I want to generate the whole action JSONs in code, and then upload them, instead of working through the console.
There is an option to download the whole package as a zipped JSON and theoretically you can also upload. That might supply a hint on how to create the JSONs.
However, these files have all kinds of IDs for the different building blocks, such as Intents or Entity. So, when I export from DialogFlow, of course I get IDs for these.
But, if I want to create a new google action, do I generate these action IDs myself?
Is there documentation on what the structure of these JSONs should be?
The format used by the export/import process is not documented, and while you can try to work with it, there is no guarantee that it will continue to work in the future.
Depending on your needs, it may be better to work with the Dialogflow API (the former API of API.ai). This provides an API to build and modify Intents and Entities (and do some other things). It isn't clear, however, that this provides access to the settings for various integrations.
Related
Since the Docs API allows for retrieval of Google Docs via JSON, is there a way to directly inject that JSON data, with alterations, into a new Google Document? I have several Google Documents that are used as templates for contract agreements, and the data points for all the information to be entered into the templates is already pre-stored in a database.
My goal would be to store the template's JSON server-side and call that data to generate a current agreement and modified agreement by iterating through the placeholder values, inserting database / user input values at those placeholders, and then creating a new Google Doc from that JSON that can be downloaded. Skipping the step of creating google-side copies, grabbing their ID's, and calling something like Batch Update
My inspiration for this came from Federico Tomassetti's post: A template system for Google Docs: Google Drive automation and PDF generation with Google Execution API.
However, Federico creates copies of the template and then fills that copy using App Scripts. I'm currently searching for a solution that would allow for Agreements to be fully generated before being inserted to reduce overhead and simplify permissions, etc. Skipping the step of creating copies and then editing.
I'm just surprised there isn't some kind of way to directly upload without having to call a GET to the template every time, creating copies, and then editing those copies via Batch Update. Hopefully I'm missing some API call that exists, but so far I haven't found anything.
I'm wondering if it's possible to make a database on parse.com available publicly for download. I have a scraper running on Google App Engine that grabs data from Kickstarter and saves it to Parse, and I want to make it available for researchers, hobbyists, etc.
This is quite broad in terms of how you want the data to be "available" to the "public".
But in general, yes this is absolutely possible. Just write a parse cloud code function that returns the data you want. Then have your frontend call that function, and your frontend will do the interpretation of how to display it (or structure it for download). This method returns JSON to be handled by the frontend.
If you want to make it available for file download (e.g. in the form of a table or something), you can use the parse rest api.
https://parse.com/docs/rest/guide#files
The procedure is to upload it, and the callback returns the url where it can be accessed. The file is public to anyone that knows the url to the file.
Recently i have been given a project that is torrent provider just like torrentz.eu, thepiratebay etc, where anyone can search what they want to download and then get the download like with the help of torrent.
I don't know the concept behind this, what is the basic requirement and what is the process to make it done. i have searched over Google but didn't find any relevant answer related to my problem.
I just want to know the process and what i really need to do to make it done. technology i will use that is spring framework.
Thanks
This is not really an Spring specific question but I'll try to help you.
You just need to save the torrent file (a text file with information needed by torrent clients) in a database along with information about the torrent like a representative name, a date and not much more. You could do this using Spring Data JPA for example. This way you won't need SQL knoledges.
If you want a site like torrentz.eu, you will also need to fetch data about the torrent like peers. You can store this also in the database but you will have to update it periodically. To do this, there are APIs like Bitsnoop that return this kind of information.
Having this, you'll need only some controller mappings to show your home and to let users search torrents given a name (the one that your saved before).
Well, first you need to know that Torrentz and ThePirateBay are 2 different things.
Torrentz is a search engine (like google) that searches for torrent files.
ThePirateBay - in past .torrent files hoster, now a simple Magnet linker.
All you need is a website with a huge .torrent files database.
Also a good hosting in a not online controlled country, so you don't get in trouble just like the most popular torrent website (thepiratebay.se / torrentz.com / kickasstorrents.com ...)
Of course they are still online, but that's just because they have a big fan base that keeps creating mirrors and proxies (https://viralifyblog.wordpress.com/2017/06/19/thepiratebay-proxy-list/)
Finally. I don't recommend creating a torrents website.
How are people managing multiple API versions with API Blueprint?
It doesn't seem that the format supports version sections within a single file, so I'm left thinking that multiple files with indicators in the filename are the best option.
We want to leverage the tools to create a central mock-server and doc commons, and will need to handle evolving multiple versions of each API.
Managing multiple versions via branches seems inconvenient for us, so we render the entire document with multiple versions of APIs in one page. Our users need to be able to read both versions by just prepending v1 or v2 in front of the URL. So, we have a node app that handles the documentation requests and renders the doc via aglio node module.
The following is how we organize the docs.
Users can request /docs/en/spec.
The en part determines the language of the document as we support different languages.
Because the entire document is pretty huge we split it into files based on the Blueprint Group (the thing that starts with # Group GroupName)
When a request comes in, we first look if we have previously compiled the doc and have a cached version, so we don't recompile every time (it's pretty intensive work especially when the doc is large).
If we have no cached version, we read all *.md files in the docs/en directory.
Sort the filenames alphabetically, concat their contents, and pass to aglio which produces a nice html content. We cache this content into a file and later pipe it to the client on each request.
The UI provides the table of contents (side menu on the left) which has, for instance, the following format.
Auth
Projects
Project Users
...
Groups
Groups v2
Now each Group of APIs has a distinct URL which is prepended with /v1 by default. When we introduce a new version of a specific API, we create a new # Group Groups v2 which is prepended with /v2. This way our users can see and choose multiple versions of the APIs in one page.
The nice things about the aglio node module is that it provide multiple themes for the UI which provides a nice navigation so that our users don't feel the page is too overloaded. Among the themes you can choose either single-page UI or multi-page UI where on selection of the API the page with the corresponding API is loaded and the URL is changed.
Implementing this logic is very simple. Hope this helps.
There is another idea which we are considering right now but haven't started just yet. It is to avoid splitting APIs into different # Groups and instead modify the Jade template used by aglio and make sure it supports multiple versions out of the box.
It might be best to version the blueprint file in a versioning repository and treat different branches as different API versions. You can even have the blueprint in the same repo/branch as the API server implementation.
If you're versioning using GitHub, Apiary can connect to GitHub and you can setup different branches to be picked up by different documentations in Apiary.
Using the jQuery wrapped version of Fineuploader v3.3.
Is it possible to populate the file list with files already in the upload folder?
I think "_addToList(id, name)" should do the trick, but I can't get it to work. Any ideas?
Seems that they are currently working on this feature:
https://github.com/Widen/fine-uploader/issues/784
So, this will be available soon.
This is not a behavior that Fine Uploader currently supports. Fine Uploader only displays files that users have submitted to the uploader since the current uploader instance was created. It doesn't try to be an all-in-one web application. You could probably add your own item to the list/UI via javascript. That probably wouldn't be terribly difficult, but seems like an odd thing to do.
If you'd like to discuss your specific use case more, please open up a feature request in the Github issue tracker.
Generally, client side code cannot add stored or hard-coded path based file names for use in any type of POST or upload operation. Obviously this is a security measure, you can imagine if a malicious web page could add to a generic POST operation some type of baked in file name. So from what I understand, only the user can specify path based file names, via a file browser for the session that it is included in. This applies to HTML/JavaScript/jQuery but am unsure if Flash/Silverlight based solutions would also be limited. I think a Java based uploader would be free of this. But you are just moving closer and closer to installed software.