def shopify_request_token(self, params): for item in self: if item.api_status == 'draft': # request mode (work) url = 'https://%s/admin/oauth/access_token' % item.url payload = { 'client_id': str(item.api_key), 'client_secret': str(item.api_secret), 'code': str(params['code']), } headers = {'Content-Type': 'application/json'} response = requests.post(url, headers=headers, data=json.dumps(payload)) if response.status_code != 200: _logger.info(response.text) else: response_json = json.loads(response.text) if 'access_token' in response_json: item.shopify_access_token = str( response_json['access_token']) # session session = shopify.Session(item.url, '2020-01', item.shopify_access_token) shopify.ShopifyResource.activate_session(session) # api_status item.api_status = 'valid'
def creat_a_product(**kwargs): session = shopify.Session(shop_url, api_version, access_token) shopify.ShopifyResource.activate_session(session) variants = [] images = [] new_product = shopify.Product() for key, value in kwargs.items(): if key == 'variants': for item in value: variant = shopify.Variant(item) variants.append(variant) value = variants elif key == 'images': for item in value: image = shopify.Image() with open(item, "rb") as f: filename = item.split("/")[-1:][0] encoded = f.read() image.attach_image(encoded, filename=filename) images.append(image) value = images setattr(new_product, key, value) new_product.save() print(new_product.id) print(new_product.to_dict())
def post(self, request, **kwargs): context = self.get_context_data(**kwargs) form = ShopForm(request.POST) if form.is_valid(): shop = form.cleaned_data['shop_name'] state = str(uuid.uuid4()) session = shopify.Session( 'https://%s.%s%s' % (shop, settings.SHOPIFY_URL, settings.SHOPIFY_AUTHORIZE_SUFIX)) session.setup(api_key=settings.SHOPIFY_API_KEY, secret=settings.SHOPIFY_SECRET) permission_url = session.create_permission_url( settings.SHOPIFY_SCOPES, request.build_absolute_uri( reverse('core:shopify_callback'))) + '&state=' + state try: response = requests.head(permission_url) if response.status_code == 404: form.add_error('shop_name', 'The shop cannot be reached.') else: request.session['state'] = state user = request.user user.shop_name = shop user.save() return redirect(permission_url) except Exception: form.add_error('shop_name', 'The shop name used is not valid.') context['form'] = form return render(request, self.template_name, context)
def sync_shopify_products(shop_url, access_token): logger.info("Sync Shopify Orders") session = shopify.Session(shop_url, settings.API_VERSION, access_token) shopify.ShopifyResource.activate_session(session) shopify_products = shopify.Product.find() not_found_products = [] for product in shopify_products: try: ShopifyProduct.objects.get(product_id=product.id) except ShopifyProduct.DoesNotExist: not_found_product = ShopifyProduct( title=product.title, vendor=product.vendor, product_id=product.id, status=product.status, product_type=product.product_type, ) not_found_products.append(not_found_product) ShopifyProduct.objects.bulk_create(not_found_products) logger.info("Products synced successfully!") return {'msg': "Products synced successfully!"}
def create_webhook(stores_obj): """ Create a shop webhook and add to store. """ try: session = shopify.Session(stores_obj.store_name, stores_obj.permanent_token) shopify.ShopifyResource.activate_session(session) topic = 'app/uninstalled' new_webhook = shopify.Webhook() new_webhook.address = settings.APP_URL + '/webhooks/' new_webhook.topic = topic # [shopify.Webhook.delete(x.id) for x in shopify.Webhook.find()] if new_webhook.save(): Webhooks.objects.update_or_create(store__store_name=stores_obj.store_name, topic=topic, defaults={'webhook_id': new_webhook.attributes['id'], 'store': stores_obj, 'topic': topic}) else: logger.error('Warning for {}. Webhook {} not saved properly!'.format(stores_obj.store_name, topic)) except Exception as e: logger.error('Exception caught for {}. {}'.format(stores_obj.store_name, e))
def setUp(self): super(GraphQLTest, self).setUp() shopify.ApiVersion.define_known_versions() shopify_session = shopify.Session("this-is-my-test-show.myshopify.com", "unstable", "token") shopify.ShopifyResource.activate_session(shopify_session) client = shopify.GraphQL() self.fake( "graphql", method="POST", code=201, headers={ "X-Shopify-Access-Token": "token", "Accept": "application/json", "Content-Type": "application/json", }, ) query = """ { shop { name id } } """ self.result = client.execute(query)
def get_access_token(request): shop_url = "https://{}:{}@{}/admin".format(settings.SHOPIFY_API_KEY, settings.SHOPIFY_API_PASSWORD, settings.SHOPIFY_STORE_DOMAIN) shopify.ShopifyResource.set_site(shop_url) shopify.Session.setup(api_key=settings.SHOPIFY_API_KEY, secret=settings.SHOPIFY_API_PASSWORD) session = shopify.Session(settings.SHOPIFY_STORE_URL) scope = [ "read_products", "write_products", "read_orders", "write_orders", "read_draft_orders", "write_draft_orders", "read_inventory", "write_inventory", "read_fulfillments", "write_fulfillments", "read_shipping", "write_shipping", "read_checkouts", "write_checkouts", ] permission_url = session.create_permission_url( scope, settings.SHOPIFY_ACCESS_REDIRECT_URL) return HttpResponseRedirect(permission_url)
def activateSession(self): if self.authToken == None: raise Exception( "Can't activate a shopify session without an authToken") session = shopify.Session(self.myshopifyDomain, self.authToken) shopify.ShopifyResource.activate_session(session)
def authenticate(request, *args, **kwargs): shop = request.REQUEST.get('shop') if settings.SHOPIFY_APP_DEV_MODE: return finalize(request, token='00000000000000000000000000000000', *args, **kwargs) if shop: redirect_uri = request.build_absolute_uri( reverse('shopify_auth.views.finalize')) scope = settings.SHOPIFY_APP_API_SCOPE permission_url = shopify.Session(shop.strip()).create_permission_url( scope, redirect_uri) if settings.SHOPIFY_APP_IS_EMBEDDED: # Embedded Apps should use a Javascript redirect. return render(request, "shopify_auth/iframe_redirect.html", {'redirect_uri': permission_url}) else: # Non-Embedded Apps should use a standard redirect. return HttpResponseRedirect(permission_url) return_address = get_return_address(request) return HttpResponseRedirect(return_address)
def _new_session(shop_url): shopify_api_version = apps.get_app_config("shopify_app").SHOPIFY_API_VERSION shopify_api_key = apps.get_app_config("shopify_app").SHOPIFY_API_KEY shopify_api_secret = apps.get_app_config("shopify_app").SHOPIFY_API_SECRET shopify.Session.setup(api_key=shopify_api_key, secret=shopify_api_secret) return shopify.Session(shop_url, shopify_api_version)
def try_connect(self, logger: AirbyteLogger, config: dict): session = shopify.Session(f"{config['shop']}.myshopify.com", "2021-01", config["api_key"]) shopify.ShopifyResource.activate_session(session) # try to read the name of the shop, which should be available with any level of permissions shopify.GraphQL().execute("{ shop { name id } }") shopify.ShopifyResource.clear_session()
def finalize(request): shop_url = request.GET.get('shop') print('Inside finalizeeee') try: shopify_session = shopify.Session(shop_url) print(request.GET) params = { "shop": shop_url, "code": request.GET['code'], "timestamp": request.GET['timestamp'], "hmac": request.GET['hmac'], } request.session['shopify'] = { "shop_url": shop_url, "access_token": shopify_session.request_token(params) } except Exception: print('Could not login') messages.error(request,"Could not log in to shopify store.") return redirect(reverse('login')) messages.info(request,"Logged in to Shopify Store.") response = redirect(_return_address(request)) request.session.pop('return_to', 1) return response
def authenticate(request, *args, **kwargs): shop = request.POST.get('shop') if shop: from shopify_auth import views as shopify_auth_views redirect_uri = request.build_absolute_uri( reverse(shopify_auth_views.finalize)) #redirect_uri = request.build_absolute_uri(reverse(shopify_auth.views.finalize)) scope = settings.SHOPIFY_APP_API_SCOPE print(redirect_uri) redirect_uri = redirect_uri[:-1] temp_url = shopify.Session(shop.strip()).create_permission_url( scope, redirect_uri) permission_url = temp_url if settings.SHOPIFY_APP_IS_EMBEDDED: # Embedded Apps should use a Javascript redirect. return render(request, "shopify_auth/iframe_redirect.html", {'redirect_uri': permission_url}) else: # Non-Embedded Apps should use a standard redirect. return HttpResponseRedirect(permission_url) else: shop = request.GET.get('shop') if shop: return finalize(request, *args, **kwargs) return_address = get_return_address(request) return HttpResponseRedirect(return_address)
def action_post(self): rec = super(SocialPostInherit, self).action_post() shops = self.env['shopify_app.shop'].sudo().search([('id', '>', 0)]) for shop in shops: # get the offline access code domain = shop['url'] app = self.env['shopify.module.name'].sudo().search([ '&', ('shopify_shop_id', '=', shop.id), ('app_name', '=', 'blog post') ]) token = app.code session = shopify.Session(domain, '2020-01', token) shopify.ShopifyResource.activate_session(session) article = shopify.Article({ "author": self.env.user.name, "blog_id": int(self.blog_id), "body_html": str(self.message), "created_at": str(self.create_date), "published_at": str(datetime.now()), # "summary_html": self.get_image(), "title": str(self.title), # "updated_at": "2012-07-06T13:57:51-04:00", "user_id": '', "tags": self.get_tag_name(), # "image": { # "created_at": str(self.create_date), # "alt": str(self.get_image()), # "src": 'https://cdn.shopify.com/s/files/1/0456/3356/8929/articles/'+str(self.get_image()) # } }) article.save() return rec
def get_credential(self, channel, id, environment): """Get Credential.""" if channel == 'analytics': credential = self._analytics_get_credential(id) if channel == 'facebook': credential = {} credential['access_token'] = self._facebook_get_access_token(id) credential['app_id'] = self._facebook_get_client_id( self.client, environment) credential['app_secret'] = self._facebook_get_client_secret( self.client, environment) if channel == 'adwords': credential = {} credential['client_id'] = self._adwords_get_client_id( self.client, environment) credential['client_secret'] = self._adwords_get_client_secret( self.client, environment) credential['developer_token'] = self._adwords_get_developer_token( self.client, environment) credential['refresh_token'] = self._adwords_get_refresh_token(id) if channel == 'shopify': credential = {} shop_url = f"{id}.myshopify.com" access_token = self._shopify_get_access_token(id) session = shopify.Session(shop_url, SHOPIFY_API_VERSION, access_token) credential['session'] = session return credential
def get_blog(self): current_app = DefaultConfig() shops = self.env['shopify_app.shop'].sudo().search([('id', '>', 0)]) for shop in shops: # get the offline access code domain = shop['url'] app = self.env['shopify.module.name'].sudo().search([ '&', ('shopify_shop_id', '=', shop.id), ('app_name', '=', 'blog post') ]) token = app.code session = shopify.Session(domain, '2020-01', token) shopify.ShopifyResource.activate_session(session) url = 'https://magenestdev.myshopify.com/admin/api/2020-07/blogs.json' headers = { 'Content-Type': 'application/json', 'client_id': current_app.SHOPIFY_API_KEY, 'client_secret': current_app.SHOPIFY_SHARED_SECRET, 'X-Shopify-Access-Token': token } response = requests.get(url, headers=headers) data = response.json() list_blogs = [] for i in range(0, len(data['blogs'])): list_blogs.extend([(str(data['blogs'][i]['id']), data['blogs'][i]['title'])]) return list_blogs
def authenticate(request, *args, **kwargs): shop = request.POST.get('shop', request.GET.get('shop')) if settings.SHOPIFY_APP_DEV_MODE: return finalize(request, token='00000000000000000000000000000000', *args, **kwargs) if shop: # Store return adress so merchant gets where they intended to. return_address_parameter = request.GET.get(auth.REDIRECT_FIELD_NAME) if return_address_parameter: request.session[ SESSION_REDIRECT_FIELD_NAME] = return_address_parameter redirect_uri = request.build_absolute_uri(reverse(finalize)) scope = settings.SHOPIFY_APP_API_SCOPE permission_url = shopify.Session( shop.strip(), getattr(settings, 'SHOPIFY_APP_API_VERSION', 'unstable')).create_permission_url(scope, redirect_uri) if settings.SHOPIFY_APP_IS_EMBEDDED: # Embedded Apps should use a Javascript redirect. return render(request, "shopify_auth/iframe_redirect.html", { 'shop': shop, 'redirect_uri': permission_url }) else: # Non-Embedded Apps should use a standard redirect. return HttpResponseRedirect(permission_url) return_address = get_return_address(request) return HttpResponseRedirect(return_address)
def process_view(self, request, view_func, view_args, view_kwargs): if hasattr(request, 'session') and 'shopify' in request.session: print request.session['shopify']['shop_url'] shopify_session = shopify.Session( request.session['shopify']['shop_url']) shopify_session.token = request.session['shopify']['access_token'] shopify.ShopifyResource.activate_session(shopify_session)
def get(self, request, **kwargs): shop = request.GET.get('shop', '') if shop != '': request.session['shop_name'] = shop shop_obj = Shop.objects.filter(name=shop) if shop_obj: return redirect(reverse('core:dashboard')) state = str(uuid.uuid4()) session = shopify.Session( 'https://%s.%s%s' % (shop, settings.SHOPIFY_URL, settings.SHOPIFY_AUTHORIZE_SUFIX)) session.setup(api_key=settings.SHOPIFY_API_KEY, secret=settings.SHOPIFY_SECRET) permission_url = session.create_permission_url( settings.SHOPIFY_SCOPES, request.build_absolute_uri( reverse('core:shopify_callback'))) + '&state=' + state try: response = requests.head(permission_url) if response.status_code == 404: return HttpResponseForbidden() else: request.session['state'] = state return redirect(permission_url) except Exception: return HttpResponseForbidden() return render(request, self.template_name, context) else: return HttpResponseForbidden()
def getStore(self): shopify.Session.setup(api_key=self.api_key, secret=self.secret_key) session = shopify.Session(self.shop_url, self.api_version, self.access_token) shopify.ShopifyResource.activate_session(session) shop = shopify.Shop.current() shopify.ShopifyResource.clear_session() return shop
def test_raise_error_if_hmac_is_invalid(self): shopify.Session.secret = "secret" params = {"code": "any-code", "timestamp": time.time()} params["hmac"] = "a94a110d86d2452e92a4a64275b128e9273be3037f2c339eb3e2af4cfb8a3828" with self.assertRaises(shopify.ValidationException): session = shopify.Session("http://localhost.myshopify.com", "unstable") session = session.request_token(params)
def test_raise_error_if_hmac_is_invalid(self): shopify.Session.secret='secret' params = {'code': 'any-code', 'timestamp': time.time()} params['hmac'] = 'a94a110d86d2452e92a4a64275b128e9273be3037f2c339eb3e2af4cfb8a3828' with self.assertRaises(shopify.ValidationException): session = shopify.Session('http://localhost.myshopify.com') session = session.request_token(params)
def _delete_products(): shop_session = sfy.Session(session['shop_url'], '2019-04', session['token']) # activate the shopify session to use resources. sfy.ShopifyResource.activate_session(shop_session) products = Product.query.all() for p in products: delete_products(p.gid) return(jsonify('ok')) #this makes the browser happy on the final call, no 500 error
def test_raise_error_if_params_passed_but_signature_omitted(self): with self.assertRaises(shopify.ValidationException): session = shopify.Session("testshop.myshopify.com") token = session.request_token({ 'code': 'any_code', 'foo': 'bar', 'timestamp': '1234' })
def _delete_customers(): shop_session = sfy.Session(session['shop_url'], '2019-04', session['token']) # activate the shopify session to use resources. sfy.ShopifyResource.activate_session(shop_session) customers = Customer.query.all() for c in customers: delete_customer(c.gid) return(jsonify('ok')) #this makes the browser happy on the final call, no 500 error
def delete_a_customer(customer_id): session = shopify.Session(shop_url, api_version, access_token) shopify.ShopifyResource.activate_session(session) try: customer = shopify.Customer().find(customer_id) customer.destroy() except: print("Failed to delete")
def initialize_shopify_client(): api_key = Context.config['api_key'] shop = Context.config['shop'] version = '2021-04' session = shopify.Session(shop, version, api_key) shopify.ShopifyResource.activate_session(session) # Shop.current() makes a call for shop details with provided shop and api_key return shopify.Shop.current().attributes
def test_raise_error_if_params_passed_but_signature_omitted(self): with self.assertRaises(shopify.ValidationException): session = shopify.Session("testshop.myshopify.com", "unstable") token = session.request_token({ "code": "any_code", "foo": "bar", "timestamp": "1234" })
def _session_from_config(cls, config): session = shopify.Session( config.get("domain"), config.get("api_version", cls._default_api_version)) session.protocol = config.get("protocol", "https") session.api_key = config.get("api_key") session.token = config.get("password") return session
def init_api_shopify(self): for item in self: # session session = shopify.Session(item.url, '2020-01', item.shopify_access_token) shopify.ShopifyResource.activate_session(session) # return return session