def common_to_pre_open_and_open(permanence):
if permanence.contract is not None:
permanence.contract.get_or_create_offer_item(permanence, reset_add_2_stock=True)
else:
# Create offer items which can be purchased depending on selection in the admin
producers_in_this_permanence = Producer.objects.filter(
permanence=permanence,
is_active=True
).order_by('?').only("id")
product_queryset = Product.objects.filter(
producer__in=producers_in_this_permanence,
is_box=False,
is_into_offer=True
).order_by('?')
for product in product_queryset:
product.get_or_create_offer_item(permanence, reset_add_2_stock=True)
boxes_in_this_permanence = Box.objects.filter(
permanence=permanence,
is_active=True
).order_by('?').only("id")
for box in boxes_in_this_permanence:
box.get_or_create_offer_item(permanence, reset_add_2_stock=True)
# Calculate the sort order of the order display screen
reorder_offer_items(permanence.id)
# Calculate the Purchase 'sum' for each customer
permanence.recalculate_order_amount()
def common_to_pre_open_and_open(permanence):
if permanence.contract is not None:
permanence.contract.get_or_create_offer_item(permanence, reset_add_2_stock=True)
else:
# Create offer items which can be purchased depending on selection in the admin
producers_in_this_permanence = Producer.objects.filter(
permanence=permanence,
is_active=True
).order_by('?').only("id")
product_queryset = Product.objects.filter(
producer__in=producers_in_this_permanence,
is_box=False,
is_into_offer=True
).order_by('?')
for product in product_queryset:
product.get_or_create_offer_item(permanence, reset_add_2_stock=True)
boxes_in_this_permanence = Box.objects.filter(
permanence=permanence,
is_active=True
).order_by('?').only("id")
for box in boxes_in_this_permanence:
box.get_or_create_offer_item(permanence, reset_add_2_stock=True)
# Calculate the sort order of the order display screen
reorder_offer_items(permanence.id)
# Calculate the Purchase 'sum' for each customer
permanence.recalculate_order_amount()
def open_order(permanence_id, send_mail=True):
# Be careful : use permanece_id, deliveries_id, ... and not objects
# for the "thread" processing
permanence = Permanence.objects.filter(
id=permanence_id).order_by("?").first()
permanence.set_status(old_status=PERMANENCE_PLANNED,
new_status=PERMANENCE_WAIT_FOR_OPEN)
# Create offer items which can be purchased depending on selection in the admin
producers_in_this_permanence = (Producer.objects.filter(
permanence=permanence, is_active=True).order_by("?").only("id"))
product_queryset = Product.objects.filter(
producer__in=producers_in_this_permanence,
is_box=False,
is_into_offer=True).order_by("?")
for product in product_queryset:
product.get_or_create_offer_item(permanence)
boxes_in_this_permanence = (Box.objects.filter(
permanence=permanence, is_active=True).order_by("?").only("id"))
for box in boxes_in_this_permanence:
box.get_or_create_offer_item(permanence)
# Calculate the sort order of the order display screen
reorder_offer_items(permanence.id)
# Calculate the Purchase 'sum' for each customer
permanence.recalculate_order_amount()
# 3 - Keep only producer with offer items which can be ordered
permanence.producers.clear()
for offer_item in (OfferItemWoReceiver.objects.filter(
permanence_id=permanence.id,
may_order=True).order_by("producer_id").distinct("producer_id")):
permanence.producers.add(offer_item.producer_id)
for producer in permanence.producers.all():
producer_invoice = ProducerInvoice.objects.filter(
permanence_id=permanence.id, producer_id=producer.id).order_by("?")
if not producer_invoice.exists():
ProducerInvoice.objects.create(
permanence_id=permanence.id,
producer_id=producer.id,
status=PERMANENCE_WAIT_FOR_OPEN,
)
if send_mail:
email_offer.send_open_order(permanence_id)
permanence.set_status(old_status=PERMANENCE_WAIT_FOR_OPEN,
new_status=PERMANENCE_OPENED)
def import_invoice_sheet(worksheet, invoice_reference=EMPTY_STRING,
customer_2_id_dict=None,
producer=None
):
error = False
error_msg = None
header = get_header(worksheet)
if header:
now = timezone.now().date()
lut_reverse_vat = dict(LUT_ALL_VAT_REVERSE)
import_counter = 0
row_num = 1
sid = transaction.savepoint()
try:
permanence = Permanence.objects.create(
permanence_date=now,
short_name=invoice_reference,
status=PERMANENCE_SEND,
highest_status=PERMANENCE_SEND
)
permanence.producers.add(producer)
row = get_row(worksheet, header, row_num)
while row and not error:
customer_name = row[_("Customer")]
if customer_name:
if customer_name in customer_2_id_dict:
customer_id = customer_2_id_dict[customer_name]
else:
error = True
error_msg = _("Row %(row_num)d : No valid customer") % {'row_num': row_num + 1}
break
product_reference = row[_("Reference")] or EMPTY_STRING
unit = row[_("Unit")]
order_unit = get_reverse_invoice_unit(unit)
vat = row[_("VAT level")]
vat_level = lut_reverse_vat[vat]
product = Product.objects.filter(producer_id=producer.id, reference=product_reference).order_by(
'?').first()
if product is None:
product = Product.objects.create(
producer=producer,
reference=product_reference,
)
long_name = row[_("Product")]
# The producer unit price is the imported customer unit price
# If the group get a reduction, this one must be mentioned into the producer admin screen
# into the "price_list_multiplier" field
product.producer_unit_price = row[_("Customer unit price")]
product.unit_deposit = row[_("Deposit")]
product.order_unit = order_unit
product.vat_level = vat_level
product.wrapped = row[_("Wrapped")]
qty_and_price_display = product.get_qty_and_price_display(customer_price=False)
if long_name.endswith(qty_and_price_display):
long_name = long_name[:-len(qty_and_price_display)]
product.long_name = long_name[:100]
product.save()
offer_item = product.get_or_create_offer_item(permanence)
create_or_update_one_purchase(
customer_id=customer_id,
offer_item=offer_item,
status=PERMANENCE_SEND,
q_order=Decimal(row[_("Quantity")]),
batch_job=True, is_box_content=False,
comment=row[_("Comment")] or EMPTY_STRING
)
import_counter += 1
row_num += 1
row = get_row(worksheet, header, row_num)
reorder_offer_items(permanence.id)
reorder_purchases(permanence.id)
except KeyError as e:
# Missing field
error = True
error_msg = _("Row %(row_num)d : A required column is missing %(error_msg)s.") % {
'row_num': row_num + 1, 'error_msg': str(e)}
except Exception as e:
error = True
error_msg = _("Row %(row_num)d : %(error_msg)s.") % {'row_num': row_num + 1, 'error_msg': str(e)}
if not error and import_counter == 0:
error = True
error_msg = "{}".format(_("Nothing to import."))
if error:
transaction.savepoint_rollback(sid)
else:
transaction.savepoint_commit(sid)
return error, error_msg
def import_invoice_sheet(worksheet, invoice_reference=EMPTY_STRING,
customer_2_id_dict=None,
producer=None
):
error = False
error_msg = None
header = get_header(worksheet)
if header:
now = timezone.now().date()
lut_reverse_vat = dict(LUT_ALL_VAT_REVERSE)
import_counter = 0
row_num = 1
sid = transaction.savepoint()
try:
permanence = Permanence.objects.create(
permanence_date=now,
short_name=invoice_reference,
status=PERMANENCE_SEND,
highest_status=PERMANENCE_SEND
)
permanence.producers.add(producer)
row = get_row(worksheet, header, row_num)
while row and not error:
customer_name = row[_("Customer")]
if customer_name:
if customer_name in customer_2_id_dict:
customer_id = customer_2_id_dict[customer_name]
else:
error = True
error_msg = _("Row %(row_num)d : No valid customer") % {'row_num': row_num + 1}
break
product_reference = row[_("Reference")] or EMPTY_STRING
unit = row[_("Unit")]
order_unit = get_reverse_invoice_unit(unit)
vat = row[_("VAT level")]
vat_level = lut_reverse_vat[vat]
product = Product.objects.filter(producer_id=producer.id, reference=product_reference).order_by(
'?').first()
if product is None:
product = Product.objects.create(
producer=producer,
reference=product_reference,
)
long_name = row[_("Product")]
# The producer unit price is the imported customer unit price
# If the group get a reduction, this one must be mentioned into the producer admin screen
# into the "price_list_multiplier" field
product.producer_unit_price = row[_("Customer unit price")]
product.unit_deposit = row[_("Deposit")]
product.order_unit = order_unit
product.vat_level = vat_level
product.wrapped = row[_("Wrapped")]
qty_and_price_display = product.get_qty_and_price_display(customer_price=False)
if long_name.endswith(qty_and_price_display):
long_name = long_name[:-len(qty_and_price_display)]
product.long_name = long_name[:100]
product.save()
offer_item = product.get_or_create_offer_item(permanence, reset_add_2_stock=True)
create_or_update_one_purchase(
customer_id=customer_id,
offer_item=offer_item,
status=PERMANENCE_SEND,
q_order=Decimal(row[_("Quantity")]),
batch_job=True, is_box_content=False,
comment=row[_("Comment")] or EMPTY_STRING
)
import_counter += 1
row_num += 1
row = get_row(worksheet, header, row_num)
reorder_offer_items(permanence.id)
reorder_purchases(permanence.id)
except KeyError as e:
# Missing field
error = True
error_msg = _("Row %(row_num)d : A required column is missing %(error_msg)s.") % {
'row_num': row_num + 1, 'error_msg': str(e)}
except Exception as e:
error = True
error_msg = _("Row %(row_num)d : %(error_msg)s.") % {'row_num': row_num + 1, 'error_msg': str(e)}
if not error and import_counter == 0:
error = True
error_msg = "{}".format(_("Nothing to import."))
if error:
transaction.savepoint_rollback(sid)
else:
transaction.savepoint_commit(sid)
return error, error_msg
def common_to_pre_open_and_open(permanence_id):
getcontext().rounding = ROUND_HALF_UP
# 1- Deactivate all offer item of this permanence
OfferItem.objects.filter(
permanence_id=permanence_id
).order_by('?').update(
is_active=False, may_order=False, is_box=False, is_box_content=False
)
# 2 - Delete unused purchases
Purchase.objects.filter(permanence_id=permanence_id, quantity_ordered=0,
quantity_invoiced=0).order_by('?').delete()
# 3 - Activate offer items which can be purchased depending on selection in the admin
producers_in_this_permanence = Producer.objects.filter(
permanence=permanence_id, is_active=True).order_by('?').only("id")
product_queryset = Product.objects.filter(
producer__in=producers_in_this_permanence, is_into_offer=True
).order_by('?').only("id", "producer_id")
OfferItem.objects.filter(product__in=product_queryset, permanence_id=permanence_id) \
.order_by('?').update(is_active=True, may_order=True)
for product in product_queryset:
if not OfferItem.objects.filter(product_id=product.id, permanence_id=permanence_id) \
.order_by('?').exists():
OfferItem.objects.create(
permanence_id=permanence_id,
product_id=product.id,
producer_id=product.producer_id,
is_box=False,
is_box_content=False,
is_active=True,
may_order=True
)
# 4 - Add composition products
product_queryset = Product.objects.filter(
is_box=True, is_into_offer=True
).order_by('?').only("id", "producer_id")
OfferItem.objects.filter(product__in=product_queryset, permanence_id=permanence_id) \
.order_by('?').update(is_active=True, may_order=True)
for product in product_queryset:
offer_item = OfferItem.objects.filter(product_id=product.id, permanence_id=permanence_id).order_by('?').first()
if offer_item is None:
OfferItem.objects.create(
permanence_id=permanence_id,
product_id=product.id,
producer_id=product.producer_id,
is_box=True,
is_box_content=False,
is_active=True,
may_order=True
)
else:
offer_item.is_box = True
offer_item.is_active = True
offer_item.save(update_fields=["is_active", "is_box"])
for box_content in BoxContent.objects.filter(box=product.id).select_related("product__producer").order_by(
'?'):
box_offer_item = OfferItem.objects.filter(product_id=box_content.product_id,
permanence_id=permanence_id).order_by('?').first()
if box_offer_item is None:
OfferItem.objects.create(
permanence_id=permanence_id,
product_id=box_content.product_id,
producer_id=box_content.product.producer_id,
is_box=False,
is_box_content=True,
is_active=True,
may_order=False
)
else:
box_offer_item.is_box_content = True
box_offer_item.is_active = True
box_offer_item.save(update_fields=["is_active", "is_box_content"])
# 6 - Add subscriptions even if the producer is not selected
product_queryset = Product.objects.filter(
order_unit=PRODUCT_ORDER_UNIT_SUBSCRIPTION, is_into_offer=True,
producer__represent_this_buyinggroup=True
).order_by('?').only("id", "producer_id")
for product in product_queryset:
if not OfferItem.objects.filter(product_id=product.id, permanence_id=permanence_id) \
.order_by('?').exists():
OfferItem.objects.create(
permanence_id=permanence_id,
product_id=product.id,
producer_id=product.producer_id,
is_box=False,
is_box_content=False,
)
# 7 - Activate purchased products even if not in selected in the admin
OfferItem.objects.filter(
purchase__permanence_id=permanence_id, is_active=False,
order_unit__lt=PRODUCT_ORDER_UNIT_DEPOSIT
).order_by('?').update(is_active=True)
# 8 - Create cache
permanence = Permanence.objects.filter(id=permanence_id).order_by('?').first()
offer_item_qs = OfferItem.objects.filter(permanence_id=permanence_id).order_by('?')
clean_offer_item(permanence, offer_item_qs, reset_add_2_stock=True)
# 9 - calculate the sort order of the order display screen
reorder_offer_items(permanence_id)
# 10 - Deactivate technical offer items
OfferItem.objects.filter(order_unit__gte=PRODUCT_ORDER_UNIT_DEPOSIT, permanence_id=permanence_id) \
.order_by('?').update(is_active=False, may_order=False)
# 11 - Calculate the Purchase 'sum' for each customer
recalculate_order_amount(
permanence_id=permanence_id,
all_producers=True,
send_to_producer=False
)
return permanence
def handle(self, *args, **options):
translation.activate(settings.LANGUAGE_CODE)
# Les producer price (et donc la tva) des produits, offer item dont is_box = true est à zéro au lieu d'être = au prix, eva consommateur
Product.objects.filter(
is_box=True
).update(
producer_unit_price=F('customer_unit_price'),
producer_vat=F('customer_vat')
)
Product.objects.filter(
vat_level='200'
).update(
vat_level='100'
)
Product.objects.filter(
vat_level='300'
).update(
vat_level='100'
)
OfferItem.objects.filter(
is_box=True
).update(
producer_unit_price=F('customer_unit_price'),
producer_vat=F('customer_vat')
)
OfferItem.objects.filter(
vat_level='200'
).update(
vat_level='100'
)
OfferItem.objects.filter(
vat_level='300'
).update(
vat_level='100'
)
Purchase.objects.filter(
offer_item__is_box=True
).update(
purchase_price=F('selling_price'),
producer_vat=F('customer_vat')
)
# Mettre purchase price et selling price des purchase dont is_box_content = True à zéro
Purchase.objects.filter(
is_box_content=True
).update(
purchase_price=DECIMAL_ZERO,
selling_price=DECIMAL_ZERO,
producer_vat=DECIMAL_ZERO,
customer_vat=DECIMAL_ZERO,
# compensation=DECIMAL_ZERO,
deposit=DECIMAL_ZERO,
)
Purchase.objects.filter(
vat_level='200'
).update(
vat_level='100'
)
Purchase.objects.filter(
vat_level='300'
).update(
vat_level='100'
)
qs = CustomerInvoice.objects.filter(
permanence__with_delivery_point=True, status__lte=PERMANENCE_CLOSED, delivery__isnull=True
).order_by('?')
Purchase.objects.filter(
customer_invoice__in=qs
).order_by('?').delete()
qs.delete()
OfferItem.objects.filter(
producer_price_are_wo_vat=True
).update(
producer_price_are_wo_vat=False,
producer_unit_price=F('producer_unit_price') + F('producer_vat')
)
OfferItem.objects.filter(
order_unit__gte=PRODUCT_ORDER_UNIT_DEPOSIT
).update(
manage_replenishment=False
)
for permanence in Permanence.objects.filter(
with_delivery_point=False
).order_by('?'):
CustomerInvoice.objects.filter(
permanence_id=permanence.id,
).order_by('?').update(
customer_who_pays_id=F('customer_id')
)
Purchase.objects.filter(
permanence_id=permanence.id,
).order_by('?').update(
customer_who_pays_id=F('customer_id')
)
for producer_invoice in ProducerInvoice.objects.filter(
invoice_reference__isnull=True
):
bank_account = BankAccount.objects.filter(
producer_invoice_id = producer_invoice.id,
operation_status=BANK_CALCULATED_INVOICE
).order_by('?').first()
if bank_account is not None:
producer_invoice.invoice_reference = bank_account.operation_comment
producer_invoice.to_be_invoiced_balance = bank_account.bank_amount_out - bank_account.bank_amount_in
producer_invoice.save(update_fields=['invoice_reference', 'to_be_invoiced_balance'])
for permanence in Permanence.objects.filter(
status__lt=PERMANENCE_CLOSED
).order_by('permanence_date'):
print ("%s %s" % (permanence.permanence_date, permanence.get_status_display()))
recalculate_order_amount(
permanence_id=permanence.id,
all_producers=True,
send_to_producer=False,
re_init=True)
reorder_offer_items(permanence.id)
for customer_invoice in CustomerInvoice.objects.filter(permanence_id=permanence.id):
delivery_point = LUT_DeliveryPoint.objects.filter(
customer_responsible=customer_invoice.customer_id
).order_by('?').first()
if delivery_point is not None:
delivery = DeliveryBoard.objects.filter(
delivery_point_id=delivery_point.id,
permanence_id=permanence.id,
).order_by('?').first()
customer_invoice.delivery = delivery
customer_invoice.set_delivery(customer_invoice.delivery)
if customer_invoice.is_order_confirm_send:
customer_invoice.confirm_order()
customer_invoice.save()
# if customer_invoice.is_order_confirm_send:
# confirm_customer_invoice(permanence.id, customer_invoice.customer_id)
for permanence in Permanence.objects.filter(
status__gte=PERMANENCE_CLOSED
).order_by('permanence_date'):
print ("%s %s" % (permanence.permanence_date, permanence.get_status_display()))
status = permanence.status
permanence.set_status(status)
if status == PERMANENCE_SEND:
recalculate_order_amount(
permanence_id=permanence.id,
all_producers=True,
send_to_producer=False,
re_init=True
)
reorder_offer_items(permanence.id)
for customer_invoice in CustomerInvoice.objects.filter(permanence_id=permanence.id):
delivery_point = LUT_DeliveryPoint.objects.filter(
customer_responsible=customer_invoice.customer_id
).order_by('?').first()
if delivery_point is not None:
print("---- %s" % delivery_point)
delivery = DeliveryBoard.objects.filter(
delivery_point_id=delivery_point.id,
permanence_id=permanence.id,
).order_by('?').first()
customer_invoice.delivery = delivery
customer_invoice.set_delivery(customer_invoice.delivery)
if customer_invoice.is_order_confirm_send:
customer_invoice.confirm_order()
customer_invoice.save()
def common_to_pre_open_and_open(permanence_id):
getcontext().rounding = ROUND_HALF_UP
# Create offer items which can be purchased depending on selection in the admin
producers_in_this_permanence = Producer.objects.filter(
permanence=permanence_id, is_active=True).order_by('?').only("id")
product_queryset = Product.objects.filter(
producer__in=producers_in_this_permanence,
is_box=False,
is_into_offer=True).order_by('?').only("id", "producer_id")
for product in product_queryset:
if not OfferItem.objects.filter(
product_id=product.id,
permanence_id=permanence_id).order_by('?').exists():
OfferItem.objects.create(
permanence_id=permanence_id,
product_id=product.id,
producer_id=product.producer_id,
)
# Deactivate all offer item of this permanence
OfferItem.objects.filter(permanence_id=permanence_id).order_by('?').update(
is_active=False, may_order=False, is_box=False, is_box_content=False)
# Activate all offer item of this permanence
OfferItem.objects.filter(
product__in=product_queryset,
permanence_id=permanence_id).exclude(order_unit__in=[
PRODUCT_ORDER_UNIT_DEPOSIT, PRODUCT_ORDER_UNIT_TRANSPORTATION
]).order_by('?').update(is_active=True, may_order=True)
OfferItem.objects.filter(product__in=product_queryset,
permanence_id=permanence_id,
order_unit__in=[
PRODUCT_ORDER_UNIT_DEPOSIT,
PRODUCT_ORDER_UNIT_TRANSPORTATION
]).order_by('?').update(is_active=True,
may_order=False)
# Create box offer items which can be purchased depending on selection in the admin
product_queryset = Product.objects.filter(
is_box=True,
is_into_offer=True).order_by('?').only("id", "producer_id")
for product in product_queryset:
offer_item = OfferItem.objects.filter(
product_id=product.id,
permanence_id=permanence_id).order_by('?').first()
if offer_item is None:
OfferItem.objects.create(permanence_id=permanence_id,
product_id=product.id,
producer_id=product.producer_id,
is_box=True,
is_box_content=False,
is_active=True,
may_order=True)
else:
offer_item.is_box = True
offer_item.is_box_content = False
offer_item.is_active = True
offer_item.may_order = True
offer_item.save(update_fields=[
"is_active", "may_order", "is_box", "is_box_content"
])
for box_content in BoxContent.objects.filter(
box=product.id).select_related("product__producer").order_by(
'?'):
box_offer_item = OfferItem.objects.filter(
product_id=box_content.product_id,
permanence_id=permanence_id).order_by('?').first()
if box_offer_item is None:
OfferItem.objects.create(
permanence_id=permanence_id,
product_id=box_content.product_id,
producer_id=box_content.product.producer_id,
is_box=False,
is_box_content=True,
is_active=True,
may_order=False)
else:
box_offer_item.is_box = False
box_offer_item.is_box_content = True
box_offer_item.is_active = True
box_offer_item.may_order = False
box_offer_item.save(update_fields=[
"is_active", "may_order", "is_box", "is_box_content"
])
# Activate purchased products even if not in selected in the admin
OfferItem.objects.filter(
purchase__permanence_id=permanence_id,
is_active=False,
order_unit__lt=PRODUCT_ORDER_UNIT_DEPOSIT).order_by('?').update(
is_active=True)
# Create cache
permanence = Permanence.objects.filter(
id=permanence_id).order_by('?').first()
offer_item_qs = OfferItem.objects.filter(
permanence_id=permanence_id).order_by('?')
clean_offer_item(permanence, offer_item_qs, reset_add_2_stock=True)
# Calculate the sort order of the order display screen
reorder_offer_items(permanence_id)
# Calculate the Purchase 'sum' for each customer
permanence.recalculate_order_amount()
return permanence
