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 delete_products(gid):
product = '''
input: {
id: "''' + gid + '''"
}
'''
del_prod_mutation = '''
mutation {
productDelete(''' + product + '''){
deletedProductId
shop {
id
}
userErrors {
field
message
}
}
}
'''
db.session.delete(Product.query.filter_by(gid=gid).first())
db.session.commit()
client = sfy.GraphQL()
result = client.execute(del_prod_mutation)
print('deletd product: ', gid)
def products_update(self, data):
product_id = data.get('id')
title = data.get('title')
vendor = data.get('vendor')
p_type = data.get('product_type')
try:
product = Product.objects.get(store=self._user,
product_id=product_id)
product.title = title
product.vendor = vendor
product.type = p_type
if product.image is None:
client = shopify.GraphQL()
query = '''
query {
product(id: "gid://shopify/Product/%s") {
id
featuredImage {
transformedSrc(maxWidth: 50)
}
}
}
''' % product_id
result = json.loads(client.execute(query))['data']['product']
image = result['featuredImage']
product.image = image
product.save()
print("Product updated: %s" % product.id)
except Exception as e:
print(e)
def get(self, request, *args, **kwargs):
client = shopify.GraphQL()
query = '''
{
products(first: 10) {
edges {
node {
id
handle
title
}
}
}
productVariants(first:10){
edges{
node{
title
}
}
}
}
'''
test = ['test', 'test']
result = client.execute(query)
result = ast.literal_eval(result)
result['data']['products']['edges'][0]['node']['test'] = test
return Response(result['data'])
def get_collections_by_product_id(product_id):
query = '''{
product(id: "%s") {
collections(first: 50) {
edges {
node {
id
title
}
}
}
}
}
'''
result = shopify.GraphQL().execute(query % product_id)
data = json.loads(result)
collections = []
if 'data' in data and 'product' in data['data'] and data['data']['product'] is not None and 'collections' in \
data['data']['product'] \
and 'edges' in data['data']['product']['collections'] and len(
data['data']['product']['collections']['edges']):
for item in data['data']['product']['collections']['edges']:
if 'node' in item:
collections.append({
"id": item['node']['id'],
"title": item['node']['title'],
})
return collections
def delete_customer(gid):
customer = '''
input: {
id: "''' + gid + '''"
}
'''
del_cust_mutation = '''
mutation {
customerDelete(''' + customer + '''){
deletedCustomerId
shop {
id
}
userErrors {
field
message
}
}
}
'''
db.session.delete(Customer.query.filter_by(gid=gid).first())
db.session.commit()
client = sfy.GraphQL()
result = client.execute(del_cust_mutation)
print(result)
def get_collections_by_id_list(set_collection_ids):
set_collection_ids = set(set_collection_ids)
query = '{'
for idx, collection_id in enumerate(set_collection_ids):
query += '''
collection%s: collection(id: "%s") {
id
title
}
''' % (idx, collection_id)
query += '}'
result = shopify.GraphQL().execute(query)
data = json.loads(result)
collections = {}
if 'data' in data:
for i in range(0, len(set_collection_ids)):
if 'collection' + str(i) in data['data'] and data['data'][
'collection' + str(i)] is not None:
item = data['data']['collection' + str(i)]
if item:
collections[item['id']] = {
"id": item['id'],
"title": item['title'],
}
return collections
def complete_draft_order(order_gid):
"""
Take any draft order id and complete it using a GQL request
"""
print('draft order gid: ', order_gid)
draft_order = '''
id: "''' + order_gid + '''"
'''
order_mutation = '''mutation {
draftOrderComplete(''' + draft_order + ''')
{
draftOrder {
id
}
userErrors {
field
message
}
}
}
'''
pprint(order_mutation)
client = sfy.GraphQL()
result = json.loads(client.execute(order_mutation))
pprint(result)
def get_orders():
orders = '''
{
draftOrders(first: 10, reverse: true) {
edges {
node {
id
createdAt
metafields(first:10, namespace:"testing date") {
edges {
node {
key
value
}
}
}
}
}
}
}
'''
# pprint(order_mutation)
# shop_session = sfy.Session(shop_url, '2019-04', shop_token)
# activate the shopify session to use resources.
# sfy.ShopifyResource.activate_session(shop_session)
client = sfy.GraphQL()
return json.loads(client.execute(orders))
def get_products_by_id_list(product_id_list):
product_id_set = set(product_id_list)
query = '{'
for idx, product_id in enumerate(product_id_set):
query += '''
product%s: product(id: "%s") {
id
title
status
}
''' % (idx, product_id)
query += '}'
result = shopify.GraphQL().execute(query)
data = json.loads(result)
products = []
if 'data' in data:
for i in range(0, len(product_id_set)):
if 'product' + str(i) in data['data'] and data['data'][
'product' + str(i)] is not None:
item = data['data']['product' + str(i)]
if item:
products.append({
"id": item['id'],
"title": item['title'],
})
return products
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_product_by_id(product_id):
query = '''{
product(id: "%s") {
id
title
status
featuredImage {
originalSrc
transformedSrc(maxWidth:160, crop: CENTER)
}
}
}
'''
result = shopify.GraphQL().execute(query % product_id)
data = json.loads(result)
product = None
if 'data' in data and 'product' in data['data'] and data['data'][
'product'] is not None:
product = {
"id": data['data']['product']['id'],
"title": data['data']['product']['title'],
"featured_image": data['data']['product']['featuredImage']['originalSrc'] \
if data['data']['product']['featuredImage'] is not None and 'originalSrc' in data['data']['product'][
'featuredImage'] else None,
"thumbnail": data['data']['product']['featuredImage']['transformedSrc'] \
if data['data']['product']['featuredImage'] is not None and 'transformedSrc' in data['data']['product'][
'featuredImage'] else None,
}
return product
def get_products_by_type(type, first, after='', search=''):
query = """{
products(%s) {
pageInfo {
hasNextPage
hasPreviousPage
}
edges {
cursor
node {
id
title
featuredImage {
originalSrc
transformedSrc(maxWidth:160, crop: CENTER)
}
}
}
}
}
"""
pagination = f'first: {first}' if after == '' else f'first: {first}, after: "{after}"'
query_params = f'query: "product_type:{type}"' if search == '' else f'query: "product_type:{type}, title:{search}*"'
result = shopify.GraphQL().execute(query % f'{pagination}, {query_params}')
data = json.loads(result)
pagination = None
products = []
if 'data' in data and 'products' in data['data']:
if 'pageInfo' in data['data']['products']:
pagination = data['data']['products']['pageInfo']
if 'edges' in data['data']['products'] and len(
data['data']['products']['edges']):
for item in data['data']['products']['edges']:
if 'node' in item:
products.append({
"cursor":
item['cursor'],
"id":
item['node']['id'],
"title":
item['node']['title'],
"featured_image":
item['node']['featuredImage']['originalSrc']
if item['node']['featuredImage'] is not None
and 'originalSrc' in item['node']['featuredImage'] else
None,
"thumbnail":
item['node']['featuredImage']['transformedSrc']
if item['node']['featuredImage'] is not None
and 'transformedSrc' in item['node']['featuredImage']
else None,
})
return {'pagination': pagination, 'products': products}
def get_orders(limit, after=None, status=''):
if after:
query = '{ orders(first:%LIMIT%, after: %AFTER%, query:"financial_status:AUTHORIZED") { edges { node { id displayFinancialStatus } } }}'
else:
query = '{ orders(first: %LIMIT%) { edges { cursor node { id } } }}'
query = query.replace('%LIMIT%', str(limit))
if after:
query = query.replace('%AFTER%', after)
result = shopify.GraphQL().execute(query)
print(result)
return json.loads(result)
def check_config(self, logger: AirbyteLogger, config_path: str, config: json) -> AirbyteConnectionStatus:
try:
session = shopify.Session(f"{config['shop']}.myshopify.com", "2020-10", 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()
return AirbyteConnectionStatus(status=Status.SUCCEEDED)
except Exception as e:
logger.error(f"Exception connecting to Shopify: ${e}")
return AirbyteConnectionStatus(
status=Status.FAILED, message="Unable to connect to the Shopify API with the provided credentials."
)
def gen_order(customer_gid, variant_list, completed_date, shop_url,
shop_token):
"""
Creates a single order
"""
line_items_string = ''
for item in variant_list:
line_item = gen_order_line_item(item[0].gid, item[1])
line_items_string += '{variantId: "%s", quantity: %i }' %\
(line_item['variantId'], line_item['quantity'])
# print(line_items_string)
draft_order = '''
input: {
customerId: "''' + customer_gid + '''",
metafields: {
description: "date",
key: "date",
namespace: "testing date"
value: "''' + completed_date + '''",
valueType: STRING
},
lineItems:[''' + line_items_string + ''']
}
'''
# pprint(draft_order)
order_mutation = '''mutation {
draftOrderCreate(''' + draft_order + ''')
{
draftOrder {
id
}
userErrors {
field
message
}
}
}
'''
# pprint(order_mutation)
shop_session = sfy.Session(shop_url, '2019-04', shop_token)
# activate the shopify session to use resources.
sfy.ShopifyResource.activate_session(shop_session)
client = sfy.GraphQL()
result = json.loads(client.execute(order_mutation))
pprint(result)
order_id = result['data']['draftOrderCreate']['draftOrder']['id']
db.session.add(Order(gid=order_id))
db.session.commit()
complete_draft_order(order_id)
def get(self, request, *args, **kwargs):
client = shopify.GraphQL()
query = '''
{
shop {
id
name
email
}
}
'''
result = client.execute(query)
result = ast.literal_eval(result)
return Response(result['data'])
def get_products_by_collection(collection):
query = """{
collection(id: "%s") {
handle
products(first: 100) {
edges {
node {
id
title
status
featuredImage {
originalSrc
transformedSrc(maxWidth:160, crop: CENTER)
}
}
}
}
}
}
"""
result = shopify.GraphQL().execute(query % collection)
data = json.loads(result)
products = []
if 'data' in data and 'collection' in data['data'] and data['data']['collection'] is not None and 'products' in \
data['data']['collection'] \
and 'edges' in data['data']['collection']['products'] \
and len(data['data']['collection']['products']['edges']):
for item in data['data']['collection']['products']['edges']:
if 'node' in item and item['node']['status'] == 'ACTIVE':
products.append({
"id":
item['node']['id'],
"title":
item['node']['title'],
"featured_image":
item['node']['featuredImage']['originalSrc']
if item['node']['featuredImage'] is not None and
'originalSrc' in item['node']['featuredImage'] else None,
"thumbnail":
item['node']['featuredImage']['transformedSrc']
if item['node']['featuredImage'] is not None
and 'transformedSrc' in item['node']['featuredImage'] else
None,
})
return products
def get(self, request, *args, **kwargs):
client = shopify.GraphQL()
query = '''
{
customers(first:1){
edges{
node{
email
displayName
}
}
}
}
'''
result = client.execute(query)
result = ast.literal_eval(result)
return Response(result['data'])
def upload_product_data(prod_name, max_variants=10):
"""
Upload a single product to the shop
input:
- prod_name: name for the fake name creation
- max_variants: maximum number of variants to allow this product to have
returns:
- graphQL post result containint the product id, shop id, and any errors
"""
product_mutation = '''mutation {
productCreate(input: {
descriptionHtml: "test product generated via GraphQL",
title: "''' + prod_name + '''"
}
)
{
product{
id
}
shop {
id
}
userErrors{
field
message
}
}
}
'''
# print(sfy.ShopifyResource.get_site())
client = sfy.GraphQL()
product_results = json.loads(client.execute(product_mutation))
# print(product_results)
pid = product_results['data']['productCreate']['product']['id']
#add this product to the database
prod = Product(gid=pid, name=prod_name)
db.session.add(prod)
db.session.commit()
#determine number of variants
for v in range(random.randint(0, max_variants)):
generate_fake_variant(pid,"Variant Test generate with GraphQL {}".format(v),\
"variant: {}".format(v), "6.69", "2.38")
return product_results
def generate_fake_variant(productId, option, variant_sku, variant_price,
variant_cost):
"""
Upload a single product to the shop
"""
variant_mutation = '''mutation {
productVariantCreate(input: {
productId: "''' + productId + '''",
options: "''' + option + '''",
price:"''' + variant_price + '''",
sku: "''' + variant_sku + '''",
inventoryItem: {
cost: "''' + variant_cost + '''"
}
})
{
product{
id
}
productVariant{
id
}
userErrors{
field
message
}
}
}
'''
client = sfy.GraphQL()
# result = client.execute(variant_mutation)
var_results = json.loads(client.execute(variant_mutation))
# print(product_results)
# print(var_results)
vid = var_results['data']['productVariantCreate']['productVariant']['id']
#upload this product's variants to the DATABASE
var = Variant(gid=vid, name=variant_sku)
prod = Product.query.filter_by(gid=productId).first()
db.session.add(var)
prod.variants.append(var)
db.session.commit()
return var_results
def excute_graph_ql(self, query: str) -> dict:
try:
# the execute function sometimes prints and this causes errors for the target, so I block printing for it
with HiddenPrints():
response = json.loads(shopify.GraphQL().execute(query))
except Exception:
raise GraphQLGeneralError("Execution failed", code=500)
if 'data' in response and response['data'] is not None:
return response['data']
if "errors" in response:
errors = response["errors"]
singer.log_info(errors)
if errors[0]["extensions"]["code"] == "THROTTLED":
raise GraphQLThrottledError("THROTTLED", code=429)
raise GraphQLGeneralError("Failed", code=500)
def get_products_by_tag(tag):
query = """{
products(first: 100, query: "tag:%s") {
edges {
node {
id
title
featuredImage {
originalSrc
transformedSrc(maxWidth:160, crop: CENTER)
}
}
}
}
}
"""
if not isinstance(tag, list):
tag = [tag]
result = shopify.GraphQL().execute(query % tag)
data = json.loads(result)
products = []
if 'data' in data and 'products' in data['data'] and 'edges' in data[
'data']['products'] and len(data['data']['products']['edges']):
for item in data['data']['products']['edges']:
if 'node' in item:
products.append({
"id":
item['node']['id'],
"title":
item['node']['title'],
"featured_image":
item['node']['featuredImage']['originalSrc']
if item['node']['featuredImage'] is not None and
'originalSrc' in item['node']['featuredImage'] else None,
"thumbnail":
item['node']['featuredImage']['transformedSrc']
if item['node']['featuredImage'] is not None
and 'transformedSrc' in item['node']['featuredImage'] else
None,
})
return products
def cron_fetch_abandoned_cart(self):
todayStr = datetime.today().strftime('%Y-%m-%d')
checkout = self.env['whatsapp.shopify.checkout'].sudo().search(
[('id', '>', 0)], order="checkout_iden desc", limit=1)
shops = self.env['shopify_app.shop'].sudo().search([('id', '>', 0)])
for shop in shops:
# get the offline access code
token = shop['code']
domain = shop['url']
session = shopify.Session(domain, '2019-04', token)
shopify.ShopifyResource.activate_session(session)
checkouts = shopify.Checkout.find(updated_at_min=todayStr)
updatedCheckouts = shopify.Checkout.find(since_id=12950897623172)
checkoutCount = shopify.Checkout.get('count')
client = shopify.GraphQL()
query = '''
{
products(first:10, query:"tag:rental") {
edges {
node {
id
title
}
}
}
}
'''
result = client.execute(query)
d = json.loads(result)
if checkouts:
for checkout in checkouts:
#update or create
cart_token = checkout.attributes['cart_token']
exist_checkout = self.sudo().search([('cart_token', 'like',
cart_token)])
if not exist_checkout:
#todo:
vals = {}
def get_all_tags(limit, after=None):
if after:
query = '''
{
shop{
productTags(first: %LIMIT%, after: %AFTER%){
edges{
node
}
}
}
}
'''
else:
query = '''
{
shop{
productTags(first: %LIMIT%){
edges{
node
}
}
}
}
'''
query = query.replace('%LIMIT%', str(limit))
if after:
query = query.replace('%AFTER%', after)
result = shopify.GraphQL().execute(query)
data = json.loads(result)
tags = []
if 'data' in data and 'shop' in data['data'] and 'productTags' in data['data']['shop'] and 'edges' in \
data['data']['shop']['productTags'] \
and len(data['data']['shop']['productTags']['edges']):
for item in data['data']['shop']['productTags']['edges']:
if 'node' in item:
tags.append(item['node'])
return tags
def get_products():
query = '''{
products(first: 10) {
edges {
node {
createdAt
collections(first: 5) {
edges {
node {
id
handle
title
}
}
}
description
featuredImage {
id
originalSrc
transformedSrc
}
id
isGiftCard
onlineStorePreviewUrl
onlineStoreUrl
productType
publishedAt
tags
title
totalInventory
updatedAt
vendor
}
}
}
}'''
result = shopify.GraphQL().execute(query)
data = json.loads(result)
return data
def get_collection_info_by_id(collection_id):
query = '''{
collection(id: "%s") {
id
title
}
}
'''
result = shopify.GraphQL().execute(query % collection_id)
data = json.loads(result)
collection = None
if 'data' in data and 'collection' in data['data'] and data['data'][
'collection'] is not None:
collection = {
"id": data['data']['collection']['id'],
"title": data['data']['collection']['title'],
}
return collection
def orders_api_call_1():
results = shopify.GraphQL().execute('''query {
orders(first:20, reverse:true, query:"fulfillment_status:unshipped,fulfillment_status:Pending") {
edges {
node {
name
displayFulfillmentStatus
createdAt
displayAddress {
name
}
}
}
}
}
''')
payload = json.loads(results)
order_ids = [i["node"]["name"] for i in payload['data']['orders']['edges']]
fulfillment_status = [
i["node"]["displayFulfillmentStatus"]
for i in payload['data']['orders']['edges']
]
order_created_time = [
i["node"]["createdAt"] for i in payload["data"]["orders"]["edges"]
]
order_create_date = [i.split("T")[0] for i in order_created_time]
names = [
i["node"]["displayAddress"]["name"]
for i in payload["data"]["orders"]["edges"]
]
df = pandas.DataFrame(list(
zip(order_ids, fulfillment_status, order_create_date,
order_created_time, names)),
columns=[
"order_ids", "fulfillment_status", "order_date",
"order_time_raw", "name"
])
return df
def inventory_items_update(self, data):
inventory_item_id = data.get('id')
sku = data.get('sku').strip()
tracked = data.get('tracked')
try:
if self._preferences.activate:
variant = Variant.objects.get(store=self._user, inventory_item_id=inventory_item_id)
variant.sku = sku
variant.inventory_management = tracked
if tracked:
variants = Variant.objects.filter(store=self._user, sku=sku, inventory_management=tracked)
for _ in variants:
if _.id != variant.id:
variant.qty = _.qty
break
if variants:
inv_item = shopify.InventoryLevel.find_first(inventory_item_ids=inventory_item_id)
shopify.InventoryLevel.set(
inventory_item_id=inventory_item_id,
location_id=inv_item.location_id,
available=variant.qty)
else:
client = shopify.GraphQL()
query = '''
query {
inventoryItem(id: "gid://shopify/InventoryItem/%s") {
variant {
inventoryQuantity
}
}
}
''' % inventory_item_id
result = json.loads(client.execute(query))['data']['inventoryItem']
variant.qty = result['variant']['inventoryQuantity']
variant.save()
else:
variant.save()
print('Inventory and sku synced for variant %s' % variant.id)
except Exception as e:
print(e)
def get(self, request, *args, **kwargs):
client = shopify.GraphQL()
query = '''
{
collections(first: 5){
edges{
node{
products (first: 5){
edges {
node {
id
}
}
}
title
}
}
}
}
'''
result = client.execute(query)
result = ast.literal_eval(result)
return Response(result['data'])
