docs: def form_valid(self, form):
          if self.__pk:
              obj = PurchasesAlbaran.objects.get(pk=self.__pk)
              self.request.albaran = obj
              form.instance.albaran = obj
  
          form.instance.validator_user = self.request.user
  
          raise Exception("revisar StorageBatch")
          """
          batch = StorageBatch.objects.filter(pk=form.data['batch']).first()
          if not batch:
              errors = form._errors.setdefault("batch", ErrorList())
              errors.append(_("Batch invalid"))
              return super(LineAlbaranCreate, self).form_invalid(form)
          """
  
          # comprueba si el producto comprado requiere un valor de atributo especial
          product_final = ProductFinal.objects.filter(pk=form.data['product']).first()
          feature_special_value = None
          if not product_final:
              errors = form._errors.setdefault("feature_special_value", ErrorList())
              errors.append(_("Product not selected"))
              return super(LineAlbaranCreate, self).form_invalid(form)
          elif product_final.product.feature_special:
              # es obligatorio la informacion de caracteristicas especiales
              if 'feature_special_value' not in form.data or not form.data['feature_special_value']:
                  errors = form._errors.setdefault("feature_special_value", ErrorList())
                  errors.append(_("Product needs information of feature special"))
                  return super(LineAlbaranCreate, self).form_invalid(form)
              else:
                  feature_special_value = list(set(filter(None, form.data['feature_special_value'].split('\n'))))
                  try:
                      quantity = int(float(form.data['quantity']))
                  except ValueError:
                      errors = form._errors.setdefault("quantity", ErrorList())
                      errors.append(_("Quantity is not valid"))
                      return super(LineAlbaranCreate, self).form_invalid(form)
  
                  if product_final.product.feature_special.unique:
                      # mismo numero de caracteristicas que de cantidades
                      # si el feature special esta marcado como 'unico'
                      if len(feature_special_value) != quantity:
                          errors = form._errors.setdefault("feature_special_value", ErrorList())
                          errors.append(_("Quantity and values of feature special not equals"))
                          return super(LineAlbaranCreate, self).form_invalid(form)
                      # no existen las caracteristicas especiales dadas de alta en el sistema
                      elif ProductUnique.objects.filter(product_final=product_final, value__in=feature_special_value).exists():
                          errors = form._errors.setdefault("feature_special_value", ErrorList())
                          errors.append(_("Some value of feature special exists"))
                          return super(LineAlbaranCreate, self).form_invalid(form)
                  elif len(feature_special_value) != 1:
                      errors = form._errors.setdefault("feature_special_value", ErrorList())
                      errors.append(_("The special feature must be unique for all products"))
                      return super(LineAlbaranCreate, self).form_invalid(form)
          try:
              with transaction.atomic():
                  # save line albaran
                  result = super(LineAlbaranCreate, self).form_valid(form)
  
                  raise Exception("Cambiar ProductStock por ProductUnique")
                  """
                  if self.object.status != PURCHASE_ALBARAN_LINE_STATUS_REJECTED:
                      # prepare stock
                      ps = ProductStock()
                      ps.product_final = product_final
                      ps.line_albaran = self.object
                      ps.batch = batch
                      # save stock
                      ps.quantity = self.object.quantity
                      ps.save()
  
                      if feature_special_value:
                          # prepare product feature special
                          if product_final.product.feature_special.unique:
                              pfs = ProductUnique()
                              pfs.product_final = product_final
                              # save product featureSpecial and stock
                              for fs in feature_special_value:
                                  pfs.pk = None
                                  pfs.value = fs
                                  pfs.save()
  
                          else:
                              pfs = ProductUnique.objects.filter(
                                  value=feature_special_value[0],
                                  product_final=product_final
                              ).first()
                              if pfs:
                                  pfs.stock_real += self.object.quantity
                              else:
                                  pfs = ProductUnique()
                                  pfs.product_final = product_final
                                  pfs.value = feature_special_value[0]
                                  pfs.stock_real = self.object.quantity
                              pfs.save()
                      else:
                          # product unique by default
                          pfs = ProductUnique.objects.filter(product_final=product_final).first()
                          if not pfs:
                              pfs = ProductUnique()
                              pfs.product_final = product_final
                              pfs.stock_real = self.object.quantity
                          else:
                              pfs.stock_real += self.object.quantity
                          pfs.save()
                  """
                  return result
          except IntegrityError as e:
              errors = form._errors.setdefault("product", ErrorList())
              errors.append(_("Integrity Error: {}".format(e)))
              return super(LineAlbaranCreate, self).form_invalid(form)