252 lines
8.7 KiB
Python
252 lines
8.7 KiB
Python
from django.db.models import Sum, Q
|
|
from django.db.models.signals import post_save, post_delete
|
|
from common.helpers import get_organization_by_user
|
|
from rest_framework.exceptions import APIException
|
|
from django.dispatch import receiver
|
|
from .models import (
|
|
QuotaDistribution,
|
|
Quota,
|
|
Product,
|
|
ProductStats,
|
|
QuotaStats
|
|
)
|
|
from apps.warehouse.models import (
|
|
InventoryQuotaSaleTransaction,
|
|
InventoryEntry
|
|
)
|
|
from django.db import models
|
|
from crum import get_current_user
|
|
|
|
|
|
def recalculate_remaining_amount(quota):
|
|
""" calculate remaining weight from distribution """
|
|
total_distributed = quota.distributions_assigned.filter(
|
|
parent_distribution__isnull=True,
|
|
).aggregate(
|
|
total=Sum('weight')
|
|
)['total'] or 0
|
|
|
|
quota.remaining_weight = quota.quota_weight - total_distributed
|
|
quota.quota_distributed = total_distributed
|
|
quota.save(update_fields=["remaining_weight", "quota_distributed"])
|
|
|
|
|
|
def remaining_distribution_weight(instance: QuotaDistribution):
|
|
""" calculate remaining & distributed weight from distribution """
|
|
|
|
total_children_weight = instance.children.aggregate(
|
|
total=Sum('weight')
|
|
)['total'] or 0
|
|
|
|
# total warehouse inventory entry
|
|
total_entry = instance.inventory_entry.aggregate(
|
|
total=Sum('weight')
|
|
)['total'] or 0
|
|
|
|
instance.remaining_weight = instance.weight - total_children_weight - total_entry
|
|
instance.distributed = total_children_weight
|
|
instance._from_signal = True
|
|
instance.save(update_fields=['remaining_weight', 'distributed'])
|
|
|
|
if instance.parent_distribution:
|
|
remaining_distribution_weight(instance.parent_distribution)
|
|
|
|
|
|
@receiver(post_save, sender=QuotaDistribution)
|
|
@receiver(post_delete, sender=QuotaDistribution)
|
|
def update_quota_remaining(sender, instance, **kwargs):
|
|
recalculate_remaining_amount(instance.quota)
|
|
|
|
# if _from_signal=True prevent from maximum recursion loop
|
|
if getattr(instance, '_from_signal', False):
|
|
return
|
|
|
|
# when delete object, prevent from update fields error
|
|
if kwargs.get('signal') == post_delete:
|
|
if instance.parent_distribution:
|
|
remaining_distribution_weight(instance.parent_distribution)
|
|
else:
|
|
remaining_distribution_weight(instance)
|
|
|
|
|
|
def update_product_stats(instance: Product, distribution: QuotaDistribution = None):
|
|
""" update all stats of product """
|
|
|
|
organization = get_organization_by_user(get_current_user())
|
|
|
|
if ProductStats.objects.filter(
|
|
organization=organization,
|
|
product=instance,
|
|
sale_unit=distribution.quota.sale_unit.unit
|
|
):
|
|
stat = instance.stats.get(
|
|
organization=organization,
|
|
product=instance,
|
|
sale_unit=distribution.quota.sale_unit.unit
|
|
)
|
|
else:
|
|
stat = ProductStats.objects.create(
|
|
product=instance,
|
|
organization=organization,
|
|
sale_unit=distribution.quota.sale_unit.unit
|
|
)
|
|
|
|
# number of quotas
|
|
|
|
quota = Quota.objects.filter(
|
|
Q(
|
|
distributions_assigned__in=QuotaDistribution.objects.filter(
|
|
Q(assigned_organization=organization) |
|
|
Q(assigner_organization=organization) &
|
|
Q(parent_distribution__isnull=True)
|
|
|
|
)
|
|
) |
|
|
Q(registerer_organization=organization),
|
|
product=instance
|
|
).distinct()
|
|
|
|
quotas_count = quota.count() # noqa
|
|
|
|
total_quotas_weight = quota.aggregate( # noqa
|
|
total=models.Sum('quota_weight')
|
|
)['total'] or 0
|
|
|
|
# total weight of product that assigned in quota
|
|
active_quotas_weight = quota.filter(is_closed=False).aggregate(
|
|
total=models.Sum('quota_weight')
|
|
)['total'] or 0
|
|
|
|
closed_quotas_weight = quota.filter(is_closed=True).aggregate( # noqa
|
|
total=models.Sum('quota_weight')
|
|
)['total'] or 0
|
|
|
|
# total remaining weight of product quotas
|
|
total_remaining_quotas_weight = quota.filter(is_closed=False).aggregate( # noqa
|
|
total=models.Sum('remaining_weight')
|
|
)['total'] or 0
|
|
|
|
received_distribution_weight = QuotaDistribution.objects.filter(
|
|
quota__product_id=instance.id,
|
|
quota__is_closed=False,
|
|
quota__sale_unit=distribution.quota.sale_unit,
|
|
assigned_organization=organization,
|
|
parent_distribution__isnull=True
|
|
)
|
|
|
|
received_distribution_number = received_distribution_weight.count()
|
|
|
|
received_distribution_weight = received_distribution_weight.aggregate(
|
|
total_weight=models.Sum('weight')
|
|
)['total_weight'] or 0
|
|
|
|
# product total distributed weight from quota
|
|
given_distribution_weight = QuotaDistribution.objects.filter(
|
|
quota__product_id=instance.id,
|
|
quota__is_closed=False,
|
|
quota__sale_unit=distribution.quota.sale_unit,
|
|
assigner_organization=organization,
|
|
parent_distribution__isnull=True
|
|
)
|
|
|
|
given_distribution_number = given_distribution_weight.count()
|
|
given_distribution_weight = given_distribution_weight.aggregate(
|
|
total_weight=models.Sum('weight')
|
|
)['total_weight'] or 0
|
|
|
|
if received_distribution_weight > 0:
|
|
distribution_weight_balance = received_distribution_weight - given_distribution_weight
|
|
else:
|
|
distribution_weight_balance = given_distribution_weight
|
|
|
|
# total sold of product from quota
|
|
total_sold = QuotaDistribution.objects.filter(
|
|
quota__product_id=instance.id,
|
|
quota__is_closed=False,
|
|
quota__sale_unit=distribution.quota.sale_unit,
|
|
assigned_organization=organization
|
|
).aggregate(total_sold=models.Sum('been_sold'))['total_sold'] or 0
|
|
|
|
# total entry from product to inventory
|
|
total_warehouse_entry = QuotaDistribution.objects.filter(
|
|
quota__product_id=instance.id,
|
|
quota__is_closed=False,
|
|
quota__sale_unit=distribution.quota.sale_unit,
|
|
assigned_organization=organization
|
|
).aggregate(total_entry=models.Sum('warehouse_entry'))['total_entry'] or 0
|
|
|
|
stat.quotas_number = quotas_count
|
|
stat.active_quotas_weight = active_quotas_weight
|
|
stat.closed_quotas_weight = closed_quotas_weight
|
|
stat.total_quota_weight = total_quotas_weight
|
|
stat.total_quota_remaining = total_remaining_quotas_weight
|
|
stat.total_remaining_distribution_weight = distribution_weight_balance
|
|
stat.received_distribution_weight = received_distribution_weight
|
|
stat.given_distribution_weight = given_distribution_weight
|
|
stat.received_distribution_number = received_distribution_number
|
|
stat.given_distribution_number = given_distribution_number
|
|
stat.total_warehouse_entry = total_warehouse_entry
|
|
stat.total_sold = total_sold
|
|
stat.save(update_fields=[
|
|
"quotas_number",
|
|
"active_quotas_weight",
|
|
"closed_quotas_weight",
|
|
"total_quota_weight",
|
|
"total_quota_remaining",
|
|
"total_remaining_distribution_weight",
|
|
"received_distribution_weight",
|
|
"given_distribution_weight",
|
|
"received_distribution_number",
|
|
"total_warehouse_entry",
|
|
"total_sold",
|
|
])
|
|
|
|
|
|
def update_quota_stats(instance: Quota):
|
|
""" update all stats of quota """
|
|
|
|
if hasattr(instance, 'stats'):
|
|
stat = instance.stats
|
|
else:
|
|
stat = QuotaStats.objects.create(quota=instance)
|
|
|
|
total_distributed = instance.quota_distributed
|
|
total_remaining = instance.remaining_weight
|
|
|
|
# total entry to inventory from quota
|
|
total_inventory = InventoryEntry.objects.filter(
|
|
distribution__quota=instance
|
|
).aggregate(
|
|
total_inventory=models.Sum('weight')
|
|
)['total_inventory'] or 0
|
|
|
|
# total sale of distributions from quota
|
|
total_sale = instance.distributions_assigned.filter(
|
|
quota__is_closed=False
|
|
).aggregate(total_sale=models.Sum('been_sold'))['total_sale'] or 0
|
|
|
|
stat.total_distributed = total_distributed
|
|
stat.remaining = total_remaining
|
|
stat.total_inventory = total_inventory
|
|
stat.total_sale = total_sale
|
|
stat.save(update_fields=[
|
|
"total_distributed",
|
|
"remaining",
|
|
"total_inventory",
|
|
"total_sale",
|
|
])
|
|
|
|
|
|
@receiver([post_save, post_delete], sender=QuotaDistribution)
|
|
@receiver([post_save, post_delete], sender=InventoryQuotaSaleTransaction)
|
|
def update_stats_on_change(sender, instance, **kwargs):
|
|
if sender == QuotaDistribution:
|
|
update_product_stats(instance.quota.product, instance)
|
|
update_quota_stats(instance.quota)
|
|
# elif sender == InventoryQuotaSaleTransaction:
|
|
# if instance.quota_distribution:
|
|
# update_product_stats(instance.quota_distribution.quota.product, instance.quota_distribution)
|
|
# update_quota_stats(instance.quota_distribution.quota)
|
|
# else:
|
|
# print("quota distribution is null - product app signal")
|