My team and I use Postman when we work on a project with a REST server.
I'm generally the one that builds out the REST server and has all the requests mapped in Postman which I export the collection and commit it in git so the rest of the team stays up-to-date and can do their own tests whilst developing the clients to consume the REST server.
I have been looking at PAW for a while and I have two questions:
Can you create a project and share it with a team which it syncs to everyone on the project OR can you export a project and put it in git which the team can import updates to stay up-to-date?
As I'm not sure if everyone in the team will out lay the money to buy the app, can you export from Paw and import into Postman?
Thanks
In response to:
As I'm not sure if everyone in the team will out lay the money to buy the app, can you export from Paw and import into Postman?
You can import your Paw requests into Postman using cURL requests.
Just make sure to grab the cURL Code Generator from the Paw Extension page, and export your cURL Request.
Then import it into Postman as shown:
Export from Paw:
File -> Export All Requests ->
You get presented a short list of already installed exporters followed by the section Available Online showing more export formats. Choose Postman 2.0. The plugin is installed on-the-fly and a JSON file is exported.
Import to Postman:
Import -> Import File ->
Drag exported JSON file into import window.
If I am not too late, you can now do all of the above using Postman Cloud.
https://www.getpostman.com/plans/cloud-basic
Related
I've already gotten my fair share of Bootstrap and Django but never tried out other frontend frameworks like Angular, React, etc. and finally wanted to try SvelteKit. So I'm really inexperienced and new with this sort of stuff.
Currently I've already set-up my Django project as well as a SvelteKit project by following the tutorial on their website.
My problem is that I'm confused about how to combine Django and SvelteKit now. Do I just run both servers simultaneously on different ports and get the data from Django JSON APIs into my Svelte frontend or is there some kind of approach to this? I thought that maybe there's a way to get my Django app to render the Svelte files from the Svelte server for me. I just feel really lost at the moment so if anyone could help me or has some resources I could read to get more familiar with the topic, since I didn't find a lot online, that'd be great!
Many thanks in advance!
First, understand the difference between Svelte and SvelteKit. SvelteKit is a front-end + server solution that is a layer above vanilla Svelte. SvelteKit adds things like routing and support for sever(less) functions.
If you want to use Django for all your server-side processing, you should just use (vanilla) Svelte to write independent web components that you call from html served by Django. No need to use SvelteKit if you aren't using any of the extra framework features.
How to write a web component with vanilla Svelte
How to write a web component with SvelteKit.
If you want to just write your API's in Django and do everything else from SvelteKit, I would run both Django and SvelteKit servers from different subdomains and/or ports. Like django.example.com and kit.example.com or example.com:8000 and example.com:3000.
SvelteKit also provides a low-level handle() hook that can bypass SvelteKit, but usually JS/node.js is still used. I think it would be tricky to pass a request from SvelteKit to Django.
I find myself having the same question, it's not perfect but I got it to work with the following:
Create a directory that will contain everything, e.g. my-project
Inside the directory create your Django project, e.g. django-svelte, with django-admin startproject django-svelte
From my-project/django-svelte create an app to contain the svelte app, e.g. frontend, with python manage.py startapp frontend
Inside frontend create two subdirectories templates and static; inside each of them create a frontend directory. (You should have frontend/templates/frontend and frontend/static/frontend in the end)
Inside my-project initialize a svelte-kit project, e.g. client, with npm init svelte client
Inside client install all packages and add #sveltejs/adapter-static with npm install and npm i -D #sveltejs/adapter-static
Replace the content of svelte.config.js with:
import adapter from '#sveltejs/adapter-static';
export default {
kit: {
paths: { base: "/static/frontend" }, // Adjust according to where you collect static files and the name of the Django app
adapter: adapter({
pages: '../django-svelte/frontend/templates/frontend', // Adjust according to the name of the Django app
assets: '../django-svelte/frontend/static/frontend', // Adjust according to the name of the Django app
fallback: null,
precompress: false
}),
prerender: {
// This can be false if you're using a fallback (i.e. SPA mode)
default: true
}
}
};
This will write your HTML, JS and CSS files inside the frontend app.
Create a build with npm run build
Collect static files in Django with python manage.py collectstatic
Run Django with python manage.py runserver or other servers
I'm sure there are simpler ways though :-)
I made a simple template for svelte and django. please check this link: https://github.com/Pei2tech/svelte4django. What you need to add routing to support svelte instead of using sveltekit.
I am developing a REST API using C#/ASP .NET Core. As part of this, I am using Swagger to generate OpenAPI specifications to represent all of the models and endpoints that this API exposes.
When I want to test these endpoints locally using Postman, I need to go through the process of opening the web browser to https://localhost:xxxx/swagger/v1/swagger.json to access the spec, I then need to copy it, go to Postman and follow Collections -> Import -> Raw text -> paste -> Continue. Then I need to set the global collection variables like the URL over and over as it's wiped every time a new collection is imported.
This gets very arduous when you are making quick small changes that need to be tested.
Is there any way to get Postman to automatically update its copy of a collection when a new local build of the ASP .NET Core solution succeeds? Or the reverse - somehow getting Visual Studio to 'push' the updated local spec to Postman?
I know this may be a stretch, just wondering if anyone else has come across this problem before. Thanks!
Where does the standalone Postman client for Windows save collections when working offline?
To clarify, I want to find where Postman saves collection files to by default when online syncing is disabled. I am not trying to export my collection as a JSON file.
I've looked in %LocalAppData%, My Documents, and Program Files, but I don't see where Postman saves its collection data.
It looks like Postman uses LevelDB. On Windows, I found my Postman DB located at:
%HOMEPATH%\AppData\Roaming\Postman\IndexedDB\
ps: %HOMEPATH% is path for C:\Users\xxxx\
also worth mentioning: %APPDATA% is a shortcut for C:\Users\xxxx\AppData\Roaming\
According to Piere F, macOS users can find it under:
~/Library/Application Support/Postman/IndexedDB
ps: Note ~ is path for /Users/userAccount/
According to David, Ubuntu users can find it under:
~/.config/Postman/IndexedDB
Postman is using Chromium offline storage capabilities because at the end it's a SPA running inside Chromium (Electron technology).
From Postman's top menubar:
Select View → Show Dev Tools
Select the Application tab
In the sidebar, open Storage → IndexedDB → postman - file:// → collection_requests
In windows, postman v9.6.2 I was able to restore collections by pasting the IndexedDB folder in the following path:
\AppData\Roaming\Postman\Partitions\<GUID>\
On Mac: The json files were automatically backed up (/Users//Library/Application Support/Postman/backup-YYYY-MM-DDTHH:mm:ss.SSSZ.json) but it is not documented anywhere.
You just have to reimport them
This support documentation helped me recover my collections after the postman application stopped working.
https://support.postman.com/hc/en-us/articles/360035071313-How-to-recover-my-data-
If you weren't logged in to the app and using it offline or in the
Scratch Pad mode then your data won't get synced to our servers and
stays local to your instance. In this case, try following the steps
below:
Look for the backup files under the following folder:
%appdata%\Postman\for Windows ~/Library/Application
Support/Postmanfor macOS ~/.config/Postman for Linux
Backup file names will be similar to
backup-2020-02-26T23-13-43.082Z.json (date or time will be different
for you).
Alternatively, if you just want to look at the collection, you can export it into json format from the collection menu.
We work offline. So for Postman Scratchpad (official offline usage):
On Windows: %HOMEPATH%\AppData\Roaming\Postman\Partitions\
On Mac: ~/Library/Application Support/Postman/Partitions/
Simply backup or share the entire directory when you want to synch.
For the version Postman from Google Chrome extension, you need copy all files from path:
"%LOCALAPPDATA%\Google\Chrome\User Data\Default\Storage\ext\fhbjgbiflinjbdggehcddcbncdddomop\def\IndexedDB\chrome-extension_..."
The files inside path above contains all history and collections from Postman
Linux Chrome or Chromium Postman extension storage path Location
/home/{USER}/.config/chromium/Default/Storage/ext/fhbjgbiflinjbdggehcddcbncdddomop/
Thanks.
If you are using a snapped Postman on Linux, let me save you some time.
Copy all the content from your source snapped Postman UNDER (as the target GUID can be different)
/home/username/snap/postman/<id>/.config/Postman/Partitions/<standalone GUID>
to your target snapped Postman UNDER
/home/username/snap/postman/<a different id>/.config/Postman/Partitions/<a different standalone GUID>
Make sure you respect the target postman id and partition GUID.
Win10:
You have to back up your old Postman
C:\Users%user%\AppData\Roaming\Postman\IndexedDB
Then copy it to the same location of the new Postman installation.
This will recover all your collections.
In Debian-like systems, using Postman v7, I found a backup of all the collections and environments saved as JSON in ~/.config/Postman with the prefix backup-.
eg: ~/.config/Postman/backup-timestamp.json
Also, found a recent support article in Postman documentation:
How to recover my data
Windows 10, I copy these folder to another and worked.
C:\Users<username>\AppData\Local\Google\Chrome\User Data\Default\IndexedDB\chrome-extension_coohjcphdfgbiolnekdpbcijmhambjff_0.indexeddb.leveldb
Maybe anyone known how can I import postman collection into the SoapUI rest project. I just find reverse import way here: http://blog.getpostman.com/2016/04/27/importing-soapui-projects-into-postman/
May be I should import Postman collection in intermediate state(for example *.xml or *.json format) and after that import in to SoapUI?
Smartbear developed a postman plugin for Ready!API:
https://github.com/SmartBear/readyapi-postman-plugin
Since the question is specifically about SoapUI, here are a few options:
upgrade to Ready!API;
get the trial version of Ready!API and import all your collections before the trial expires;
adapt the source code from GitHub to generate a soapUI project (xml) file from the json postman export.
One thing to note, a project saved in Ready!API can be opened in SoapUI and vice-versa.
I know it's been years, but if someone has a similar problem, here is an explanation specifically for SOAPui and not by using ReadyAPI: https://www.soapui.org/docs/postman-collections.html
You also have to have the latest version 5.5 of SOAPui.
I would like to work with the Google Admin SDK and get information about our domain's email settings per user. I refer to Developer's Guide | Email Settings API
I am comfortable approaching the problem in Java, Python, and C# and all three languages have examples included in the documentation.
Where can I get all these libraries shown in the documentation?
C#
using Google.GData.Apps;
using Google.GData.Apps.GoogleMailSettings;
using Google.GData.Client;
using Google.GData.Extensions;
Java
import sample.appsforyourdomain.gmailsettings.GmailSettingsService;
Python
import gdata.apps.emailsettings.client
They are located here:
https://developers.google.com/admin-sdk/directory/v1/libraries
If you work through the Java QuickStart, these three imports aren't included and the provided quick start code won't compile.
import com.google.api.services.admin.directory.DirectoryScopes;
import com.google.api.services.admin.directory.model.*;
import com.google.api.services.admin.directory.Directory;
It seems the Java portion of this project is in need of an update.
Note the Maven and Gradle builds on the Java download page - https://developers.google.com/api-client-library/java/apis/admin/directory_v1 - show this error message:
This library is in the process of uploading to the central Maven repository. Please check back in a few hours.
I've seen that message there for a couple months now.
There are basically 2 kinds of APIs for Google Apps. The old style "GData" Atom based APIs and the new API Discovery Service compliant "Google APIs" (modern infra).
The Email Settings API is an old style GData API so you need the GData API client libraries.
The GData API client libraries are available for download from here:
https://developers.google.com/gdata/docs/client-libraries