I'm dealing with a shopping cart system that doesn't really stay updated with the changes to PayPal's API. I have the source code and am confident enough to add/change parameters for calls (e.g. for expresscheckout) -- but some of the things I want to do are only available in newer versions of the API.
The cart PayPal PHP code sets the PayPal API version to '76' right now.
Can I safely just change it to '112' - or do I have to carefully audit and test all the existing code? In other words, is it safe to assume that PayPal's newer API versions are backward compatible with older code?
Yes, you can upgrade the API version to 113 and yes it is backward compatible and supports all existing parameters.
Note : Check this link to see the deprecated parameters that should be avoided.
Related
does anyone know the state of the Paypal .NET SDK? I just wonder, according to https://github.com/paypal/PayPal-NET-SDK/releases, the latest version is a V2.0 Release Candidate, but it is already 2 years old, and it seems like there was never an actual V2.0 release. Has this project died? Should I rather use the Paypal REST API directly?
Don't use any version of the v1 PayPal-NET-SDK (neither 1.x nor 2.0 rc2)
Use the new v2 Checkout-NET-SDK
If it does not (yet) support the API you want to integrate (e.g. the new Subscriptions API would be one example), then use direct HTTPS calls for that REST API
We are re-developing our eCommerce application and goingto use PayPal as our main gateway.
I am trying to figure out whether to use REST API or SDK.
Is SDK easier to use than REST API?
Which is better to use?
A good way to look at this is that the PayPal SDKs are built on top of the APIs (the root endpoints) in order to abstract out a lot of the complexities and keep integrations as up-to-date as possible.
If you are leveraging off of the API with your own code (and no SDK), you'll have to build out pieces for the auth (OAuth 2), in order to capture your access token, then build out calls for each endpoint that you wish to build against. Most of the time you'll see integrations like this if people want to highly customize their build against the API, or want to build in a language / integration not available in the SDKs.
The SDK will abstract out those complexities for you, so it'll definitely be the easier integration. In addition, the SDKs will be continually updated as the APIs change, so you won't have to update the code yourself to maintain that, just fetch the newest SDK version and test the integration.
If you're looking for the easiest integration, use the SDK. For Java, that's at https://github.com/paypal/PayPal-Java-SDK. There's also a number of quickstart samples at https://developer.paypal.com/docs/api/quickstart/ using the SDKs.
I have a site which tracks time spent working on projects for clients. It was created in classic Asp. I want to bill the time to the clients using the PayPal API. I am having a hard time determining which version I should use. I have read much of documentation and I am not sure which API to use (Classic vs REST).
I still prefer the Classic API. The REST API is still new to PayPal and is well behind the Classic API in terms of overall features.
A Custom object is not visible to the API (using WWW::SalesForce Perl Module), but IS visible using the debug console.
When I say "not visible", it is not queriable, and does not appear in the list returned to the
$sf->describeGlobal();
command.
The object has all related API attributes checked off. Has anyone else had this experience and been able to resolve?
The perl module you mention is pretty old and based on an old API version, your custom object is likely using a feature which makes it incompatible with older api versions, and so won't appear in them. You could possibly update the module to a newer API version (or see if it has a property to indicate which salesforce API version to use), or switch to something else, I'd imagine that calling the Salesforce REST/JSON API from Perl ought to be pretty straightforward.
We are developing an application that has an iPhone client, and a Rails server. We have released a first version, and are now starting to work on 1.1 version.
We were wondering if there are any tools (external or provided by hostingrails) to address those two basic requirements:
- development / production versions of a Rails application
- simultaneous live versions of the application (versioned APIs) for example to keep supporting older versions of the client application iPhone.
A first approach we are thinking of right now would be to duplicate the application for each version of the API we want to have, each of them being referenced by a specific URL for example: myapp.com/v1 , myapp.com/v2 ...
This entire stack would itself be duplicated in order to have a live/production version, and a development one. Once tested, the development version would be switched with the production version.
What do you think of this approach ? Are there any tools that allow to manage the lifecycle of the application ?
Does Rails has built-in features facilitating this ?
Thanks
The simplest thing would just be to keep your API backward-compatible, thus obviating the need to maintain two versions of the API, and if you must evolve it in a way that breaks backwards compatibility, deprecate the old API and give it a real termination date so that you don't support it ad infinitum.
If you absolutely have to go down this road, read Fowler's blog post on the topic first (http://martinfowler.com/bliki/TolerantReader.html) and then look at namespacing your API routes. In Rails you could accomplish this using namespaced routes and controllers, so you might have your original api at /application/endpoint and your new version at /application/v2/endpoint (I'm assuming that you can't change your endpoints for old clients easily)
I'm not aware of any tools that explicitly claim to solve the problems you're saying you want to solve, but I think that has more to do with developers working hard not to need them than the idea that they're not solvable in Rails.
Did you consider using Subdomains?: http://railscasts.com/episodes/221-subdomains-in-rails-3