Créer un produit "parent" canonique dans Django Oscar par programmation

Question

J'essaie d'utiliser une version modifiée de la classe django-oscar import_oscar_catalogue pour importer un tas de produits à partir d'un CSV, et lors de la première rencontre d'un produit (défini par le titre) , créez un produit parent canonique, puis, pour toutes les futures rencontres, créez un produit enfant sous ce produit parent.

Cela semble fonctionner, mais le produit canonique ne reflète pas les niveaux de stock combinés du produit enfant, ni n'affiche les attributs corrects pour ce produit. Il les répertorie correctement comme des variations dans le tableau de bord django.

Comment puis-je créer par programme cette relation enfant/parent dans les produits, avec les enregistrements de stock corrects?

Code pertinent:

def _create_item(self, upc, title, product_class, other_product_attributes): 
    product_class, __ \ 
     = ProductClass.objects.get_or_create(name=product_class) 
    try: 
     parent = Product.objects.get(title=title) 
     item = Product() 
     item.parent = parent 
    except Product.DoesNotExist: 
     # Here is where I think it might need to be changed 
     # Maybe pitem = ParentProduct() or something? 
     pitem = Product() 
     pitem.upc = upc 
     pitem.title = title 
     pitem.other_product_attributes = other_product_attributes 
     # Here parent item is saved to db 
     pitem.save() 
     # Create item because no parent was found 
     item = Product() 
     parent = Product.objects.get(title=title) 
     #Set parent 
     item.parent = parent 
    # Customize child attributes 
    item.product_class = product_class 
    item.title = title 
    item.other_product_attributes = other_product_attributes 
    # Save the child item 
    item.save() 

def _create_stockrecord(self, item, partner_name, partner_sku, price_excl_tax, 
    num_in_stock, stats): 
    # Create partner and stock record 
    partner, _ = Partner.objects.get_or_create(
     name=partner_name) 
    try: 
     stock = StockRecord.objects.get(partner_sku=partner_sku) 
    except StockRecord.DoesNotExist: 
     stock = StockRecord() 
     stock.num_in_stock = 0 
    # General attributes 
    stock.product = item 
    stock.partner = partner 
    # SKU will be unique for every object 
    stock.partner_sku = partner_sku 
    stock.price_excl_tax = D(price_excl_tax) 
    stock.num_in_stock += int(num_in_stock) 
    # Save the object to database 
    stock.save() 

Le create_stockrecord() crée un enregistrement de 1 stock pour chaque variation de l'article unique, mais les stockrecords de ces variations ne se traduisent pas l'élément parent.

Merci pour vos suggestions.

EDIT: J'ai mis à jour la classe avec une méthode qui appelle explicitement ProductClass.objects.track_stock() par rapport à l'instance ProductClass, et je l'appelle après avoir parcouru toutes les lignes du fichier CSV (en passant nom de la classe de produit que j'utilise actuellement). Cependant, lorsque l'on regarde le stock dans le tableau de bord, aucun stock enfant/variation n'est comptabilisé par rapport au parent.

def track_stock(self, class_name): 
    self.logger.info("ProductClass name: %s" % class_name) 
    product_class = ProductClass.objects.get_or_create(name=class_name) 
    self.logger.info("ProductClass: %s" % str(product_class)) 
    self.logger.info("TrackStock: %s" % str(product_class[0].track_stock)) 
    product_class[0].track_stock = True 
    self.logger.info("TrackStock: %s" % str(product_class[0].track_stock)) 
    product_class[0].save() 


INFO Starting catalogue import 
INFO - Importing records from 'sample_inventory.csv' 
INFO - Flushing product data before import 
INFO Parent items: 6, child items: 10 
INFO ProductClass name: ClassName 
INFO ProductClass: (<ProductClass: ClassName>, False) 
INFO TrackStock: True 
INFO TrackStock: True 

J'ai vérifié la page d'administration, seulement 1 ProductClass est créé, et il a le même nom que est transmis à track_stock(). Y at-il quelque chose d'autre qui doit être fait pour activer cette fonctionnalité? track_stock() la documentation est plutôt rare. Dans la sortie, track_stock semble être vrai dans les deux cas. Est-ce que cela doit être False pendant que les child_objects sont créés, puis retournés à True?

EDIT: SOLUTION:

Après quelques recherches de la test factory, je l'ai résolu la question en spécifiant

product.stucture = 'parent' 

Sur l'objet parent et

product.structure = 'child' 

sur l'objet enfant. J'ai aussi besoin de changer les attributs personnalisés de mes objets à un dict product_attributes, puis définissez chaque valeur de l'objet:

if product_attributes: 
     for code, value in product_attributes.items(): 
      product_class.attributes.get_or_create(name=code, code=code) 
      setattr(product.attr, code, value) 

Il n'a pas été nécessaire de créer un dossier de stock pour chaque objet parent, car ils suivent la les registres de stock des objets enfants auxquels ils sont associés. Il était également pas nécessaire de fixer track_stock = True, comme il est défini sur True par défaut lors de la création d'un Product()

Answer 1

Pour pouvoir refléter correctement les niveaux de stock pour tout Product vous devez avoir un Partner qui fournira le produit et vous devez avoir StockRecord qui relie le partenaire et les produits ensemble.

D'abord, assurez-vous d'avoir toutes ces informations dans la base de données pour chacune de vos variantes Product.

Ensuite, vous devez mettre à jour votre ProductClass et définir l'attribut "track_stock" sur True comme son Aucun par défaut.

Vous devez également supprimer le ProductClass de vos produits enfants car ils héritent du ProductClass de leur produit parent.

EDIT 1:

Pour ajouter des attributs à un produit que vous devez ajouter un pour l'ProductClass Types de produit et vous pouvez définir les attributs directement sur le produit like this example.

EDIT 2:

Vous devez également définir la "net_stock_level" sur le StockRecord.

Pour en savoir plus sur la manière dont Oscar obtient les niveaux de stock, regardez Selector. Cette classe détermine les stratégies de tarification, de taxe et de niveau de stock à utiliser que vous devrez peut-être personnaliser dans le futur si vous souhaitez facturer des taxes ou proposer des prix différents en fonction de l'utilisateur.