def get(klass, options = {}): if isinstance(options, str): options = { 'access_token': options } options = util.merge_dict({ 'schema': 'openid' }, options) return klass.post(klass.path, options)
def get(cls, options=None, api=None): options = options or {} if isinstance(options, string_types): options = {'access_token': options} options = util.merge_dict({'schema': 'openid'}, options) api = api or default_api() return cls.post(cls.path, options, api=api)
def request(self, url, method, body=None, headers=None, refresh_token=None): """Make HTTP call, formats response and does error handling. Uses http_call method in API class. Usage:: >>> api.request("https://api.sandbox.paypal.com/v1/payments/payment?count=10", "GET", {}) >>> api.request("https://api.sandbox.paypal.com/v1/payments/payment", "POST", "{}", {} ) """ http_headers = util.merge_dict( self.headers(refresh_token=refresh_token, headers=headers or {}), headers or {}) if http_headers.get('PayPal-Request-Id'): log.info('PayPal-Request-Id: %s' % (http_headers['PayPal-Request-Id'])) self._check_openssl_version() try: return self.http_call(url, method, data=json.dumps(body), headers=http_headers) # Format Error message for bad request except exceptions.BadRequest as error: return {"error": json.loads(error.content)} # Handle Expired token except exceptions.UnauthorizedAccess as error: if(self.token_hash and self.client_id): self.token_hash = None return self.request(url, method, body, headers) else: raise error
def logout_url(options=None): options = util.merge_dict( { 'logout': 'true', 'redirect_uri': redirect_uri() }, options or {}) return session_url(end_session_path, options)
def logout_url(options={}): options = util.merge_dict( { 'logout': 'true', 'redirect_uri': redirect_uri() }, options) return util.join_url_params(end_session_path, options)
def logout_url(options=None): options = options or {} options = util.merge_dict({ 'logout': 'true', 'redirect_uri': redirect_uri() }, options) return session_url(end_session_path, options)
def get(cls, options=None): options = options or {} if isinstance(options, string_types): options = {'access_token': options} options = util.merge_dict({'schema': 'openid'}, options) return cls.post(cls.path, options)
def get(klass, options={}): if isinstance(options, str): options = {'access_token': options} options = util.merge_dict({'schema': 'openid'}, options) return klass.post(klass.path, options)
def __init__(self, options=None, **kwargs): """Create API object Usage:: >>> import paypalrestsdk >>> api = paypalrestsdk.Api(mode="sandbox", client_id='CLIENT_ID', client_secret='CLIENT_SECRET', ssl_options={"cert": "/path/to/server.pem"}) """ kwargs = util.merge_dict(options or {}, kwargs) self.mode = kwargs.get("mode", "sandbox") self.endpoint = kwargs.get("endpoint", self.default_endpoint()) self.token_endpoint = kwargs.get("token_endpoint", self.endpoint) # Mandatory parameter, so not using `dict.get` self.client_id = kwargs["client_id"] # Mandatory parameter, so not using `dict.get` self.client_secret = kwargs["client_secret"] self.proxies = kwargs.get("proxies", None) self.token_hash = None self.token_request_at = None # setup SSL certificate verification if private certificate provided ssl_options = kwargs.get("ssl_options", {}) if "cert" in ssl_options: os.environ["REQUESTS_CA_BUNDLE"] = ssl_options["cert"] if kwargs.get("token"): self.token_hash = { "access_token": kwargs["token"], "token_type": "Bearer" } self.options = kwargs
def __init__(self, options=None, **kwargs): """Create API object Usage:: >>> import paypalrestsdk >>> api = paypalrestsdk.Api(mode="sandbox", client_id='CLIENT_ID', client_secret='CLIENT_SECRET', ssl_options={"cert": "/path/to/server.pem"}) """ kwargs = util.merge_dict(options or {}, kwargs) self.mode = kwargs.get("mode", "sandbox") self.endpoint = kwargs.get("endpoint", self.default_endpoint()) self.token_endpoint = kwargs.get("token_endpoint", self.endpoint) # Mandatory parameter, so not using `dict.get` self.client_id = kwargs["client_id"] # Mandatory parameter, so not using `dict.get` self.client_secret = kwargs["client_secret"] self.proxies = kwargs.get("proxies", None) self.token_hash = None self.token_request_at = None # setup SSL certificate verification if private certificate provided ssl_options = kwargs.get("ssl_options", {}) if "cert" in ssl_options: os.environ["REQUESTS_CA_BUNDLE"] = ssl_options["cert"] if kwargs.get("token"): self.token_hash = { "access_token": kwargs["token"], "token_type": "Bearer"} self.options = kwargs
def create(self, refresh_token=None, correlation_id=None): """Creates a resource e.g. payment Usage:: >>> payment = Payment({}) >>> payment.create() # return True or False """ headers = {} if correlation_id is not None: headers = util.merge_dict( self.http_headers(), { 'Paypal-Application-Correlation-Id': correlation_id, 'Paypal-Client-Metadata-Id': correlation_id }) else: headers = self.http_headers() new_attributes = self.api.post(self.path, self.to_dict(), headers, refresh_token) ## Patch for v2 new_attributes["id"] = new_attributes["href"].split("/")[-1] self.error = None self.merge(new_attributes) return self.success()
def logout_url(options=None, api=None): api = api or default_api() options = util.merge_dict({ 'logout': 'true', 'redirect_uri': redirect_uri(api) }, options or {}) return session_url(end_session_path, options, api=api)
def authorize_url(options = {}): options = util.merge_dict({ 'response_type': 'code', 'scope': 'openid', 'client_id': client_id(), 'redirect_uri': redirect_uri() }, options) return util.join_url_params(start_session_path, options)
def post(cls, action, options=None, headers=None): url = util.join_url(endpoint(), action) body = util.urlencode(options or {}) headers = util.merge_dict({ 'User-Agent': cls.user_agent, 'Content-Type': 'application/x-www-form-urlencoded'}, headers or {}) data = api.default().http_call(url, 'POST', data=body, headers=headers) return cls(data)
def authorize_url(options=None): options = util.merge_dict({ 'response_type': 'code', 'scope': 'openid', 'client_id': client_id(), 'redirect_uri': redirect_uri() }, options or {}) return session_url(start_session_path, options)
def authorize_url(options=None): options = options or {} options = util.merge_dict({ 'response_type': 'code', 'scope': 'openid', 'client_id': client_id(), 'redirect_uri': redirect_uri() }, options) return session_url(start_session_path, options)
def create(klass, options = {}): if isinstance(options, str): options = { 'code': options } options = util.merge_dict({ 'grant_type': 'authorization_code', 'client_id': client_id(), 'client_secret': client_secret() }, options) return klass.post(klass.path, options)
def create_with_refresh_token(klass, options = {}): if isinstance(options, str): options = { 'refresh_token': options } options = util.merge_dict({ 'grant_type': 'refresh_token', 'client_id': client_id(), 'client_secret': client_secret() }, options) return klass.post(klass.path, options)
def create_with_refresh_token(cls, options=None, api=None): options = options or {} api = api or default_api() if isinstance(options, string_types): options = {'refresh_token': options} options = util.merge_dict({ 'grant_type': 'refresh_token', 'client_id': client_id(api), 'client_secret': client_secret(api) }, options) return cls.post(cls.path, options, api=api)
def create(cls, options=None, api=None): options = options or {} api = api or default_api() if isinstance(options, string_types): options = {'code': options} options = util.merge_dict({ 'grant_type': 'authorization_code', 'client_id': client_id(api), 'client_secret': client_secret(api) }, options) return cls.post(cls.path, options, api=api)
def create(klass, options={}): if isinstance(options, str): options = {'code': options} options = util.merge_dict( { 'grant_type': 'authorization_code', 'client_id': client_id(), 'client_secret': client_secret() }, options) return klass.post(klass.path, options)
def create(cls, options=None): options = options or {} if isinstance(options, string_types): options = {'code': options} options = util.merge_dict({ 'grant_type': 'authorization_code', 'client_id': client_id(), 'client_secret': client_secret() }, options) return cls.post(cls.path, options)
def create_with_refresh_token(cls, options=None): options = options or {} if isinstance(options, string_types): options = {'refresh_token': options} options = util.merge_dict({ 'grant_type': 'refresh_token', 'client_id': client_id(), 'client_secret': client_secret() }, options) return cls.post(cls.path, options)
def create_with_refresh_token(klass, options={}): if isinstance(options, str): options = {'refresh_token': options} options = util.merge_dict( { 'grant_type': 'refresh_token', 'client_id': client_id(), 'client_secret': client_secret() }, options) return klass.post(klass.path, options)
def get_token_hash(self, authorization_code=None, refresh_token=None, headers=None): """Generate new token by making a POST request 1. By using client credentials if validate_token_hash finds token to be invalid. This is useful during web flow so that an already authenticated user is not reprompted for login 2. Exchange authorization_code from mobile device for a long living refresh token that can be used to charge user who has consented to future payments 3. Exchange refresh_token for the user for a access_token of type Bearer which can be passed in to charge user """ path = "/v1/oauth2/token" payload = "grant_type=client_credentials" if authorization_code is not None: payload = "grant_type=authorization_code&response_type=token&redirect_uri=urn:ietf:wg:oauth:2.0:oob&code=" + \ authorization_code elif refresh_token is not None: payload = "grant_type=refresh_token&refresh_token=" + refresh_token else: self.validate_token_hash() if self.token_hash is not None: # return cached copy return self.token_hash token = self.http_call( util.join_url(self.token_endpoint, path), "POST", data=payload, headers=util.merge_dict( { "Authorization": ("Basic %s" % self.basic_auth()), "Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json", "User-Agent": self.user_agent }, headers or {}), timeout=__default_timeout__) if refresh_token is None and authorization_code is None: # cache token for re-use in normal case self.token_request_at = datetime.datetime.now() self.token_hash = token return token
def __init__(self, options = {}, **args): args = util.merge_dict(options, args) self.mode = args.get("mode", "sandbox") self.endpoint = args.get("endpoint", self.default_endpoint()) self.token_endpoint = args.get("token_endpoint", self.endpoint) self.client_id = args.get("client_id") self.client_secret = args.get("client_secret") self.ssl_options = args.get("ssl_options", {}) self.token_hash = None self.token_request_at = None if args.get("token"): self.token_hash = { "access_token": args.get("token"), "token_type": "Bearer" } self.options = args
def __init__(self, options=None, **args): args = util.merge_dict(options or {}, args) self.mode = args.get("mode", "sandbox") self.endpoint = args.get("endpoint", self.default_endpoint()) self.token_endpoint = args.get("token_endpoint", self.endpoint) self.client_id = args["client_id"] # Mandatory parameter, so not using `dict.get` self.client_secret = args["client_secret"] # Mandatory parameter, so not using `dict.get` self.ssl_options = args.get("ssl_options", {}) self.token_hash = None self.token_request_at = None if args.get("token"): self.token_hash = {"access_token": args["token"], "token_type": "Bearer"} self.options = args
def get_token_hash(self, authorization_code=None, refresh_token=None, headers=None): """Generate new token by making a POST request 1. By using client credentials if validate_token_hash finds token to be invalid. This is useful during web flow so that an already authenticated user is not reprompted for login 2. Exchange authorization_code from mobile device for a long living refresh token that can be used to charge user who has consented to future payments 3. Exchange refresh_token for the user for a access_token of type Bearer which can be passed in to charge user """ path = "/v1/oauth2/token" payload = "grant_type=client_credentials" if authorization_code is not None: payload = "grant_type=authorization_code&response_type=token&redirect_uri=urn:ietf:wg:oauth:2.0:oob&code=" + \ authorization_code elif refresh_token is not None: payload = "grant_type=refresh_token&refresh_token=" + refresh_token else: self.validate_token_hash() if self.token_hash is not None: # return cached copy return self.token_hash token = self.http_call( util.join_url(self.token_endpoint, path), "POST", data=payload, headers=util.merge_dict({ "Authorization": ("Basic %s" % self.basic_auth()), "Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json", "User-Agent": self.user_agent }, headers or {})) if refresh_token is None and authorization_code is None: # cache token for re-use in normal case self.token_request_at = datetime.datetime.now() self.token_hash = token return token
def request(self, url, method, body=None, headers=None): http_headers = util.merge_dict(self.headers(), headers or {}) if http_headers.get('PayPal-Request-Id'): logging.info('PayPal-Request-Id: %s' % (http_headers['PayPal-Request-Id'])) try: return self.http_call(url, method, body=body, headers=http_headers) # Format Error message for bad request except BadRequest as error: return {"error": json.loads(error.content)} # Handle Expired token except UnauthorizedAccess as error: if(self.token_hash and self.client_id): self.token_hash = None return self.request(url, method, body, headers) else: raise error
def request(self, url, method, body = None, headers = {}): http_headers = util.merge_dict(self.headers(), headers) if http_headers.get('PayPal-Request-Id'): logging.info('PayPal-Request-Id: %s'%(http_headers['PayPal-Request-Id'])) try: return self.http_call(url, method, body= body, headers= http_headers) # Format Error message for bad request except BadRequest as error: return { "error": json.loads(error.content) } # Handle Exipre token except UnauthorizedAccess as error: if(self.token_hash and self.client_id): self.token_hash = None return self.request(url, method, body, headers) else: raise error
def create(self, refresh_token=None, correlation_id=None): """Creates a resource e.g. payment Usage:: >>> payment = Payment({}) >>> payment.create() # return True or False """ headers = {} if correlation_id is not None: headers = util.merge_dict( self.http_headers(), {'Paypal-Application-Correlation-Id': correlation_id, 'Paypal-Client-Metadata-Id': correlation_id} ) else: headers = self.http_headers() new_attributes = self.api.post(self.path, self.to_dict(), headers, refresh_token) self.error = None self.merge(new_attributes) return self.success()
def logout_url(self, options={}): options = util.merge_dict({'id_token': self.id_token}, options) return logout_url(options)
def logout_url(options = {}): options = util.merge_dict({ 'logout': 'true', 'redirect_uri': redirect_uri() }, options) return util.join_url_params(end_session_path, options)
def http_headers(self): """Generate HTTP header """ return util.merge_dict(self.header, self.headers, {'PayPal-Request-Id': self.generate_request_id()})
def logout_url(self, options = {}): options = util.merge_dict({ 'id_token': self.id_token }, options) return logout_url(options)
def userinfo(self, options=None): return Userinfo.get(util.merge_dict({'access_token': self.access_token}, options or {}))
def refresh(self, options=None): options = util.merge_dict({'refresh_token': self.refresh_token}, options or {}) tokeninfo = self.__class__.create_with_refresh_token(options) self.merge(tokeninfo.to_dict()) return self
def logout_url(self, options=None): return logout_url(util.merge_dict({'id_token': self.id_token}, options or {}))
def refresh(self, options={}): options = util.merge_dict({'refresh_token': self.refresh_token}, options) tokeninfo = self.__class__.create_with_refresh_token(options) self.merge(tokeninfo.to_dict()) return self
def userinfo(self, options={}): options = util.merge_dict({'access_token': self.access_token}, options) return Userinfo.get(options)
def userinfo(self, options = {}): options = util.merge_dict({ 'access_token': self.access_token }, options) return Userinfo.get(options)
def logout_url(self, options=None, api=None): return logout_url(util.merge_dict({'id_token': self.id_token}, options or {}), api=api)
def refresh(self, options=None, api=None): options = util.merge_dict({'refresh_token': self.refresh_token}, options or {}) tokeninfo = self.__class__.create_with_refresh_token(options, api=api) self.merge(tokeninfo.to_dict()) return self
def http_headers(self): """Generate HTTP header """ return util.merge_dict( self.header, self.headers, {'PayPal-Request-Id': self.generate_request_id()})
def userinfo(self, options=None, api=None): return Userinfo.get(util.merge_dict({'access_token': self.access_token}, options or {}), api=api)