Weisen Sie eine Seriennummer zu, wenn die Menge mehr als eins ist.

Question

Ich habe ein Modell, in dem eine eindeutige Seriennummer generiert wird, und es gibt ein Mengenfeld, in dem der Benutzer auswählen kann, wie viele Teile er herstellen möchte. Denken Sie daran wie ein Einkaufsauftrag. Ich möchte, dass, wenn der Benutzer eine Menge von mehr als eins auswählt, jedem einzelnen Teil eine Seriennummer zugewiesen wird. Modelle:

from __future__ import unicode_literals 
from tande.models import Project, Person 
from django.db import models 
from django.utils import timezone 
from django.utils.text import slugify 
from django.core.exceptions import NON_FIELD_ERRORS, ValidationError 
from django.utils.translation import ugettext_lazy as _ 
from django.core.urlresolvers import reverse 
from django.db.models.signals import pre_save 
from django.conf import settings 

# Create your models here. 
class buildrisk(models.Model): 
    risk = models.CharField(max_length=20, default = 'Select Risk') 
    def __unicode__ (self): 
      return self.risk 

class sens(models.Model): 
    sens = models.CharField(max_length=20, default = 'Select Sensitivity') 
    def __unicode__ (self): 
      return self.sens 

class MOI(models.Model): 
    method = models.CharField(max_length=20, default = 'Select Method') 
    def __unicode__ (self): 
      return self.method 

def number(): 
    no = PartRequest.objects.count() 
    if no == None: 
     return "PR00001" 
    else: 
     return "PR00" + str(no + 100) 

def snumber(): 
    no = PartRequest.objects.count() 
    add = sum(map(int, str(no))) 
    if no == None: 
     return "SN00001" 
    else: 
     return "SN00" + str(no + 100 + add) 
    # while n: 
    # sn, n = sn + n % 10, n // 10 
    # return sn 

class PartRequest(models.Model): 
    user = models.ForeignKey(settings.AUTH_USER_MODEL, default=1) 
    part_request_number = models.CharField(_('Part Request Number'),max_length=10, default = number) 
    serialnumber = models.CharField(_('Serial Number'),max_length=10, default= snumber) 
    project_manager = models.ForeignKey(Person, related_name = 'Manager', null = True) 
    requester = models.ForeignKey(Person, related_name = 'Requester', null = True) #drop down 
    project_id = models.ForeignKey(Project, related_name = 'Project', null=True) 
    ordernumber = models.PositiveIntegerField(_('Order Number'), default=0) 
    description = models.CharField(_('Description'), max_length=500) 
    quantityrequired = models.PositiveIntegerField(_('Quantity'), default=0) 
    sensitivity = models.ForeignKey(sens, related_name='sensitivity', null=True) #drop down 
    identification_method = models.ForeignKey(MOI, related_name= 'MOI', null=True) 
    build_risk = models.ForeignKey(buildrisk, related_name= 'Risk', null=True) 
    daterequired = models.DateField(_('Date Required'), default = '04/08/16') 
    slug = models.SlugField(unique=True, null=True) 
    def __str__(self): 
     return unicode(self.requester) 

    def get_absolute_url(self): 
     return "/buildpage/%s/" %(self.slug) 
#return ("buildpage:page3", kwargs = {"slug": self.slug}) 

def create_slug(instance, new_slug=None): 
    slug = slugify(instance.part_request_number) 
    if new_slug is not None: 
     slug = new_slug 
    qs = PartRequest.objects.filter(slug=slug).order_by("-id") 
    exists = qs.exists() 
    if exists: 
     new_slug = "%s-%s" %(slug, qs.first().id) 
     return create_slug(instance, new_slug=new_slug) 
    return slug 

def pre_save_receiver(sender, instance, *args, **kwargs): 
    if not instance.slug: 
     instance.slug = create_slug(instance) 
pre_save.connect(pre_save_receiver, sender = PartRequest) 

Aufrufe:

from django.shortcuts import render, get_object_or_404, redirect, get_object_or_404 
from django.contrib import messages 
from django.http import HttpResponse, Http404, HttpResponseRedirect 
from django.template import RequestContext, loader 
from django.contrib.auth.decorators import login_required 
from .forms import PartRequestForm 
from .models import PartRequest 
from tande.models import Project, Person 

# Create your views here. 
@login_required 
def home(request): 
    latest_project_list = Project.objects.all() 
    context = {'latest_project_list': latest_project_list} 
    return render(request, 'buildpage/home.html', context) 

def partrequestinfo(request): 
    if not request.user.is_staff or not request.user.is_superuser: 
     raise Http404 
    req_form = PartRequestForm(request.POST or None, request.FILES or None) 
    if req_form.is_valid(): 
      instance = req_form.save(commit=False) 
      instance.user = request.user 
      print request.POST 
      print req_form.cleaned_data.get("requester") 
      print instance 
      instance.save() 
      messages.success(request, "Successfully Created") 
      return HttpResponseRedirect(instance.get_absolute_url()) 
    else: 
     context = { 
       "req_form": req_form 
     } 
    return render(request, "buildpage/partrequestinfo.html", context) 

def partrequestdetail(request, slug=None): 
    print "in partrequestdetail function" 
    instance = get_object_or_404(PartRequest, slug=slug) 
    context = { 
     "project_id": instance.project_id, 
     "instance": instance, 
    } 
    return render(request, 'buildpage/partrequestdetail.html', context) 

def partrequestupdate(request, slug=None): 
    if not request.user.is_staff or not request.user.is_superuser: 
     raise Http404 
    instance = get_object_or_404(PartRequest, slug=slug) 
    req_form = PartRequestForm(request.POST or None, request.FILES or None, instance=instance) 
    if req_form.is_valid(): 
      instance = req_form.save(commit=False) 
      print request.POST 
      print req_form.cleaned_data.get("requester") 
      print instance 
      instance.save() 
      messages.success(request, "Saved") 
      return HttpResponseRedirect(instance.get_absolute_url()) 
    context = { 
     "project_id": instance.project_id, 
     "instance": instance, 
     "req_form": req_form, 
    } 
    return render(request, 'buildpage/partrequestinfo.html', context) 

def partrequestdelete(request, slug=None): 
    if not request.user.is_staff or not request.user.is_superuser: 
     raise Http404 
    instance = get_object_or_404(PartRequest, slug=slug) 
    messages.success(request, "Successfully Deleted") 
    return redirect("buildpage:home") 

def preparebuildlist(request, slug=None): 

    return render(request, 'buildpage/preparebuildlist.html') 

Answer 1

Ich kann nicht wirklich Ihre Modelle verstehen, aber ich denke, was Sie brauchen (wenn Sie nicht bereits es haben) ist ein Part Modell. Ein Feld im Modell Part muss die Seriennummer des Teils sein, die automatisch generiert werden kann, wenn Sie möchten. Wenn ein Benutzer X Teile anfordert, können Sie einfach X Part Objekte erstellen und speichern.