Are the rules about Amadeus seatmaps conversion to another standard (say used by star alliance) documented somewhere ? We need to provide some seatmaps in the Amadeus format from another provider.
Related
I am working on Google map places API and I am new to this. I created a sample project where I am able to retrieve latitudes and longitudes of nearby restaurants. But now I want to retrieve tattoo shops near by. But "tattoo shops" are not the supported type in google places API. Can some one tell me how to do that. I couldnot find any way of doing it.
Simply use keyword=tattoo+shops rather than type=restaurant in your request.
(I'm assuming you're using Nearby Search in the Google Places API Web Service.)
I still don't know if google maps API uses the SOAP protocol or if it's a RESTful service. I've read its documentation but it doesn't say anything about that.
I know this is an old question but I wanted to try to give an answer anyway, because I do not agree with the logic in #Brick's answer (supports JSON and XML, therefore is RESTful).
There are quite a few different Google Maps APIs, so it is hard to answer your question without you specifying which one you mean. However, for an API to be RESTful, it has to comply with the following five or six constraints:
Client-Server
Stateless
Cacheable
Layered system
Code on demand (optional)
Uniform interface
So an API supporting JSON and XML might, or might not be, RESTful, depending if it complies with the constraints above.
I think Google Maps API is not a REST API.
Google maps API give us tools, methods and objects, when we include its API, We can use these methods to build a map, we need to give data to these objects in order to build our map.
So, we are not really asking for a REST resource, we don't use a REST client to access it and we don't get json or xml data.
A rest API works with standard HTTP methods (like GET, PUT, POST, and DELETE) and returns/add/edit/delete data from its resource.
REST does not enforces message format as XML or JSON or
but it supports both. But SOAP is XML based message protocol it doesnt support JSON.
Since Google Map APIs support both json and xml , it can be safely said they they are implemented in REST.
Further if you look at the URI of google map api , you will see that they are resources based just like REST URI should be ,for example to get the directions resource you hit this URI
- https://maps.googleapis.com/maps/api/directions/json?origin=Boston,MA&destination=Concord,MA&waypoints=Charlestown,MA|Lexington,MA&key=YOUR_API_KEY
It's a general question for any programming language that can use google maps api...
Is there a way i can get specific locations provided by web sites that use google maps with their own location marks or location info.
For example yellow pages will offer locations that you won't get if you search for it simply from the official google maps web site.
What if also this website doesn't provide API to parse data from?
For further example , a web site may have a map having all locations of restaurants in Canada for instance so i want to get the same information in this map to import it in my map inside my application.
The sites you are referring to have the address and geocode information in their own database. They send you the data in response to your request and render it on the map in your browser using the client-side script API that google map provides.
If that's the case and the site didn't provide a public data service, then no, you can't get those data using the normal way.
I am working in Yii-php framework. I am creating function which will retrive weather related information from some weather websites suppose weather.com
So in Yii, how to receive weather related information from certain site and display it on view.
Can we make use of webservice for this?
check This extension NOAA Weather Extension
The NOAA Weather Extension works with data provided by the U.S. National Oceanic and Atmospheric Administration (NOAA) and the National Weather Service (NWS). Features include:
List item
Pre-made weather widgets you can quickly add to your site Data
providers that allow full access to raw weather data Intelligent
download retry and cache behaviors Unlike proprietary services, all
weather data is in the public domain
What things should a developer designing and implementing an API for a community based website know before starting the heavy coding? There are a bunch of APIs out there like Twitter API, Facebook API, Flickr API, etc which are all good examples. But how would you build your own API?
What technologies would you use? I think it's a good idea to use REST-like interface so that the API is accessible from different platforms/clients/browsers/command line tools (like curl). Am I right? I know that all the principles of web development should be met like caching, availability, scalability, security, protection against potential DOS attacks, validation, etc. And when it comes to APIs some of the most important things are backward compatibility and documentation. Am I missing something?
On the other hand, thinking from user's point of view (I mean the developer who is going to use your API), what would you look for in an API? Good documentation? Lots of code samples?
This question was inspired by Joel Coehoorn's question "What should a developer know before building a public web site?".
This question is a community wiki, so I hope you will help me put in one place all the things that should be addressed when building an API for a community based website.
If you really want to define a REST api, then do the following:
forget all technology issues other than HTTP and media types.
Identify the major use cases where a client will interact with the API
Write client code that perform those "use cases" against a hypothetical HTTP server. The only information that client should start with is the response from a GET request to the root API url. The client should identify the media-type of the response from the HTTP content-type header and it should parse the response. That response should contain links to other resources that allow the client to perform all of the APIs required operations.
When creating a REST api it is easier to think of it as a "user interface" for a machine rather than exposing an object model or process model. Imagine the machine navigating the api programmatically by retrieving a response, following a link, processing the response and following the next link. The client should never construct a URL based on its knowledge of how the server organizes resources.
How those links are formatted and identified is critical. The most important decision you will make in defining a REST API is your choice of media types. You either need to find standard ways of representing that link information (think Atom, microformats, atom link-relations, Html5 link relations) or if you have specialized needs and you don't need really wide reach to many clients, then you could create your own media-types.
Document how those media types are structured and what links/link-relations they may contain. Specific information about media types is critical to the client. Having a server return Content-Type:application/xml is useless to a client if it wants to do anything more than parse the response. The client cannot know what is contained in a response of type application/xml. Some people do believe you can use XML schema to define this but there are several disadvantages to this and it violates the REST "self-descriptive message" constraint.
Remember that what the URL looks like has absolutely no bearing on how the client should operate. The only exception to this, is that a media type may specify the use of templated URIs and may define parameters of those templates. The structure of the URL will become significant when it comes to choosing a server side framework. The server controls the URL structure, the client should not care. However, do not let the server side framework dictate how the client interacts with the API and be very cautious about choosing a framework that requires you to change your API. HTTP should be the only constraint regarding the client/server interaction.