def test_create_variant(self): self.fake("products/632910392/variants", method='POST', body=self.load_fixture('variant'), headers={'Content-type': 'application/json'}) v = shopify.Variant({'product_id': 632910392}) v.save()
def export_products(self): """ This functions export products of the user to his shopify shop :return: """ export_products = "" products = self.env['product.template'].search([('create_uid', '=', self.env.user.id)]) shopify_products = shopify.Product.find(limit=250) for product in products: already_exist = False for shopify_product in shopify_products: if shopify_product.attributes['title'] == product.name: already_exist = True break if already_exist: continue export_products = export_products + product.name + " " new_product = shopify.Product() new_product.title = product.name new_product.body_html = product.description new_product.product_type = product.type product_variant = shopify.Variant({"title": "v1", "price": 123123}) new_product.variants = [product_variant] new_product.save() if export_products: raise osv.except_osv(("Products Export Success"), (export_products + " exported successfully")) else: raise osv.except_osv(("Products Export"), ("non product to export"))
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 test_add_variant_to_product(self): self.fake("products/632910392/variants", method='POST', body=self.load_fixture('variant'), headers={'Content-type': 'application/json'}) self.fake("products/632910392/variants/808950810", method='PUT', code=200, body=self.load_fixture('variant'), headers={'Content-type': 'application/json'}) v = shopify.Variant() self.assertTrue(self.product.add_variant(v))
def create_variants(variants, product): # variants = deepcopy(variants) product1 = shopify.Product.find(product.id) created_variants = [] for variant in variants: # print(variant) # del variant['id'] # vari = { # "title": variant['title'], # "option1": variant['option1'], # "option2": variant['option2'], # "option3": variant['option3'], # "sku": variant['sku'], # "requires_shipping": variant['requires_shipping'], # "taxable": variant['taxable'], # # "featured_image": variant['featured_image'], # # "available": variant['available'], # "price": variant['price'], # "grams": variant['grams'], # "compare_at_price": variant['compare_at_price'], # "position": variant['position'] # } # edit_variants(variant, product1) # for own_variant in product.variants: # own_variant.attributes = vari # created_variants.append(shopify.Variant(vari)) new_variant = shopify.Variant() new_variant.title = variant['title'] new_variant.price = variant['price'] new_variant.sku = variant['sku'] new_variant.position = variant['position'] new_variant.compare_at_price = variant['compare_at_price'] new_variant.option1 = variant['option1'] new_variant.option2 = variant['option2'] new_variant.option3 = variant['option3'] new_variant.taxable = variant['taxable'] new_variant.grams = variant['grams'] new_variant.requires_shipping = variant['requires_shipping'] new_variant.inventory_policy = "continue" new_variant.inventory_quantity = 1 new_variant.inventory_management = "shopify" new_variant.old_inventory_quantity = 1 new_variant.fulfillment_service = "manual" created_variants.append(new_variant) product1.variants = [] product1.variants = created_variants # product.variants = [] save = product1.save() if save: print(product.title) else: print("Not Saved")
def post_product(self, record): product = shopify.Product() product.title = record.name product.handle = record.default_code or record.name product.body_html = record.description_sale or record.description_purchase or '' if record.attribute_line_ids: product.options = [{ 'name': attribute_line.attribute_id.display_name } for attribute_line in record.attribute_line_ids] product.variants = [] for local_variant in record.product_variant_ids: variant = { 'price': local_variant.lst_price, 'sku': local_variant.default_code or '', 'barcode': local_variant.barcode or '', 'inventory_management': 'shopify', } if record.attribute_line_ids: option_count = len(product.options) if option_count > 0: variant.update( option1=local_variant. product_template_attribute_value_ids.filtered( lambda self: product.options[0].get( 'name') in self.display_name).name) if option_count > 1: variant.update( option2=local_variant. product_template_attribute_value_ids.filtered( lambda self: product.options[1].get( 'name') in self.display_name).name) if option_count > 2: variant.update( option2=local_variant. product_template_attribute_value_ids.filtered( lambda self: product.options[2].get( 'name') in self.display_name).name) variant = shopify.Variant(variant) product.variants.append(variant) if self.ensure_response(product, 'save'): for local_variant, remote_variant in zip( record.product_variant_ids, product.variants): self.put_variant(local_variant, remote_variant.id, product) return True, product else: _logger.error(product.errors.errors) return False, product
def randomProduct(title): images = [] for i in range(random.randint(1, 4)): images.append(setUpImage(i + 1)) variants = [] variants.append(shopify.Variant({'price': random.randint(1, 100)})) attrs = {} attrs['title'] = title attrs['tags'] = ['bits and bobs, hats'] attrs['body_html'] = '<p>Hat in Grey. 100% Alpaca.</p>' attrs['image'] = images[0] attrs['images'] = images attrs['variants'] = variants product = shopify.Product(attributes=attrs) return product
def test_add_variant_to_product(self): self.fake( "products/632910392/variants", method="POST", body=self.load_fixture("variant"), headers={"Content-type": "application/json"}, ) self.fake( "products/632910392/variants/808950810", method="PUT", code=200, body=self.load_fixture("variant"), headers={"Content-type": "application/json"}, ) v = shopify.Variant() self.assertTrue(self.product.add_variant(v))
def update_product_map_price(product, new_map_price): """ This works right now but needs to be updated for multiple variants, The variants come in lists so that should be pretty easy to go through and change the one that needs to be changed. """ update_product = shopify.Product.find(product.get_product_id()) variant = shopify.Variant({'price': new_map_price, 'requires_shipping': True}) if len(update_product.variants) == 1: update_product.variants = [variant] update_product.save() if update_product.errors: # something went wrong, see new_product.errors.full_messages() for example update_product.errors.full_messages()
def to_shopify_object( self, existing_object: Optional[shopify.Variant] = None ) -> shopify.Variant: if existing_object: obj = existing_object else: obj = shopify.Variant() for field in self.__fields__: if self.__getattribute__(field) is not None: obj.__setattr__(field, self.__getattribute__(field)) # Special handling of compare at price. If this is None and price is given, then set to None. elif field == "compare_at_price" and self.__getattribute__( "price") is not None: obj.__setattr__(field, None) return obj
def export_product(self): """ This functions export products of the user to his shopify shop :return: """ shop_name = self.env.user.shop_name api_key = self.env.user.api_key api_password = self.env.user.api_password api_secret_key = self.env.user.api_secret_key shop_url = "https://%s:%s@%s.myshopify.com/admin" % ( api_key, api_password, shop_name) shopify.ShopifyResource.set_site(shop_url) shopify.Session.setup(api_key=api_key, secret=api_secret_key) exported_products = "" products = self.env['product.template'].search([('id', 'in', self.ids) ]) shopify_products = shopify.Product.find(limit=250) for product in products: already_exist = False for shopify_product in shopify_products: if shopify_product.attributes['title'] == product.name: already_exist = True break if already_exist: continue exported_products = exported_products + product.name + " " new_product = shopify.Product() new_product.title = product.name new_product.body_html = product.description new_product.product_type = product.type product_variant = shopify.Variant({"title": "v1", "price": 123123}) new_product.variants = [product_variant] new_product.save() if exported_products: raise osv.except_osv( ("Products Export Success"), (exported_products + " exported successfully")) else: raise osv.except_osv(("Products Export Message"), ("non product to export"))
def put_variant(self, record, remote_id, product): variant = shopify.Variant({'id': remote_id}) variant.product_id = product.id variant.price = round( record.with_context(pricelist=self.pricelist_id).price, 2) variant.sku = record.default_code or '' variant.barcode = record.barcode or '' variant.inventory_management = 'shopify' if record.image_1920: image = shopify.Image() image.alt = product.handle image.attachment = record.image_1920.decode('utf-8') image.product_id = product.id if self.ensure_response(image, 'save'): variant.image_id = image.id else: _logger.error(image.errors.errors) if record.product_template_attribute_value_ids: option_count = len(product.options) if option_count > 0: variant.option1 = record.product_template_attribute_value_ids.filtered( lambda self: product.options[ 0].name in self.display_name).name if option_count > 1: variant.option2 = record.product_template_attribute_value_ids.filtered( lambda self: product.options[ 1].name in self.display_name).name if option_count > 2: variant.option3 = record.product_template_attribute_value_ids.filtered( lambda self: product.options[ 2].name in self.display_name).name if self.ensure_response(variant, 'save'): return True, variant else: _logger.error(variant.errors.errors) return False, variant
def create_shopify_products(shopify_products): """ Connect to shopify store, create products based on shopify_products dict coming from get_tahoe_courses() function and notify admins about product creation """ try: # connect to shopify store shopify.ShopifyResource.set_site(shopify_store_admin_api) store = shopify.Shop.current() store_admin_name = store.name store_admin_email = store.customer_email # 1 Create products in store # 1.1 find existing SKUs from shopify to checkproduct doesn't exist variants = shopify.Variant.find() # SKU in shopify is Course ID in OpenEDX skus = [] number_created_products = 0 created_products_list = [] for variant in variants: # Fill SKUs list with all courses id that exist in shopify skus.append(variant.sku) # 1.2 loop over shopify_products and create store products # shopify_products contains course metadata coming from OpenEDX for product in shopify_products: # 1.3 Check if the course already exist in store # Remember product_sku = result["course_id"] if not product["product_sku"] in skus: # 1.4 create products in store new_product = shopify.Product() new_image = shopify.Image() new_product.title = product["product_title"] new_product.body_html = product["product_description"] new_product.published = "false" new_product.published_at = "" # tag is site full URL new_product.tags = product["product_tag"] new_variant = shopify.Variant( { "sku": product["product_sku"], "requires_shipping": False, "inventory_policy": "deny", } ) new_product.variants = [new_variant] product_saved = new_product.save() if product_saved: logging.info( "{}: {} created successfully".format( product["product_title"], product["product_sku"] ) ) else: logging.error( "unexpected error happened for {}: {} creation".format( product["product_title"], product["product_sku"] ) ) new_image.src = product["product_image"] new_product.images = new_image new_image.product_id = new_product.id image_saved = new_image.save() if not image_saved and not product["product_image"]: logging.error("{}: {} image didn't get saved") number_created_products += 1 created_products_list.append( [ product["product_title"], product["product_sku"], product["product_tag"], date.today().strftime("%m-%d-%Y"), ] ) else: continue logging.info("{} product(s) created usccessfully".format( number_created_products ) ) # 2 Notify admins via email with created courses report # 2.1 Create CSV file from created products if number_created_products: text = "Number of created products in shopify: {} ".format( number_created_products ) header = ["Product Name", "Product SKU", "Tahoe URL", "Created AT"] fp = NamedTemporaryFile( delete=False, prefix="created_product_", suffix=".csv", mode="w", dir="/tmp/", ) writer = csv.writer(fp, quotechar='"', quoting=csv.QUOTE_ALL) writer.writerow(header) for created_product in created_products_list: writer.writerow(created_product) fp.flush() fp.close() data = open(fp.name, "rb").read() message = { "attachments": [ { "content": base64.b64encode(data).decode("utf-8"), "name": fp.name.split("/")[2], "type": "text/csv", } ], "from_email": "*****@*****.**", "from_name": "Appsembler Technical Support", "important": True, "subject": "You'r Shopify product creation report", "text": text, "to": [ { "email": store_admin_email, "name": store_admin_name, "type": "to", }, { "email": "*****@*****.**", "name": "Amir Tadrisi", "type": "to", }, ], } if environment == "prod": mandrill_client.messages.send(message=message) return Response( "{} Product(s) got created".format(number_created_products), status=201 ) except Exception as e: logging.error(e) if environment == "prod": stackdriver_client.report_exception()
def add_new_wheel(connection, wheel_variant): """ Method that adds a new Wheel ProsWheel to Shopify :param wheel_variant: Wheel to add :return: Returns nothing """ # TODO: Need to find a way to stream line this # TODO: Comment out the method # Make the tags that we want to add tags_to_add = [] # Brand tags_to_add.append("Brand_" + wheel_variant.whl_manufact_nm) # Finish tags_to_add.append("Finish_" + wheel_variant.finish) # Bolt Pattern tags_to_add.append("Bolt Pattern_" + wheel_variant.bolt_pattern_metric) # Wheel Offset tags_to_add.append("Wheel Offset_" + wheel_variant.offset) # Wheel Size tags_to_add.append("Wheel Size_" + wheel_variant.size) # Make the bolt pattern setup lug_count = wheel_variant.lug_count dist1 = str(int(float(wheel_variant.bolt_pattern_mm_1))) bolt_pattern1 = lug_count + "x" + dist1 # print(bolt_pattern1) dist2 = str(int(float(wheel_variant.bolt_pattern_mm_2))) bolt_pattern2 = "" if int(dist2) != 0: bolt_pattern2 = lug_count + "x" + dist2 # 2 cases # 1) Is a variant if wheelTools.has_variants(wheel_variant): product_id = wheelTools.find_product_id(wheel_variant) new_wheel_product = shopify.Product.find(product_id) variant = shopify.Variant({'price': wheel_variant.map_price, 'option1': wheel_variant.size, 'option2': bolt_pattern1, 'option3': wheel_variant.offset, 'quantity': 1, 'sku': wheel_variant.upc, 'position': 1, 'inventory_policy': "deny", 'fulfillment_service': "manual", 'inventory_management': "shopify", 'inventory_quantity': wheel_variant.curr_stock, 'taxable': True, 'weight': float(wheel_variant.shipping_weight), 'weight_unit': "g", # g, kg 'requires_shipping': True}) # TODO: Need to organize this code # Below is all for when there is a second bolt pattern variant2 = shopify.Variant({'price': wheel_variant.map_price, 'option1': wheel_variant.size, 'option2': bolt_pattern2, 'option3': wheel_variant.offset, 'quantity': 1, 'sku': wheel_variant.upc, 'position': 1, 'inventory_policy': "deny", 'fulfillment_service': "manual", 'inventory_management': "shopify", 'inventory_quantity': wheel_variant.curr_stock, 'taxable': True, 'weight': float(wheel_variant.shipping_weight), 'weight_unit': "g", # g, kg 'requires_shipping': True}) # print(type(new_wheel_product.variants)) if bolt_pattern1 not in new_wheel_product.tags: new_wheel_product.tags += "," + bolt_pattern1 if bolt_pattern2 not in new_wheel_product.tags: new_wheel_product.tags += "," + bolt_pattern2 # print(new_wheel_product) new_wheel_product.variants.append(variant) if bolt_pattern2 != "": new_wheel_product.variants.append(variant2) # print("Variants: ", new_wheel_product.variants) # Get tags already put in tags = Tags() tags.string_to_tags(new_wheel_product.tags) # Now, we can go through and add the tags we want for t in tags_to_add: if not tags.is_a_tag(t) and "nan" not in t: tags.add_tag(t) new_wheel_product.tags = tags.tags_to_string() new_wheel_product.save() if new_wheel_product.errors: # something went wrong, see new_product.errors.full_messages() for example raise Exception("New Wheel Product Error:\n",new_wheel_product.errors.full_messages()) wheelTools.add_wheel(product_id, wheel_variant) # TODO: Need to organize this code # Below is all for when there is a second bolt pattern # 2) Is not a variant else: # Update a product new_wheel_product = shopify.Product() new_wheel_product.options = [{'name': 'Tire Size'}, {'name': 'Bolt Pattern'}, {'name': 'Offset'}] new_wheel_product.title = wheel_variant.style_description new_wheel_product.vendor = "Wheel Pros" new_wheel_product.product_type = "Wheels" new_wheel_product.body_html = """<b>%s</b> <p>%s</p> """ % (wheel_variant.style_description, wheel_variant.part_number_description) variant = shopify.Variant({'price': wheel_variant.map_price, 'option1': wheel_variant.size, 'option2': bolt_pattern1, 'option3': wheel_variant.offset, 'quantity': 1, 'sku': wheel_variant.upc, 'position': 1, 'inventory_policy': "deny", 'fulfillment_service': "manual", 'inventory_management': "shopify", 'inventory_quantity': wheel_variant.curr_stock, 'taxable': True, 'weight': float(wheel_variant.shipping_weight), 'weight_unit': "g", # g, kg 'requires_shipping': True}) # TODO: Need to organize this code # Below is all for when there is a second bolt pattern variant2 = shopify.Variant({'price': wheel_variant.map_price, 'option1': wheel_variant.size, 'option2': bolt_pattern2, 'option3': wheel_variant.offset, 'quantity': 1, 'sku': wheel_variant.upc, 'position': 1, 'inventory_policy': "deny", 'fulfillment_service': "manual", 'inventory_management': "shopify", 'inventory_quantity': wheel_variant.curr_stock, 'taxable': True, 'weight': float(wheel_variant.shipping_weight), 'weight_unit': "g", # g, kg 'requires_shipping': True}) new_wheel_product.variants = [variant] if bolt_pattern2 != "": new_wheel_product.variants.append(variant2) new_wheel_product.tags = """WheelPros,Wheels""" # Get tags already put in tags = Tags() tags.string_to_tags(new_wheel_product.tags) # Now, we can go through and add the tags we want for t in tags_to_add: if not tags.is_a_tag(t) and "nan" not in t: tags.add_tag(t) new_wheel_product.tags = tags.tags_to_string() image = shopify.Image() file_name = "%s" % wheel_variant.wheel_image if ShopifyTools.is_image_and_ready(file_name): image.src = file_name else: pass # Used to see when doesn't have an image # print(wheel_variant.upc) # print(wheel_variant.style_description) # print("-----------------") new_wheel_product.images = [image] new_wheel_product.save() wheelTools.add_wheel(new_wheel_product.id, wheel_variant) # print("PRODUCT ID: ", new_wheel_product.id) new_wheel_product.save() # returns false if the record is invalid if new_wheel_product.errors: # something went wrong, see new_product.errors.full_messages() for example raise Exception("New Wheel Product Error:\n",new_wheel_product.errors.full_messages()) # Add to the database ShopifyToolsWheels.add_element(connection, "wheel_pros_wheels", f"('{new_wheel_product.id}', '{wheel_variant.style_description}', '{str(wheel_variant.upc)}', {wheel_variant.map_price}, '{wheel_variant.size}', '{bolt_pattern1}', '{wheel_variant.offset}', {wheel_variant.curr_stock}, {float(wheel_variant.shipping_weight)}, '{wheel_variant.wheel_image}', '{tags.tags_to_string()}')")
def add_new_kit(kit_variant): # 2 cases # 1) Is a variant # Tags tags_to_add = [] # Size tags_to_add.append("Size_" + kit_variant.get_size()) tags_to_add.append(kit_variant.get_tire()) tags_to_add.append(kit_variant.get_wheel()) if kitTools.has_variants(kit_variant): product_id = kitTools.find_product_id(kit_variant) new_kit_product = shopify.Product.find(product_id) variant = shopify.Variant({ 'price': kit_variant.get_msrp(), 'option1': kit_variant.get_wheel(), 'option2': kit_variant.get_tire(), 'sku': "a", 'position': 1, 'inventory_policy': "continue", 'fulfillment_service': "manual", 'inventory_management': "shopify", 'inventory_quantity': 1, 'taxable': False, 'weight': 0, 'weight_unit': "g", # g, kg 'requires_shipping': True }) # Get tags already put in tags = Tags() tags.string_to_tags(new_kit_product.tags) # Now, we can go through and add the tags we want for t in tags_to_add: if not tags.is_a_tag(t) and "nan" not in t: tags.add_tag(t) new_kit_product.tags = tags.tags_to_string() new_kit_product.variants.append(variant) new_kit_product.save() kitTools.add_kit(product_id, kit_variant) # TODO: Need to organize this code # Below is all for when there is a second bolt pattern # 2) Is not a variant else: # Update a product new_kit_product = shopify.Product() new_kit_product.options = [{'name': 'Wheel'}, {'name': 'Tire'}] new_kit_product.title = kit_variant.get_kit_name() new_kit_product.vendor = "Racks Deep Custom Performance" new_kit_product.product_type = "Kits" new_kit_product.body_html = """<b>%s</b> <h1>All Kits come mounted with new lugnuts</h1> """ % (kit_variant.get_kit_name()) variant = shopify.Variant({ 'price': kit_variant.get_msrp(), 'option1': kit_variant.get_wheel(), 'option2': kit_variant.get_tire(), 'sku': "a", 'position': 1, 'inventory_policy': "continue", 'fulfillment_service': "manual", 'inventory_management': "shopify", 'inventory_quantity': 1, 'taxable': False, 'weight': 0, 'weight_unit': "g", # g, kg 'requires_shipping': True }) new_kit_product.variants = [variant] new_kit_product.tags = """WheelPros, Kits """ # Get tags already put in tags = Tags() tags.string_to_tags(new_kit_product.tags) # Now, we can go through and add the tags we want for t in tags_to_add: if not tags.is_a_tag(t) and "nan" not in t: tags.add_tag(t) new_kit_product.tags = tags.tags_to_string() #image = shopify.Image() #file_name = "%s" % (wheel_variant.get_wheel_image()) #if ShopifyTools.is_image_and_ready(file_name): # image.src = file_name # else: # print(wheel_variant.get_upc) # print(wheel_variant.get_style_description()) # print("-----------------") # new_wheel_product.images = [image] new_kit_product.save() kitTools.add_kit(new_kit_product.id, kit_variant) if new_kit_product.errors: # something went wrong, see new_product.errors.full_messages() for example print(new_kit_product.errors.full_messages())
def process_item(self, item, of_color): """Check if item already exists. If not, create a new variant and add it.""" skip = False similar_variants = 0 for p in self._current_products[item[self.k("Style")]]: # if p.product_type != item[self.k("Category")]: # skip = True # continue # skip = False color_option = "" color = item[self.k("Color Name")].lower().strip() size_option = "" size = item[self.k("Size")].lower().strip() if len(p.options) >= 2: for option in p.options: if option.name == 'Color': color_option = 'option{}'.format(option.position) if option.name == 'Size': size_option = 'option{}'.format(option.position) else: size_option = 'option1' color_option = 'option2' if color_option and size_option: variant = None for v in p.variants: c = v.attributes[color_option].lower() cb = c == color s = v.attributes[size_option].lower() sb = s == size if v.attributes[color_option].lower() == color \ and v.attributes[size_option].lower() == size: variant = v break if variant: skip = True if variant.id: if self._sanmar: # price = self.get_price(item) price = self.get_price(item) if price != variant.price: variant.price = price variant.save() # if price != 0 and price != "": # variant.price = price self._shopify_ids[str(item[self.k("Item Number")])] = { "variant_id": variant.id, "product_id": p.id } key = 'sanmar' if self._sanmar else 'alpha' inum = str(item[self.k("Item Number")]) self._product_ids.setdefault(str(p.id), {}).setdefault( str(variant.id), {})[key] = inum break product = None for p in self._current_products[item[self.k("Style")]]: if len(p.variants) + of_color - similar_variants < 100: product = p break skip = True if not skip: if not product: product = self.new_product( item[self.k("Mill Name")], item[self.k("Style")], self.get_description_short(item), item[self.k("Full Feature Description")], item[self.k("Category")], len(self._current_products[item[self.k("Style")]])) color_option = "" size_option = "" try: color_option = [ 'option{}'.format(o.position) for o in product.options if o.name.lower() == "color" ][0] size_option = [ 'option{}'.format(o.position) for o in product.options if o.name.lower() == "size" ][0] except IndexError: size_option = 'option1' color_option = 'option2' # If total variants, plus the all of that color, mines the ones already made with the same color >= 100 # then a new product needs created. Shopify limits 100 variants / product. color = item[self.k("Color Name")].lower().strip() similar_variants = len([ v for v in product.variants if str(v.attributes[color_option]).lower() == color ]) if len(product.variants) + of_color - similar_variants >= 100: for x in range( len(self._current_products[item[self.k("Style")]])): if product.id == self._current_products[item[self.k( "Style")]][x].id: self._current_products[item[self.k( "Style")]][x] = product break size_option = 'option1' color_option = 'option2' product = self.new_product( item[self.k("Mill Name")], item[self.k("Style")], self.get_description_short(item), item[self.k("Full Feature Description")], item[self.k("Category")], len(self._current_products[item[self.k("Style")]])) price = self.get_price(item) variant = shopify.Variant({ color_option: item[self.k("Color Name")].title().strip(), size_option: item[self.k("Size").strip()], 'product_id': product.id }) self._images[item[self.k("Front of Image Name")]] = { "product_id": product.id } if price != 0 and price != "": variant.price = price product.variants.append(variant) found = False for x in range(len(self._current_products[item[self.k("Style")]])): if product.id == self._current_products[item[self.k( "Style")]][x].id: self._current_products[item[self.k("Style")]][x] = product found = True break if not found: self._current_products[item[self.k("Style")]].append(product)
def add_new_product(filter_variant): """ Method that adds a new Wheel Pros Tire to Shopify :param ds18_variant: Tire to add: :return: Returns nothing """ # TODO: Need to find a way to stream line this # TODO: Comment out the method # Make the tags that we want to add tags_to_add = [] # Brand #print(filter_variant) tags_to_add.append("Type_" + str(filter_variant.get_prod_description())) # 2 cases # 1) Is a variant print(filter_variant) if filterTools.has_variants(filter_variant): product_id = filterTools.find_product_id(filter_variant) new_filter_product = shopify.Product.find(product_id)[0] print("Type of new_filter_project: ", type(new_filter_product)) variant = shopify.Variant({ 'price': float(filter_variant.get_map_price()), 'quantity': 1, 'sku': filter_variant.get_upc(), 'position': 1, 'inventory_policy': 'continue', 'fulfillment_service': 'manual', 'inventory_management': 'shopify', 'inventory_quantity': 1, 'taxable': False, 'weight_unit': 'g', 'requires_shipping': True }) # Get tags already put in tags = Tags() print("Type of new_filter_project: ", type(new_filter_product)) tags.string_to_tags(new_filter_product.tags) # Now, we can go through and add the tags we want for t in tags_to_add: if not tags.is_a_tag(t) and "nan" not in t: tags.add_tag(t) new_filter_product.tags = tags.tags_to_string() new_filter_product.tags = tags.tags_to_string() new_filter_product.variants.append(variant) new_filter_product.save() if new_filter_product.errors: # something went wrong, see new_product.errors.full_messages() for example new_filter_product.errors.full_messages() filterTools.add_product(product_id, filter_variant) # 2) Is not a variant else: print(filter_variant) new_filter_product = shopify.Product() # Built the tire name new_filter_product.title = filter_variant.get_prod_description() new_filter_product.vendor = 'S&B Filters' new_filter_product.product_type = 'Filters' new_filter_product.body_html = """%s """ % ( filter_variant.get_prod_description()) variant = shopify.Variant({ 'price': float(filter_variant.get_map_price()), 'quantity': 1, 'sku': filter_variant.get_upc(), 'position': 1, 'inventory_policy': 'continue', 'fulfillment_service': 'manual', 'inventory_management': 'shopify', 'inventory_quantity': 1, 'taxable': False, 'weight_unit': 'g', 'requires_shipping': True }) new_filter_product.variants = [variant] new_filter_product.tags = """S&B Filters, Filters""" # Get tags already put in tags = Tags() tags.string_to_tags(new_filter_product.tags) # Now, we can go through and add the tags we want for t in tags_to_add: if not tags.is_a_tag(t) and "nan" not in t: tags.add_tag(t) new_filter_product.tags = tags.tags_to_string() url_for_image = filter_variant.get_image_url().split("|")[0] print("The image: ", url_for_image) # if not ShopifyToolsFilter.url_is_alive(url_for_image): # url_for_image = "https://sandbfilters.s3.us-east-2.amazonaws.com/" + filter_variant.get_part_num() + ".png" image = shopify.Image() image.src = url_for_image new_filter_product.images = [image] filterTools.add_product(new_filter_product.id, filter_variant) new_filter_product.save() # returns false if the record is invalid if new_filter_product.errors: print("Hello") # something went wrong, see new_product.errors.full_messages() for example new_filter_product.errors.full_messages()
def post(self, request, *args, **kwargs): reseller_id = kwargs['accountId'] dzero = decimal.Decimal(0) consignor_id = request.data.get('consignorId') category_id = request.data.get('categoryId') title = request.data.get('title') price = request.data.get('price', dzero) price = price if price else dzero retail_price = request.data.get('retailPrice', dzero) retail_price = retail_price if retail_price else dzero cost_net = request.data.get('costNet', dzero) cost_net = cost_net if cost_net else dzero quantity = request.data.get('quantity', 0) tag_quantity = request.data.get('tagQuantity', 0) item_fee = request.data.get('itemFee', dzero) item_fee = item_fee if item_fee else dzero allow_donate = request.data.get('allowDonate', False) featured_product = request.data.get('featuredProduct', False) shipping_handling = request.data.get('shippingHandling', dzero) shipping_handling = shipping_handling if shipping_handling else dzero web_fee = request.data.get('webFee', dzero) web_fee = web_fee if web_fee else dzero weight = request.data.get('weight', 0) width = request.data.get('width', 0) height = request.data.get('height', 0) date_received = request.data.get('dateReceived', datetime.datetime.now(datetime.timezone.utc)) date_updated = datetime.datetime.now(datetime.timezone.utc) list_ready = request.data.get('listReady', False) post_date = datetime.datetime.now(datetime.timezone.utc) description = request.data.get('description', '') reseller = Reseller.objects.filter(pk=reseller_id).first() consignor = Consignor.objects.filter(pk=consignor_id).first() category = Category.objects.filter(pk=category_id).first() item = Item( reseller=reseller, consignor=consignor, category=category, title=title, price=price, retail_price=retail_price, cost_net=cost_net, quantity=quantity, tag_quantity=tag_quantity, item_fee=item_fee, allow_donate=allow_donate, featured_product=featured_product, shipping_handling=shipping_handling, web_fee=web_fee, weight=weight, width=width, height=height, date_received=date_received, list_ready=list_ready, post_date=post_date, date_updated=date_updated, status='NEW' ) item.save() attributes = request.data.get('attributes') attributes = json.loads(attributes) for a in attributes: print(a) attribute_id = a['attributeId'] attribute = Attributes.objects.filter(pk=attribute_id).first() ItemAttributes(reseller=reseller, item=item, attribute=attribute, value=a['value']).save() session = shopify.Session(reseller.domain, '2019-04', reseller.shopify_access_token) shopify.ShopifyResource.activate_session(session) new_product = shopify.Product() new_product.title = title new_product.product_type = category.json()['displayName'] description = """ <strong> {0} </strong> <br /><br /> """.format(description) new_product.save() variant_object = { "product_id": new_product.id, "inventory_quantity": str(quantity), "price": str(price), "weight": weight } for a in attributes: attribute_id = a['attributeId'] attribute = Attributes.objects.filter(pk=attribute_id).first() new_product.add_metafield(shopify.Metafield({ 'namespace': 'attribute', 'key': attribute.json()['name'], 'value': a['value'], 'value_type': 'string', })) variant_object[attribute.json()['name']] = a['value'] description = """ {0} <strong> {1} </strong>: {2} <br /> """.format(description, attribute.json()['name'], a['value']) variant = shopify.Variant(variant_object) variant.save() new_product.body_html = description new_product.add_variant(variant) new_product.save() item.description = description item.save() for image in request.data.getlist('image'): file_type = image.name.rsplit('.', 1)[1] photo = ItemPhotos(reseller=reseller, item=item, file_type=file_type) photo.save() photo_json = photo.json() content_type = "image/" + photo.file_type response = self.spaces_client.put_object( Body=image, # Path to local file Bucket=photo_json['bucket'], # Name of Space Key=photo_json['url'], ACL='public-read', ContentType=content_type) return Response(status=status.HTTP_201_CREATED)
def add_new_tire(connection, tire_variant): """ Method that adds a new Wheel Pros Tire to Shopify :param tire_variant: Tire to add: :return: Returns nothing """ # TODO: Need to find a way to stream line this # TODO: Comment out the method # Make the tags that we want to add tags_to_add = [] # Ply if tire_variant.get_ply() != "0": tags_to_add.append("Ply_" + tire_variant.get_ply()) # Speed Rating # tags_to_add.append("Speed Rating_"+tire_variant.get_speed_rating()) # Rim Diameter tags_to_add.append("Rim Diameter_" + tire_variant.get_rim_diameter() + "\"") # Tire Diameter # tags_to_add.append("Tire Diameter_"+tire_variant.get_tire_diameter()) # Full Model Name # tags_to_add.append("Model_"+tire_variant.get_full_model_name()) # Construction Type tags_to_add.append("Construction Type_" + tire_variant.get_construction_type()) # Terrain tags_to_add.append("Terrain_" + tire_variant.get_terrain()) # Need to find out the correct price if float(tire_variant.get_map_price()) == 0: price_for_tire = tire_variant.get_mrsp_price() else: price_for_tire = tire_variant.get_map_price() #Need to take out certain parts and change option1 option1 = tire_variant.get_tire_size_description() option1 = option1.replace("R", "X") option1 = option1.replace("LT", "") option1 = option1.replace("-", "X") # 2 cases # 1) Is a variant if tireTools.has_variants(tire_variant): product_id = tireTools.find_product_id(tire_variant) new_tire_product = shopify.Product.find(product_id) variant = shopify.Variant({ 'price': float(price_for_tire), 'option1': option1, 'quantity': 1, 'sku': tire_variant.get_upc(), 'position': 1, 'inventory_policy': 'deny', 'fulfillment_service': 'manual', 'inventory_management': 'shopify', 'inventory_quantity': tire_variant.get_curr_stock(), 'taxable': False, 'weight': float(tire_variant.get_weight()), 'weight_unit': 'g', 'requires_shipping': True }) # Get tags already put in tags = Tags() tags.string_to_tags(new_tire_product.tags) # Now, we can go through and add the tags we want for t in tags_to_add: if not tags.is_a_tag(t) and "nan" not in t: tags.add_tag(t) new_tire_product.tags = tags.tags_to_string() new_tire_product.variants.append(variant) new_tire_product.save() tireTools.add_tire(product_id, tire_variant) # 2) Is not a variant else: new_tire_product = shopify.Product() new_tire_product.options = [{'name': 'Tire Size'}] # Built the tire name new_tire_product.title = tire_variant.get_full_model_name() new_tire_product.vendor = 'Wheel Pros' new_tire_product.product_type = 'Tires' new_tire_product.body_html = """<b>%s</b> <p>%s</p> """ % (tire_variant.get_tire_description(), tire_variant.get_part_num()) variant = shopify.Variant({ 'price': float(price_for_tire), 'option1': option1, 'quantity': 1, 'sku': tire_variant.get_upc(), 'position': 1, 'inventory_policy': 'deny', 'fulfillment_service': 'manual', 'inventory_management': 'shopify', 'inventory_quantity': tire_variant.get_curr_stock(), 'taxable': False, 'weight': float(tire_variant.get_weight()), 'weight_unit': 'g', 'requires_shipping': True }) new_tire_product.variants = [variant] new_tire_product.tags = """WheelPros, Tires, %s, %s, %s, %s,""" % (tire_variant.get_full_model_name(), tire_variant.get_part_num(), tire_variant.get_tire_size(), tire_variant.get_upc()) # Get tags already put in tags = Tags() tags.string_to_tags(new_tire_product.tags) # Now, we can go through and add the tags we want for t in tags_to_add: if not tags.is_a_tag(t) and "nan" not in t: tags.add_tag(t) image = shopify.Image() file_name = tire_variant.get_picture_cd() image.src = file_name new_tire_product.images = [image] new_tire_product.save() tireTools.add_tire(new_tire_product.id, tire_variant) new_tire_product.save() # returns false if the record is invalid if new_tire_product.errors: # something went wrong, see new_product.errors.full_messages() for example new_tire_product.errors.full_messages() # Add to the database ShopifyToolsTires.add_element( connection, "wheel_pros_tires", f"('{new_tire_product.id}', '{tire_variant.get_full_model_name()}', '{tire_variant.upc}', {tire_variant.map_price}, '{option1}', '', '', {tire_variant.curr_stock}, {float(tire_variant.weight)}, '{tire_variant.get_picture_cd()}', '{tags.tags_to_string()}')" )
def add_new_product(ds18_variant): """ Method that adds a new Wheel Pros Tire to Shopify :param ds18_variant: Tire to add: :return: Returns nothing """ # TODO: Need to find a way to stream line this # TODO: Comment out the method print(ds18_variant.get_model()) # Make the tags that we want to add tags_to_add = [] # Brand tags_to_add.append("Brand_" + ds18_variant.get_collection()) # 2 cases # 1) Is a variant if ds18Tools.has_variants(ds18_variant): return product_id = ds18Tools.find_product_id(ds18_variant) new_ds18_product = shopify.Product.find(product_id) variant = shopify.Variant({ 'price': float(ds18_variant.get_msrp_price()), 'quantity': 1, 'sku': ds18_variant.get_model(), 'position': 1, 'inventory_policy': 'continue', 'fulfillment_service': 'manual', 'inventory_management': 'shopify', 'inventory_quantity': 1, 'taxable': False, 'weight_unit': 'g', 'requires_shipping': True }) # Get tags already put in tags = Tags() tags.string_to_tags(new_ds18_product.tags) # Now, we can go through and add the tags we want for t in tags_to_add: if not tags.is_a_tag(t) and "nan" not in t: tags.add_tag(t) new_ds18_product.tags = tags.tags_to_string() new_ds18_product.tags = tags.tags_to_string() new_ds18_product.variants.append(variant) new_ds18_product.save() ds18Tools.add_product(product_id, ds18_variant) # 2) Is not a variant else: new_ds18_product = shopify.Product() # Built the tire name new_ds18_product.title = ds18_variant.get_name() new_ds18_product.vendor = 'DS 18' new_ds18_product.product_type = 'Sound' new_ds18_product.body_html = """<b>%s</b> <p>%s</p> """ % (ds18_variant.get_brand, ds18_variant.get_name()) variant = shopify.Variant({ 'price': float(ds18_variant.get_msrp_price()), 'quantity': 1, 'sku': ds18_variant.get_model(), 'position': 1, 'inventory_policy': 'continue', 'fulfillment_service': 'manual', 'inventory_management': 'shopify', 'inventory_quantity': 1, 'taxable': False, 'weight_unit': 'g', 'requires_shipping': True }) new_ds18_product.variants = [variant] new_ds18_product.tags = """DS18, Sound""" # Get tags already put in tags = Tags() tags.string_to_tags(new_ds18_product.tags) # Now, we can go through and add the tags we want for t in tags_to_add: if not tags.is_a_tag(t) and "nan" not in t: tags.add_tag(t) new_ds18_product.tags = tags.tags_to_string() image = shopify.Image() image.src = "https://ds18.s3.us-east-2.amazonaws.com/" + ds18_variant.get_model( ).replace("-", "").replace("/", "") + ".jpg" new_ds18_product.images = [image] ds18Tools.add_product(new_ds18_product.id, ds18_variant) new_ds18_product.save() # returns false if the record is invalid if new_ds18_product.errors: # something went wrong, see new_product.errors.full_messages() for example new_ds18_product.errors.full_messages()