Managing Product UOMs and Price Tags in Django

Based on your model structure, here are some best practices for efficiently managing products with multiple UOMs and price tags in Django:

1. Use Django Formsets for Related Models

For handling multiple UOMs and price tags during product creation/editing, Django's formsets are ideal:

PYTHONCopied
from django import forms
from django.forms import inlineformset_factory
from .models import Product, ProductUom, ProductPrice, PriceTag

class ProductForm(forms.ModelForm):
    class Meta:
        model = Product
        fields = ['name', 'category', 'image0', 'image1', 'image2', 'image3', 'image4', 
                 'short_desc', 'description', 'base_cost', 'raw_material_cost', 
                 'base_sale', 'rsp', 'active']

# Create formsets for related models
UomFormSet = inlineformset_factory(
    Product, ProductUom, 
    fields=('uom', 'qty'), 
    extra=1, can_delete=True
)

PriceFormSet = inlineformset_factory(
    Product, ProductPrice,
    fields=('price_tag', 'price'),
    extra=1, can_delete=True
)

2. View Implementation

PYTHONCopied
from django.shortcuts import render, redirect, get_object_or_404
from django.views.generic import CreateView, UpdateView
from django.db import transaction

class ProductCreateView(CreateView):
    model = Product
    form_class = ProductForm
    template_name = 'products/product_form.html'
    
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        if self.request.POST:
            context['uom_formset'] = UomFormSet(self.request.POST)
            context['price_formset'] = PriceFormSet(self.request.POST)
        else:
            context['uom_formset'] = UomFormSet()
            context['price_formset'] = PriceFormSet()
        return context
    
    @transaction.atomic
    def form_valid(self, form):
        context = self.get_context_data()
        uom_formset = context['uom_formset']
        price_formset = context['price_formset']
        
        if uom_formset.is_valid() and price_formset.is_valid():
            self.object = form.save()
            uom_formset.instance = self.object
            uom_formset.save()
            price_formset.instance = self.object
            price_formset.save()
            return redirect('product_detail', pk=self.object.pk)
        else:
            return self.render_to_response(self.get_context_data(form=form))

3. Template Example

HTMLCopied
<form method="post" enctype="multipart/form-data">
    {% csrf_token %}
    {{ form.as_p }}
    
    <h3>Units of Measure</h3>
    {{ uom_formset.management_form }}
    <div id="uom-forms">
        {% for uom_form in uom_formset %}
            <div class="uom-form">
                {{ uom_form.as_p }}
            </div>
        {% endfor %}
    </div>
    <button type="button" id="add-uom">Add Another UOM</button>
    
    <h3>Price Tiers</h3>
    {{ price_formset.management_form }}
    <div id="price-forms">
        {% for price_form in price_formset %}
            <div class="price-form">
                {{ price_form.as_p }}
            </div>
        {% endfor %}
    </div>
    <button type="button" id="add-price">Add Another Price Tier</button>
    
    <button type="submit">Save Product</button>
</form>

4. JavaScript for Dynamic Form Addition

JAVASCRIPTCopied
document.addEventListener('DOMContentLoaded', function() {
    // For UOM forms
    const uomContainer = document.querySelector('#uom-forms');
    const addUomButton = document.querySelector('#add-uom');
    
    addUomButton.addEventListener('click', function() {
        const formCount = document.querySelector('#id_uoms-TOTAL_FORMS');
        const newForm = uomContainer.querySelector('.uom-form').cloneNode(true);
        
        // Update form index
        newForm.innerHTML = newForm.innerHTML.replace(/uoms-\d+/g, `uoms-${formCount.value}`);
        newForm.innerHTML = newForm.innerHTML.replace(/id_uoms-\d+/g, `id_uoms-${formCount.value}`);
        
        // Clear form values
        newForm.querySelectorAll('input').forEach(input => {
            input.value = '';
        });
        
        uomContainer.appendChild(newForm);
        formCount.value = parseInt(formCount.value) + 1;
    });
    
    // Similar code for price forms
});

5. Admin Configuration

For admin interface, use TabularInline for related models:

PYTHONCopied
from django.contrib import admin
from .models import Product, ProductUom, ProductPrice, Category, PriceTag

class ProductUomInline(admin.TabularInline):
    model = ProductUom
    extra = 1

class ProductPriceInline(admin.TabularInline):
    model = ProductPrice
    extra = 1

@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
    list_display = ('name', 'category', 'base_sale', 'active')
    list_filter = ('category', 'active')
    search_fields = ('name', 'short_desc')
    inlines = [ProductUomInline, ProductPriceInline]

admin.site.register(Category)
admin.site.register(PriceTag)

6. Bulk Operations

For bulk operations, consider using Django's bulk_create and bulk_update:

PYTHONCopied
def create_product_with_relations(product_data, uoms_data, prices_data):
    with transaction.atomic():
        # Create the product
        product = Product.objects.create(**product_data)
        
        # Create UOMs
        uoms = [ProductUom(product=product, **uom_data) for uom_data in uoms_data]
        ProductUom.objects.bulk_create(uoms)
        
        # Create price tags
        prices = [ProductPrice(product=product, **price_data) for price_data in prices_data]
        ProductPrice.objects.bulk_create(prices)
        
        return product

These approaches should help you efficiently manage the complex relationships between products, UOMs, and price tags in your wholesale application.

Managing Related Models in Django for Product Management

Your model structure looks well-designed for a wholesale product management system. For efficiently managing the upload and editing process for products with multiple UOMs and price tags, I can suggest some approaches based on Django's best practices.

Using Django Admin with Inline Forms

Django's admin interface provides a powerful way to manage related models through inline forms. This would allow you to create/edit a product and its related UOMs and price tags in a single form.

PYTHONCopied
from django.contrib import admin
from .models import Product, ProductUom, ProductPrice, Category, PriceTag

class ProductUomInline(admin.TabularInline):
    model = ProductUom
    extra = 1  # Number of empty forms to display

class ProductPriceInline(admin.TabularInline):
    model = ProductPrice
    extra = 1

@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
    inlines = [ProductUomInline, ProductPriceInline]
    list_display = ['name', 'category', 'base_sale', 'active', 'updated_at']
    list_filter = ['category', 'active']
    search_fields = ['name', 'short_desc']

admin.site.register(Category)
admin.site.register(PriceTag)

Using ModelForms with Formsets for Custom Views

For a more customized interface, you can use Django's formsets to handle multiple related models:

PYTHONCopied
from django import forms
from django.forms import inlineformset_factory
from .models import Product, ProductUom, ProductPrice

class ProductForm(forms.ModelForm):
    class Meta:
        model = Product
        fields = ['name', 'category', 'image0', 'image1', 'image2', 'image3', 'image4', 
                 'short_desc', 'description', 'base_cost', 'raw_material_cost', 
                 'base_sale', 'rsp', 'active']

# Create formsets for related models
UomFormSet = inlineformset_factory(
    Product, ProductUom, 
    fields=['uom', 'qty'], 
    extra=1, can_delete=True
)

PriceFormSet = inlineformset_factory(
    Product, ProductPrice,
    fields=['price_tag', 'price'],
    extra=1, can_delete=True
)

Then in your view:

PYTHONCopied
from django.shortcuts import render, redirect, get_object_or_404
from django.views import View
from .forms import ProductForm, UomFormSet, PriceFormSet
from .models import Product

class ProductCreateView(View):
    def get(self, request):
        form = ProductForm()
        uom_formset = UomFormSet()
        price_formset = PriceFormSet()
        return render(request, 'create_product.html', {
            'form': form,
            'uom_formset': uom_formset,
            'price_formset': price_formset
        })
    
    def post(self, request):
        form = ProductForm(request.POST, request.FILES)
        if form.is_valid():
            product = form.save()
            uom_formset = UomFormSet(request.POST, instance=product)
            price_formset = PriceFormSet(request.POST, instance=product)
            
            if uom_formset.is_valid() and price_formset.is_valid():
                uom_formset.save()
                price_formset.save()
                return redirect('product_detail', pk=product.pk)
        
        # If form is invalid, re-render with errors
        uom_formset = UomFormSet(request.POST)
        price_formset = PriceFormSet(request.POST)
        return render(request, 'create_product.html', {
            'form': form,
            'uom_formset': uom_formset,
            'price_formset': price_formset
        })

class ProductUpdateView(View):
    def get(self, request, pk):
        product = get_object_or_404(Product, pk=pk)
        form = ProductForm(instance=product)
        uom_formset = UomFormSet(instance=product)
        price_formset = PriceFormSet(instance=product)
        return render(request, 'update_product.html', {
            'form': form,
            'uom_formset': uom_formset,
            'price_formset': price_formset
        })
    
    def post(self, request, pk):
        product = get_object_or_404(Product, pk=pk)
        form = ProductForm(request.POST, request.FILES, instance=product)
        if form.is_valid():
            product = form.save()
            uom_formset = UomFormSet(request.POST, instance=product)
            price_formset = PriceFormSet(request.POST, instance=product)
            
            if uom_formset.is_valid() and price_formset.is_valid():
                uom_formset.save()
                price_formset.save()
                return redirect('product_detail', pk=product.pk)
        
        # If form is invalid, re-render with errors
        uom_formset = UomFormSet(request.POST, instance=product)
        price_formset = PriceFormSet(request.POST, instance=product)
        return render(request, 'update_product.html', {
            'form': form,
            'uom_formset': uom_formset,
            'price_formset': price_formset
        })

Template Example

Here's a simplified template example for the form:

HTMLCopied
<form method="post" enctype="multipart/form-data">
    {% csrf_token %}
    
    <h2>Product Information</h2>
    {{ form.as_p }}
    
    <h2>Units of Measure</h2>
    {{ uom_formset.management_form }}
    <table>
        <thead>
            <tr>
                <th>UOM</th>
                <th>Quantity</th>
                <th>Delete</th>
            </tr>
        </thead>
        <tbody>
            {% for uom_form in uom_formset %}
                <tr>
                    <td>{{ uom_form.uom }}</td>
                    <td>{{ uom_form.qty }}</td>
                    <td>{{ uom_form.DELETE }}</td>
                </tr>
            {% endfor %}
        </tbody>
    </table>
    <button type="button" id="add-uom">Add UOM</button>
    
    <h2>Price Tiers</h2>
    {{ price_formset.management_form }}
    <table>
        <thead>
            <tr>
                <th>Price Tag</th>
                <th>Price</th>
                <th>Delete</th>
            </tr>
        </thead>
        <tbody>
            {% for price_form in price_formset %}
                <tr>
                    <td>{{ price_form.price_tag }}</td>
                    <td>{{ price_form.price }}</td>
                    <td>{{ price_form.DELETE }}</td>
                </tr>
            {% endfor %}
        </tbody>
    </table>
    <button type="button" id="add-price">Add Price Tier</button>
    
    <button type="submit">Save Product</button>
</form>

Additional Considerations

1. JavaScript Enhancement: Add JavaScript to dynamically add/remove formset rows for better UX.

2. Validation: Consider adding custom validation to ensure all required UOMs and price tiers are provided.

3. Bulk Operations: For managing multiple products, consider implementing Django's bulk_create and bulk_update methods.

4. Transaction Management: Use Django's transaction.atomic to ensure all related models are saved or none at all:

PYTHONCopied
from django.db import transaction

@transaction.atomic
def save_product_with_relations(product_data, uom_data, price_data):
    # Create or update product and related models
    # If any operation fails, the entire transaction is rolled back

This approach should provide a solid foundation for managing your product relationships efficiently while maintaining data integrity.