I have successfully generated composer rest api followed by instruction given by https://hyperledger.github.io/composer/latest/tutorials/developer-tutorial.html finally am getting success message
Discovering types from business network definition ...
Discovered types from business network definition
Generating schemas for all types in business network definition ...
Generated schemas for all types in business network definition
Adding schemas for all types to Loopback ...
Added schemas for all types to Loopback
Web server listening at: http://localhost:3000
Browse your REST API at http://localhost:3000/explorer
and after am adding participant getting 200 response code in api , but the added data not displayed in composer playground, whats the issue in this? anyhelp appreciated
I think there is a problem with your starting a business-network or upgrading a business-network. please ensure that your started network version same as composer-rest-server API version shown on http://localhost:3000/explorer/. If there is an issue then you can do ./stopFabric.sh. and then start your business-network again.
the playground is exactly what it says, a playground. It's a little environment to help you play with models, test them and create a bna from the result, not to deploy a fully working network.
However, if you do want to see some real data then you have to connect it to an actual network using a proper network card. If you use the web version then that's not connected to anything real.
So, connect the playground to the same network card you used to create the composer rest api and then you will be able to see something.
This being said, the best way to check your data actually exists on the ledger is to use the composer api you used to create you assets.
Every asset endpoint accepts all the verbs you need to work with. You used POST to create an asset, now use the GET method to check the data on the ledger. if you look at the swagger interface, you will see all endpoint, all verbs they accept and the data models required
Related
We just installed and configured Qlik Sense of a machine with all the necessary steps and everything is correct, because we tested using the QRS API about endpoint ( /about ). We are using Java so the QRS API it's the desired option
My question is the following : when a user makes an account into our application we want to create for him an app in Qlik Sense with his username using QRS API but the documentation isn't very clear about the endpoints and data we need to provide.
https://help.qlik.com/en-US/sense-developer/April2020/Subsystems/RepositoryServiceAPI/Content/Sense_RepositoryServiceAPI/RepositoryServiceAPI-App-Upload-App.htm
Here it says that we need to provide a QVF file but we don't know where we should get that file
Can you please provide us with a step by step guide on how to achieve this as we are new to this platform ?
The Engine is responsible for the app creation. The Repository can only import already existing apps (qvf files)
Most of the Engine API is websocket JSON API but Qlik is exposing small subset of the Engine API as REST as well
In your case I think you can use POST /v1/apps method to create an app
If you do prefer to use the websocket API you can have a look at Create an app example
I'm confused about Firebase and serverless in general, as I was just introduced to this concept recently (note that I'm still studying computer science and I'm just exploring on my own now).
In the past I've been part of a project that had the following structure:
Front End in a Single-page-app
Back End built as a REST API
Now let's say I want to build a product, that might have a website and mobile apps. It also has to have backend logic as there are accounts, objects owned by users, and possible integration with a payment service.
What I initially expected from this, before knowning about serverless, is that you build a backend using something like Go (was my case), where you handle all the database data and third-party integrations, build a front end with something like Vue, and then use the backend's REST API to communicate between both of them.
Is this still the case with serverless? Do you build the whole backend server code, or does it work in another way?
I don't need/want you to explain all of it to me. I just need some insight on what is done and common so I can investigate further.
I'm trying to follow this guide: https://console.bluemix.net/docs/services/IoT/GA_information_management/ga_im_index_scenario.html#scenario
But as soon as I hit "Manage Schemas" in the device type section I get an "Internal Error", saying I should contact the Admin... I'm not able to create schemas. What's going wrong?
Thanks in advance!
Tom
It is not entirely clear what you are trying to achieve. If you are simply trying to retrieve the raw events that have been published by your device, then you need to use a URL for the form:
/api/v0002/device/types/{deviceType}/devices/{deviceId}/events/{eventName}
This is documented in the Watson IoT Platform API reference.
It is worth noting that, if this is all you are trying to achieve, you do not need to follow the guide that you referenced. It is possible to retrieve the raw events using the REST API simply by defining the Device Type and registering your device.
The guide that you referenced describes the Data Management capabilities of the Watson IoT Platform. These capabilities allow you to process the raw events in order to generate/compute state for the device. This is more involved than simply retrieving the raw events because you need to configure schemas for the events and the state and then define the mappings that tell the platform how to compute the properties on the state when an event is received. The computed state for a device is a different resource and needs to be retrieved using a different URL:
GET /api/v0002/device/types/{typeId}/devices/{deviceId}/state/{logicalInterfaceId}
This is documented here
It's a little confusing, but that Manage Schemas section of the UI is not related to the feature you're looking at as part of the guide you referred to.
The guide you're looking at outlines how to configure event schemas and logical interface schemas for a Device Type using REST API calls. If you wish to create this configuration using the web UI, this is possible too but you need to get to the Interfaces section from the Device Types view: see this image
In this case, I clicked on the Humidity Sensor Device Type and then, in the expanded view, clicked on the Interface tab. From there you can use the Simple or Advanced flows to create the configuration.
The reason for the error is because the component that provides the function on that page (Real time insights) is not present in the eu-de region. The page should not be present but for some reason is.
If you are planning on following that guide then this is a different part of the UI from the “manage schemas” page, and is located under the “interfaces” section in “device types”. The function defined in that guide is available in eu-de.
For our Web api project we use the following url versioning system:
https://{fqdn}/{apiVersion}/{apiResourceName}/{resourcePath}?{parameters}
for instance we can have something like the following:
https://myapi.mysite.com/v1/customer/2
Now considering above, let say you want to release two versions (live,test) to the customer. One live version (working with live data) and the other one is the test (working with test data for customer development test).
For live one I could easily use the one I mentioned : https://myapi.mysite.com/v1/customer/2 .
How do you name the test version of the above api? what is the test version of a api url version v1? Can specify the test api url?
Also what are best practices for fully qualified domain name of the API {fqdn} when using url versioning?
There are really several ways to do this.
One way, for instance, is to simply use attribute routing to give it a different path. Create a separate method, give it a path of /vtest/customer/2 for example and if users access this /vtest/ version (or v2 or 3 or whatever) then return the test data/new version. See an example in this question
Another way is to host your "test data" API in a different application in your server and have your web.config point to test versions of your database/source data. Using IIS, you'd configure two different applications (one for test, other for live) and the base URL would differ e.g.: https://myapi.mysite.com/appname1/v1/customer/2 vs https://myapi.mysite.com/appname2/v1/customer/2 and your appname could be something like live vs test. Have a look at this simple example
You could also just host them in different servers altogether, which would result in your {fqdn} changing between test and live versions (e.g. server.com/v1/customer/2 vs testserver.com/v1/customer/2) - this is what I do at my current job, and I find it very effective as it isolates live/test data (and API versions) avoiding confusion between them.
I also found this blog post detailing how to do this with namespaces
In other words there isn't just one best/correct way to do what you want, it all boils down to how you (or your company/boss/team) wants to structure and control test vs live data in your APIs. Take a look at these options to see which one is best in your case, hope I was able to help.
I think the title of your question is misleading. The problem you are trying to solve is not versioning (because your client is connecting to the same version of your application: v1). It is about having multiple environments: one for live data and one (or more) for test data.
At my company we solve this issue through the host name. At https://live.mysite.com/api/v1 we host v1 of the API connected to live data. At https://nodex.mysite.com/api/v1 we host v1 of the API connected to test data. Our clients can request new nodes as necessary (e.g. client1-devnode.mysite.com/api/v1 to develop against, and client1-testnode.mysite.com/api/v1 to test against. Each node get it's own set of test data.
Most of the live projects different server for different environments.
Instead of using different version of API endpoints, You should use different servers for different environment like this :
For Prod/live : https://myapi.mysite.com/v1/customer/2
For Test : https://myapi.mysitetest.com/v1/customer/2
For Dev : https://myapi.mysitedev.com/v1/customer/2
You need to configure environment specific properties for different backend endpoints you are hitting. Like : test.properties/dev.properties/live.properties
With my experience in API developing i found that there are 2 way of making server (test/developer)/live
I will show an example with your link type
https://{fqdn}/{apiVersion}/{apiResourceName}/{resourcePath}?{parameters}
In your case you can use or settings based and Link based testing type
What is settings based?
Settings based is that your server for example https://rest.mysite.com/v1/customer/2
will acting as test if you or your customer will set in he's settings server status to test and if as live - status to live.
This method is good in some cases but in order to test and to have live in same time,- this type not recommended.
What is link|URL|URI based?
This method have 2 types of identifying request is test or live
One way is to set test as a parameter https://api.mysite.com/test/v1/customer/2 and without test it goes to live
Second way is to set api to testApi or apiTest for example https://testapi.mysite.com/v1/customer/2 or https://apitest.mysite.com/v1/customer/2 . This way customer have both test and live and he can do testing and having live project too.
And don`t forget for security always check customer and verify before giving live api access.
As an option you may use custom defined header. If request contains custom header -> redirect request to test version of API.
I'm pretty new with an Ember so for the start I have a noob question - is it possible to use Local Storage and REST adapter at the same time?
For example, if I want to do a login via API, if login is success the server will return an API key which is used for later communication with a service. Is it possible to store that information locally on the client and to retrieve it when necessary but also, for other models, to use REST adapter?
If this is not a good way to handle such case, which one would you propose and is there any kind of example which would me lead me in the right direction?
Thanks to the people from #emberjs, I found out that there is a wonderful ember-auth authentication framework for the Ember.js which does what I need.