fix --> soft delete distribution batch

Dockerfile

@@ -1,5 +1,5 @@
 # pull official base image
-FROM ghcr.io/seniorkian/python310-rasaddam:1.0.1
+FROM registry.hamdocker.ir/seniorkian/python310-rasaddam:1.0.0
 
 # Create the app directory
 RUN #mkdir /app
@@ -12,10 +12,13 @@ ENV PYTHONDONTWRITEBYTECODE 1
 ENV PYTHONUNBUFFERED 1
 
 # install dependencies
+ENV TZ="Asia/Tehran"
+RUN pip config --user set global.index https://mirror-pypi.runflare.com/simple
+RUN pip config --user set global.index-url https://mirror-pypi.runflare.com/simple
+RUN pip config --user set global.trusted-host mirror-pypi.runflare.com
 RUN pip install --upgrade pip
 COPY ./requirements.txt .
-RUN --mount=type=cache,target=/root/.cache/pip \
+RUN pip install --no-cache-dir -r requirements.txt
-    pip install --no-cache-dir -r requirements.txt
 
 # copy project
 COPY . /app/

apps/core/visibility_registry.py

@@ -11,6 +11,7 @@ VISIBILITY_MAP = {
     'rancher': 'organization',
     'rancherorganizationlink': 'organization',  # noqa
     'tagbatch': 'organization',  # noqa
+    'tagdistribution': ['assigner_org', 'assigned_org']
 
     # 'deviceactivationcode': 'organization',
     # 'deviceversion': 'organization',

apps/livestock/migrations/0017_livestockspecies_value.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.0 on 2026-01-24 11:28
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('livestock', '0016_temporarylivestock'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='livestockspecies',
+            name='value',
+            field=models.IntegerField(default=0),
+        ),
+    ]

apps/livestock/migrations/0018_livestockspecies_en_name_alter_livestockspecies_name.py

@@ -0,0 +1,23 @@
+# Generated by Django 5.0 on 2026-01-24 11:32
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('livestock', '0017_livestockspecies_value'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='livestockspecies',
+            name='en_name',
+            field=models.CharField(max_length=50, null=True),
+        ),
+        migrations.AlterField(
+            model_name='livestockspecies',
+            name='name',
+            field=models.CharField(max_length=50, null=True),
+        ),
+    ]

apps/livestock/models.py

@@ -7,7 +7,9 @@ from apps.tag import models as tag_models
 
 class LiveStockSpecies(BaseModel):  # noqa
     """ species of live stocks like Kurdi, Luri, etc """  # noqa
-    name = models.CharField(max_length=50)
+    name = models.CharField(max_length=50, null=True)
+    en_name = models.CharField(max_length=50, null=True)
+    value = models.IntegerField(default=0)
 
     def __str__(self):
         return f'{self.name}'

apps/livestock/web/api/v1/serializers.py

@@ -1,6 +1,7 @@
 from rest_framework import serializers
-from apps.livestock import models as livestock_models
+
 from apps.herd.web.api.v1.serializers import HerdSerializer
+from apps.livestock import models as livestock_models
 from apps.tag.web.api.v1.serializers import TagSerializer
 
 
@@ -28,7 +29,9 @@ class LiveStockSpeciesSerializer(serializers.ModelSerializer):
         model = livestock_models.LiveStockSpecies
         fields = [
             'id',
-            'name'
+            'name',
+            'en_name',
+            'value',
         ]
 
 

apps/pos_device/exceptions.py

@@ -2,6 +2,23 @@ from rest_framework import status
 from rest_framework.exceptions import APIException
 
 
+class DeviceException(APIException):
+    status_code = status.HTTP_400_BAD_REQUEST
+    default_detail = "خطا در اطلاعات پلاک"  # noqa
+    default_code = 'error'
+
+    def __init__(self, message=None, status_code=None, code=None):
+        if status_code is not None:
+            self.status_code = status_code
+
+        detail = {
+            "message": message,
+            "status_code": status_code
+        }
+
+        super().__init__(detail)
+
+
 class DeviceAlreadyAssigned(APIException):
     status_code = status.HTTP_403_FORBIDDEN
     default_detail = "این دستگاه قبلا به این کلاینت تخصیص داده شده است"  # noqa

apps/pos_device/migrations/0081_alter_device_serial.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.0 on 2026-01-26 06:47
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('pos_device', '0080_bankaccountdevicelink'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='device',
+            name='serial',
+            field=models.TextField(null=True),
+        ),
+    ]

apps/pos_device/models.py

@@ -36,7 +36,7 @@ class Device(BaseModel):
     acceptor = models.CharField(max_length=50, null=True)
     terminal = models.CharField(max_length=50, null=True)
     mac = models.CharField(max_length=50, null=True)
-    serial = models.TextField(null=True, unique=True)
+    serial = models.TextField(null=True)
     password = models.CharField(max_length=25, null=True)
     multi_device = models.BooleanField(default=False)
     server_in = models.BooleanField(default=False)

apps/pos_device/web/api/v1/serilaizers/device.py

@@ -3,6 +3,7 @@ from rest_framework.serializers import ModelSerializer
 from apps.authentication.api.v1.serializers.serializer import BankAccountSerializer
 from apps.pos_device import exceptions as pos_exceptions
 from apps.pos_device import models as pos_models
+from apps.pos_device.exceptions import DeviceException
 from apps.pos_device.web.api.v1.serilaizers import client as client_serializer
 from apps.product.web.api.v1.serializers.quota_distribution_serializers import QuotaDistributionSerializer
 
@@ -18,6 +19,19 @@ class DeviceSerializer(ModelSerializer):
         model = pos_models.Device
         fields = '__all__'
 
+    def validate(self, attrs):
+        serial = attrs['serial']
+
+        if not self.instance:
+            if self.Meta.model.objects.filter(serial=serial).exists():
+                raise DeviceException("دستگاه یا این شماره سریال از قبل ثبت شده است.", status_code=403)  # noqa
+
+        if self.instance:
+            if serial != self.instance.serial and self.Meta.model.objects.filter(serial=serial).exists():
+                raise DeviceException("دستگاهی با این شماره سریال وجود دارد.", status_code=403)  # noqa
+
+        return attrs
+
     def to_representation(self, instance):
         """ custom output of serializer """
         representation = super().to_representation(instance)

apps/tag/apps.py

@@ -4,3 +4,6 @@ from django.apps import AppConfig
 class TagConfig(AppConfig):
     default_auto_field = 'django.db.models.BigAutoField'
     name = 'apps.tag'
+
+    def ready(self):
+        import apps.tag.signals.tag_distribution_signals  # noqa

apps/tag/migrations/0030_tagdistribution.py

@@ -0,0 +1,38 @@
+# Generated by Django 5.0 on 2026-01-18 10:44
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('authentication', '0060_organization_ownership_code'),
+        ('tag', '0029_alter_tag_tag_code_tagbatch'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='TagDistribution',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('create_date', models.DateTimeField(auto_now_add=True)),
+                ('modify_date', models.DateTimeField(auto_now=True)),
+                ('creator_info', models.CharField(max_length=100, null=True)),
+                ('modifier_info', models.CharField(max_length=100, null=True)),
+                ('trash', models.BooleanField(default=False)),
+                ('species_code', models.IntegerField(default=0)),
+                ('distributed_number', models.IntegerField(default=0)),
+                ('batch', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='tag_distributions', to='tag.tagbatch')),
+                ('created_by', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='%(class)s_createddby', to=settings.AUTH_USER_MODEL)),
+                ('modified_by', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='%(class)s_modifiedby', to=settings.AUTH_USER_MODEL)),
+                ('organization', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='tag_distributions', to='authentication.organization')),
+                ('tag', models.ManyToManyField(related_name='distributions', to='tag.tag')),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+    ]

apps/tag/migrations/0031_tagbatch_batch_identity_alter_tagbatch_organization.py

@@ -0,0 +1,25 @@
+# Generated by Django 5.0 on 2026-01-19 06:19
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('authentication', '0060_organization_ownership_code'),
+        ('tag', '0030_tagdistribution'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='tagbatch',
+            name='batch_identity',
+            field=models.PositiveBigIntegerField(default=0),
+        ),
+        migrations.AlterField(
+            model_name='tagbatch',
+            name='organization',
+            field=models.ForeignKey(help_text='creator org of tag batch', null=True, on_delete=django.db.models.deletion.CASCADE, related_name='tag_batches', to='authentication.organization'),
+        ),
+    ]

apps/tag/migrations/0032_remove_tagbatch_batch_identity.py

@@ -0,0 +1,17 @@
+# Generated by Django 5.0 on 2026-01-19 06:25
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tag', '0031_tagbatch_batch_identity_alter_tagbatch_organization'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='tagbatch',
+            name='batch_identity',
+        ),
+    ]

apps/tag/migrations/0033_tagbatch_batch_identity.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.0 on 2026-01-19 06:34
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tag', '0032_remove_tagbatch_batch_identity'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='tagbatch',
+            name='batch_identity',
+            field=models.CharField(max_length=50, null=True, unique=True),
+        ),
+    ]

apps/tag/migrations/0034_remove_tagdistribution_organization.py

@@ -0,0 +1,17 @@
+# Generated by Django 5.0 on 2026-01-19 06:41
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tag', '0033_tagbatch_batch_identity'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='tagdistribution',
+            name='organization',
+        ),
+    ]

apps/tag/migrations/0035_tagdistribution_assigned_org.py

@@ -0,0 +1,20 @@
+# Generated by Django 5.0 on 2026-01-19 06:42
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('authentication', '0060_organization_ownership_code'),
+        ('tag', '0034_remove_tagdistribution_organization'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='tagdistribution',
+            name='assigned_org',
+            field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='tag_distributions', to='authentication.organization'),
+        ),
+    ]

apps/tag/migrations/0036_tagdistribution_assigner_org_and_more.py

@@ -0,0 +1,25 @@
+# Generated by Django 5.0 on 2026-01-19 06:46
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('authentication', '0060_organization_ownership_code'),
+        ('tag', '0035_tagdistribution_assigned_org'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='tagdistribution',
+            name='assigner_org',
+            field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='assigner_tag_dist', to='authentication.organization'),
+        ),
+        migrations.AlterField(
+            model_name='tagdistribution',
+            name='assigned_org',
+            field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='assigned_tag_dist', to='authentication.organization'),
+        ),
+    ]

apps/tag/migrations/0037_tagdistribution_dist_identity_and_more.py

@@ -0,0 +1,54 @@
+# Generated by Django 5.0 on 2026-01-20 07:31
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('authentication', '0060_organization_ownership_code'),
+        ('tag', '0036_tagdistribution_assigner_org_and_more'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='tagdistribution',
+            name='dist_identity',
+            field=models.CharField(default='0', max_length=20, null=True, unique=True),
+        ),
+        migrations.AddField(
+            model_name='tagdistribution',
+            name='is_closed',
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AlterField(
+            model_name='tagbatch',
+            name='tag',
+            field=models.ManyToManyField(related_name='batches', to='tag.tag'),
+        ),
+        migrations.CreateModel(
+            name='TagDistributionBatch',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('create_date', models.DateTimeField(auto_now_add=True)),
+                ('modify_date', models.DateTimeField(auto_now=True)),
+                ('creator_info', models.CharField(max_length=100, null=True)),
+                ('modifier_info', models.CharField(max_length=100, null=True)),
+                ('trash', models.BooleanField(default=False)),
+                ('dist_batch_identity', models.CharField(default='0', max_length=20, null=True, unique=True)),
+                ('total_tag_count', models.IntegerField(default=0)),
+                ('is_closed', models.BooleanField(default=False)),
+                ('assigned_org', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='to_tag_distribution_batch', to='authentication.organization')),
+                ('assigner_org', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='from_tag_distribution_batch', to='authentication.organization')),
+                ('created_by', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='%(class)s_createddby', to=settings.AUTH_USER_MODEL)),
+                ('distributions', models.ManyToManyField(related_name='tag_distribution_batch', to='tag.tagdistribution')),
+                ('modified_by', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='%(class)s_modifiedby', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+    ]

apps/tag/migrations/0038_tagdistributionbatch_distribution_type_and_more.py

@@ -0,0 +1,28 @@
+# Generated by Django 5.0 on 2026-01-24 05:58
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ('tag', '0037_tagdistribution_dist_identity_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='tagdistributionbatch',
+            name='distribution_type',
+            field=models.CharField(choices=[('random', 'RANDOM'), ('batch', 'BATCH')], default='batch', max_length=20,
+                                   null=True),
+        ),
+        migrations.AddField(
+            model_name='tagdistributionbatch',
+            name='remaining_tag_count',
+            field=models.PositiveBigIntegerField(default=0),
+        ),
+        migrations.AddField(
+            model_name='tagdistributionbatch',
+            name='total_distributed_tag_count',
+            field=models.PositiveBigIntegerField(default=0),
+        ),
+    ]

apps/tag/migrations/0039_tagbatch_total_distributed_tags.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.0 on 2026-01-24 06:38
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tag', '0038_tagdistributionbatch_distribution_type_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='tagbatch',
+            name='total_distributed_tags',
+            field=models.PositiveBigIntegerField(default=0),
+        ),
+    ]

apps/tag/migrations/0040_tagdistributionbatch_parent.py

@@ -0,0 +1,19 @@
+# Generated by Django 5.0 on 2026-01-24 09:13
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tag', '0039_tagbatch_total_distributed_tags'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='tagdistributionbatch',
+            name='parent',
+            field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='children', to='tag.tagdistributionbatch'),
+        ),
+    ]

apps/tag/migrations/0041_tagbatch_total_remaining_tags.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.0 on 2026-01-24 10:31
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tag', '0040_tagdistributionbatch_parent'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='tagbatch',
+            name='total_remaining_tags',
+            field=models.PositiveBigIntegerField(default=0),
+        ),
+    ]

apps/tag/migrations/0042_tagdistribution_parent_and_more.py

@@ -0,0 +1,29 @@
+# Generated by Django 5.0 on 2026-01-27 09:18
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tag', '0041_tagbatch_total_remaining_tags'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='tagdistribution',
+            name='parent',
+            field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='child', to='tag.tagdistribution'),
+        ),
+        migrations.AddField(
+            model_name='tagdistribution',
+            name='remaining_number',
+            field=models.IntegerField(default=0),
+        ),
+        migrations.AddField(
+            model_name='tagdistribution',
+            name='total_tag_count',
+            field=models.IntegerField(default=0),
+        ),
+    ]

apps/tag/models.py

@@ -47,11 +47,17 @@ class Tag(BaseModel):
 
 
 class TagBatch(BaseModel):
+    batch_identity = models.CharField(
+        unique=True,
+        max_length=50,
+        null=True
+    )
     organization = models.ForeignKey(
         Organization,
         on_delete=models.CASCADE,
         related_name='tag_batches',
-        null=True
+        null=True,
+        help_text="creator org of tag batch"
     )
     request_number = models.CharField(
         max_length=50,
@@ -59,10 +65,12 @@ class TagBatch(BaseModel):
         null=True
     )
 
-    tag = models.ManyToManyField(Tag, related_name='tags')
+    tag = models.ManyToManyField(Tag, related_name='batches')
     species_code = models.IntegerField(default=0)
     serial_from = models.PositiveBigIntegerField(default=0)
     serial_to = models.PositiveBigIntegerField(default=0)
+    total_distributed_tags = models.PositiveBigIntegerField(default=0)
+    total_remaining_tags = models.PositiveBigIntegerField(default=0)
 
     status = models.CharField(
         max_length=20,
@@ -83,29 +91,87 @@ class TagBatch(BaseModel):
 
 
 class TagDistribution(BaseModel):
+    parent = models.ForeignKey(
+        'self',
+        on_delete=models.CASCADE,
+        related_name='child',
+        null=True
+    )
+    dist_identity = models.CharField(max_length=20, default="0", unique=True, null=True)
     batch = models.ForeignKey(
         TagBatch,
         on_delete=models.CASCADE,
-        related_name='distributions',
+        related_name='tag_distributions',
         null=True
     )
     tag = models.ManyToManyField(Tag, related_name='distributions')
-    organization = models.ForeignKey(
+    assigner_org = models.ForeignKey(
         Organization,
         on_delete=models.CASCADE,
-        related_name='distributions',
+        related_name='assigner_tag_dist',
+        null=True
+    )
+    assigned_org = models.ForeignKey(
+        Organization,
+        on_delete=models.CASCADE,
+        related_name='assigned_tag_dist',
         null=True
     )
     species_code = models.IntegerField(default=0)
+    total_tag_count = models.IntegerField(default=0)
     distributed_number = models.IntegerField(default=0)
+    remaining_number = models.IntegerField(default=0)
+    is_closed = models.BooleanField(default=False)
 
     def __str__(self):
-        return f'{self.id}-{self.distributed_number}-{self.organization.name}'
+        return f'{self.id}-{self.distributed_number}-{self.assigned_org.name}'
 
     def save(self, *args, **kwargs):
         return super(TagDistribution, self).save(*args, **kwargs)
 
 
+class TagDistributionBatch(BaseModel):
+    parent = models.ForeignKey(
+        'self',
+        on_delete=models.CASCADE,
+        related_name='children',
+        null=True
+    )
+    dist_batch_identity = models.CharField(max_length=20, default="0", unique=True, null=True)
+    assigner_org = models.ForeignKey(
+        Organization,
+        on_delete=models.CASCADE,
+        related_name='from_tag_distribution_batch',
+        null=True
+    )
+    assigned_org = models.ForeignKey(
+        Organization,
+        on_delete=models.CASCADE,
+        related_name="to_tag_distribution_batch",
+        null=True
+    )
+    distribution_type = models.CharField(
+        choices=(
+            ('random', 'RANDOM'),
+            ('batch', 'BATCH'),
+        ),
+        max_length=20,
+        null=True,
+        default='batch'
+    )
+    distributions = models.ManyToManyField(TagDistribution, related_name='tag_distribution_batch')
+    total_tag_count = models.IntegerField(default=0)
+    total_distributed_tag_count = models.PositiveBigIntegerField(default=0)
+    remaining_tag_count = models.PositiveBigIntegerField(default=0)
+    is_closed = models.BooleanField(default=False)
+
+    def __str__(self):
+        return f'{self.id}'
+
+    def save(self, *args, **kwargs):
+        return super(TagDistributionBatch, self).save(*args, **kwargs)
+
+
 class TagAssignment(BaseModel):
     organization = models.ForeignKey(
         auth_models.Organization,

apps/tag/services/tag_batch_service.py

@@ -0,0 +1,69 @@
+from django.db.models import Sum, Q, Count, QuerySet, OuterRef, Subquery, IntegerField
+from django.db.models.functions import Coalesce
+
+from apps.authentication.models import Organization
+from apps.authentication.services.service import get_all_org_child
+from apps.tag.models import TagBatch
+
+
+class TagBatchService:
+    """
+    services of tag batch
+    """
+
+    def tag_batch_main_dashboard(self, org: Organization = None, batch: QuerySet[TagBatch] = None):
+        """
+        dashboard data of batch main page
+        """
+
+        qs = TagBatch.objects.select_related('organization') if not batch else batch
+
+        if org.type.key != 'ADM':
+            child_orgs = get_all_org_child(org)  # noqa
+            child_orgs.append(org)
+            qs = qs.filter(organization__in=child_orgs)
+
+        base_data = qs.aggregate(
+            batch_count=Count('id', distinct=True),
+            total_distributed_tags=Coalesce(Sum('total_distributed_tags'), 0),
+            total_remaining_tags=Coalesce(Sum('total_remaining_tags'), 0),
+            has_distributed_batches_number=Count(
+                'id',
+                distinct=True,
+                filter=Q(status__in=[
+                    'distributed',
+                ])
+            )
+        )
+        base_data.update(qs.aggregate(tag_count_created_by_batch=Count('tag')))
+
+        tag_count_subquery = (
+            TagBatch.objects
+            .filter(id=OuterRef('id'))
+            .annotate(cnt=Count('tag'))
+            .values('cnt')
+        )
+
+        species_data = (
+            qs
+            .annotate(
+                tag_count=Subquery(tag_count_subquery, output_field=IntegerField())
+            )
+            .values('species_code')
+            .annotate(
+                batch_count=Count('id', distinct=True),
+                total_distributed_tags=Coalesce(Sum('total_distributed_tags'), 0),
+                total_remaining_tags=Coalesce(Sum('total_remaining_tags'), 0),
+                tag_count_created_by_batch=Coalesce(Sum('tag_count'), 0),
+                has_distributed_batches_number=Count(
+                    'id',
+                    distinct=True,
+                    filter=Q(status='distributed')
+                )
+            )
+            .order_by('species_code')
+        )
+
+        base_data['batch_data_by_species'] = list(species_data)
+
+        return base_data

apps/tag/services/tag_distribution_services.py

@@ -0,0 +1,374 @@
+import random
+
+from django.db import transaction
+from django.db.models import Sum, Q
+from django.db.models.aggregates import Count
+from django.db.models.functions import Coalesce
+from rest_framework.exceptions import PermissionDenied
+
+from apps.authentication.models import Organization
+from apps.livestock.models import LiveStockSpecies
+from apps.tag.exceptions import TagException
+from apps.tag.models import Tag, TagBatch, TagDistribution, TagDistributionBatch
+from common.generics import generate_unique_code
+
+
+class TagDistributionService:
+    """
+    service of distribute tags in organizations
+    """
+
+    def create_distribution_from_batch(self, org: Organization = None, data: dict = None):
+        """
+        distribute tags with batch
+        """
+        with transaction.atomic():
+            distributions = []
+            total_counted_tags = 0
+            assigned_org = Organization.objects.get(id=data.get('assigned_org'))
+
+            for distribution in data.get('dists'):
+                batch_identity = distribution.get('batch_identity', None)
+                # if batch identity exists distribute tags of batch
+                if batch_identity:
+                    batch = TagBatch.objects.get(batch_identity=batch_identity)
+                    tags = Tag.objects.filter(
+                        batches__batch_identity=batch_identity,
+                        species_code=distribution.get('species_code'),
+                        status='F'
+                    )
+                    distribution_type = 'batch'
+                else:
+                    batch = None
+                    # get tags without batch and only with species code
+                    tags = Tag.objects.filter(
+                        species_code=distribution.get('species_code'),
+                        status='F'
+                    )
+                    distribution_type = 'random'
+
+                if tags.count() < distribution.get('count'):
+                    raise TagException(
+                        "تعداد وارد شده از تعداد موجودی این گونه بیشتر میباشد.",  # noqa
+                        403
+                    )
+
+                dist = TagDistribution.objects.create(
+                    batch=batch,
+                    assigner_org=org,
+                    assigned_org=assigned_org,
+                    species_code=distribution.get('species_code'),
+                    total_tag_count=distribution.get('count'),
+                    remaining_number=distribution.get('count'),
+                    dist_identity=generate_unique_code(f"{random.randint(1000, 9999)}"),
+                )
+
+                #  get counted tag ids and filter by them to update status To Reserve
+                counted_tags_obj = tags.order_by('create_date')[:int(distribution.get('count'))]
+                counted_tag_ids = [tag.id for tag in counted_tags_obj]
+                tags.filter(id__in=counted_tag_ids).update(status='R')
+
+                dist.tag.add(*counted_tags_obj)
+                distributions.append(dist)
+
+                total_counted_tags += distribution.get('count')
+
+            # create distribution batch
+            distributions_batch = TagDistributionBatch.objects.create(
+                parent=TagDistributionBatch.objects.get(id=data.get('parent')) if data.get('parent') else None,
+                assigner_org=org,
+                assigned_org=assigned_org,
+                total_tag_count=total_counted_tags,
+                dist_batch_identity=generate_unique_code(f"{random.randint(1000, 9999)}"),
+                distribution_type=distribution_type,
+            )
+            distributions_batch.distributions.add(*distributions)
+
+        return {'tag_distributions': distributions, 'distributions_batch': distributions_batch}
+
+    def edit_distribution_from_batch(
+            self, dist_batch: TagDistributionBatch = None,
+            data: dict = None,
+            org: Organization = None
+    ):
+        """
+        edit record of distributed tags
+        """
+
+        #  clear and hard delete of distributions
+        dist_batch_distributions = dist_batch.distributions.all()
+        for dist in dist_batch_distributions:  # free distributed tags from reserve
+            dist.tag.all().update(status='F')
+        dist_batch_distributions.delete()
+
+        # create new distributions and update batch
+        total_counted_tags = 0
+        distributions = []
+        assigned_org = Organization.objects.get(id=data.get('assigned_org'))
+        for distribution in data.get('dists'):
+            batch_identity = distribution.get('batch_identity', None)
+            # if batch identity exists distribute tags of batch
+            if batch_identity:
+                batch = TagBatch.objects.get(batch_identity=batch_identity)
+                tags = Tag.objects.filter(
+                    batches__batch_identity=batch_identity,
+                    species_code=distribution.get('species_code'),
+                    status='F'
+                )
+                distribution_type = 'batch'
+            else:
+                batch = None
+                # get tags without batch and only with species code
+                tags = Tag.objects.filter(
+                    species_code=distribution.get('species_code'),
+                    status='F'
+                )
+                distribution_type = 'random'
+
+            if tags.count() < distribution.get('count'):
+                raise TagException(
+                    "تعداد وارد شده از تعداد موجودی این گونه بیشتر میباشد.",  # noqa
+                    403
+                )
+
+            dist = TagDistribution.objects.create(
+                batch=batch,
+                assigner_org=org,
+                assigned_org=assigned_org,
+                species_code=distribution.get('species_code'),
+                total_tag_count=distribution.get('count'),
+                remaining_number=distribution.get('count'),
+                dist_identity=generate_unique_code(f"{random.randint(1000, 9999)}"),
+            )
+
+            #  get counted tag ids and filter by them to update status To Reserve
+            counted_tags_obj = tags.order_by('create_date')[:int(distribution.get('count'))]
+            counted_tag_ids = [tag.id for tag in counted_tags_obj]
+            tags.filter(id__in=counted_tag_ids).update(status='R')
+
+            dist.tag.add(*counted_tags_obj)
+            distributions.append(dist)
+
+            total_counted_tags += distribution.get('count')
+
+        # update distribution batch
+        dist_batch.assigned_org = assigned_org
+        dist_batch.total_tag_count = total_counted_tags
+        dist_batch.distribution_type = distribution_type  # noqa
+        dist_batch.save(update_fields=['assigned_org', 'total_tag_count', 'distribution_type'])
+        dist_batch.distributions.add(*distributions)
+
+        return {'tag_distributions': distributions, 'distributions_batch': dist_batch}
+
+    def create_distribution_from_distribution(
+            self, org: Organization = None,
+            tag_batch: TagDistributionBatch = None,
+            data: dict = None
+    ):
+        """
+        create a distribution from distribution to target organization
+        """
+        with transaction.atomic():
+            distributions = []
+            total_counted_tags = 0
+
+            assigned_org = Organization.objects.get(id=data['assigned_org'])
+            parent_batch = TagDistributionBatch.objects.get(
+                id=data['parent_distribution_batch']
+            )
+
+            if parent_batch.assigned_org != org and org.type.key != 'ADM':
+                raise PermissionDenied("دسترسی غیرمجاز")  # noqa
+
+            for dist_data in data['dists']:
+                species = dist_data['species_code']
+                count = dist_data['count']
+                parent_tag_distribution = TagDistribution.objects.get(
+                    id=dist_data['parent_tag_distribution']
+                )
+                batch = TagBatch.objects.get(
+                    batch_identity=dist_data.get('batch_identity')
+                ) if dist_data.get('batch_identity') else None
+
+                tags = Tag.objects.filter(
+                    distributions__tag_distribution_batch=parent_batch,
+                    species_code=species,
+                    status='R',
+                )
+
+                if tags.count() < count:
+                    raise TagException("پلاک کافی برای این گونه وجود ندارد", 403)  # noqa
+
+                dist = TagDistribution.objects.create(
+                    parent=parent_tag_distribution,
+                    batch=batch,
+                    assigner_org=org,
+                    assigned_org=assigned_org,
+                    species_code=species,
+                    total_tag_count=count,
+                    remaining_number=count,
+                    dist_identity=generate_unique_code(
+                        f"{random.randint(1000, 9999)}"
+                    ),
+                )
+
+                selected_tags = tags.order_by('create_date')[:count]
+                dist.tag.add(*selected_tags)
+
+                distributions.append(dist)
+                total_counted_tags += count
+
+            dist_batch = TagDistributionBatch.objects.create(
+                parent=parent_batch,
+                assigner_org=org,
+                assigned_org=assigned_org,
+                total_tag_count=total_counted_tags,
+                distribution_type=parent_batch.distribution_type,
+                dist_batch_identity=generate_unique_code(
+                    f"{random.randint(1000, 9999)}"
+                )
+            )
+
+            dist_batch.distributions.add(*distributions)
+
+            return {
+                'tag_distributions': distributions,
+                'distributions_batch': dist_batch
+            }
+
+    def edit_distribution_from_distribution(
+            self, org: Organization = None,
+            tag_batch: TagDistributionBatch = None,
+            data: dict = None
+
+    ):
+        with transaction.atomic():
+
+            if tag_batch.assigner_org != org:
+                raise PermissionDenied("اجازه ویرایش این توزیع را ندارید")  # noqa
+
+            for dist in tag_batch.distributions.all():
+                dist.tag.all().update(
+                    status='R',
+                    organization=org
+                )
+
+            old_distributions = tag_batch.distributions.all()
+            tag_batch.distributions.clear()
+            old_distributions.delete()
+
+            assigned_org = Organization.objects.get(id=data['assigned_org'])
+            parent_batch = tag_batch.parent
+
+            distributions = []
+            total_counted_tags = 0
+
+            for dist_data in data['dists']:
+                species = dist_data['species_code']
+                parent_tag_distribution = TagDistribution.objects.get(
+                    id=dist_data['parent_tag_distribution']
+                )
+                batch = TagBatch.objects.get(
+                    batch_identity=dist_data.get('batch_identity')
+                ) if dist_data.get('batch_identity') else None
+                count = dist_data['count']
+
+                tags = Tag.objects.filter(
+                    distributions__tag_distribution_batch=parent_batch,
+                    species_code=species,
+                    status='R',
+                )
+
+                if tags.count() < count:
+                    raise TagException(
+                        "پلاک کافی برای این گونه وجود ندارد",  # noqa
+                        403
+                    )
+
+                dist = TagDistribution.objects.create(
+                    parent=parent_tag_distribution,
+                    batch=batch,
+                    assigner_org=org,
+                    assigned_org=assigned_org,
+                    species_code=species,
+                    total_tag_count=count,
+                    remaining_number=count,
+                    dist_identity=generate_unique_code(
+                        f"{random.randint(1000, 9999)}"
+                    ),
+                )
+
+                selected_tags = tags.order_by('create_date')[:count]
+                dist.tag.add(*selected_tags)
+
+                distributions.append(dist)
+                total_counted_tags += count
+
+            # 5️⃣ update distribution batch
+            tag_batch.assigned_org = assigned_org
+            tag_batch.total_tag_count = total_counted_tags
+            tag_batch.is_closed = False
+            tag_batch.save(update_fields=[
+                'assigned_org',
+                'total_tag_count',
+                'is_closed'
+            ])
+
+            tag_batch.distributions.add(*distributions)
+
+            return {
+                'tag_distributions': distributions,
+                'distributions_batch': tag_batch
+            }
+
+    def distribution_batch_main_dashboard(self, org: Organization, is_closed: str = 'false'):
+        """
+        distribution batch main page dashboard detail
+        """
+
+        is_closed = False if is_closed == 'false' else True
+
+        if org.type.key == 'ADM':
+            distribution_query = (Q(is_closed=is_closed))
+        else:
+            distribution_query = (
+                Q(assigner_org=org) |
+                Q(assigned_org=org),
+                Q(is_closed=is_closed)
+            )
+
+        distributions_batch = TagDistributionBatch.objects.prefetch_related(
+            'distributions'
+        ).filter(distribution_query)
+
+        data = distributions_batch.aggregate(
+            count=Count('id'),
+            total_sent_tag_count=Coalesce(Sum('total_tag_count', filter=Q(assigner_org=org)), 0),
+            total_recieved_tag_count=Coalesce(Sum('total_tag_count', filter=Q(assigned_org=org)), 0),
+            total_recieved_distributions=Count('id', filter=Q(assigned_org=org)),
+            total_sent_distributions=Count('id', filter=Q(assigner_org=org)),
+            total_distributed_tag_count=Sum('total_distributed_tag_count'),
+            remaining_tag_count=Sum('remaining_tag_count'),
+        )
+
+        #  distributions item list detail
+        items_list = []
+        distributions = TagDistribution.objects.filter(
+            distribution_query
+        )
+
+        species = LiveStockSpecies.objects.values('value')
+
+        for spec in species:
+            dist_data = distributions.aggregate(
+                dist_count=Count('id', filter=Q(species_code=spec.get('value'))),
+                tag_count=Coalesce(
+                    Sum('distributed_number', filter=Q(species_code=spec.get('value'))), 0
+                )
+            )
+            dist_data.update({'species_code': spec.get('value')})  # add species code to data
+            items_list.append(dist_data)
+
+        data.update({'items': items_list})
+
+        return data

apps/tag/services/tag_services.py

@@ -1,3 +1,5 @@
+import random
+
 from django.db.models import Q
 from django.db.models.aggregates import Count
 
@@ -7,6 +9,14 @@ from apps.tag.exceptions import TagException
 from apps.tag.models import Tag, TagBatch
 from apps.tag.tools import tag_code_serial_scanning
 
+SPECIES_MAP = {
+    'cow': 1,
+    'buffalo': 2,
+    'camel': 3,
+    'sheep': 4,
+    'goat': 5,
+}
+
 
 class TagService:
     """
@@ -44,12 +54,15 @@ class TagService:
 
         # create tag batch
         request_number = (serial_end_range - serial_start_range) + 1
+        batch_identity = f'{serial_start_range}{serial_end_range}{data.get("species_code")}{random.randint(1000, 9999)}'
         batch = TagBatch.objects.create(
+            batch_identity=batch_identity,
             organization=org,
             request_number=request_number if request_number > 0 else 1,
             species_code=data.get('species_code'),
             serial_from=serial_start_range,
             serial_to=serial_end_range,
+            total_remaining_tags=request_number if request_number > 0 else 1,
             status='created',
         )
 
@@ -92,6 +105,7 @@ class TagService:
         batch.species_code = data.get('species_code')
         batch.serial_from = serial_start_range
         batch.serial_to = serial_end_range
+        batch.total_remaining_tags = request_number
         batch.save(update_fields=['request_number', 'species_code', 'serial_from', 'serial_to'])
 
         # recreate tags for batch

apps/tag/signals/tag_distribution_signals.py

@@ -0,0 +1,75 @@
+from django.db.models import Sum
+from django.db.models.functions import Coalesce
+from django.db.models.signals import m2m_changed
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+
+from apps.tag.models import TagDistribution, TagDistributionBatch, Tag
+
+
+@receiver(m2m_changed, sender=TagDistribution.tag.through)
+def update_batch_on_distribution_change(
+        sender, instance: TagDistribution, action, **kwargs
+):
+    if action not in ['post_add', 'post_remove', 'post_clear']:
+        return
+
+    if not instance.batch:
+        return
+
+    if instance.parent:
+        return
+    
+    batch = instance.batch
+
+    distributions = TagDistribution.objects.filter(batch=batch)
+
+    distributed_tags = Tag.objects.filter(
+        distributions__batch=batch,
+        status__in=['R', 'A'],
+    ).distinct().count()
+
+    print("distributed_tags", distributed_tags)
+    batch.total_distributed_tags = distributed_tags
+    batch.total_remaining_tags = (
+            int(batch.request_number) - distributed_tags
+    )
+
+    batch.status = (
+        'distributed'
+        if batch.total_remaining_tags == 0
+        else 'created'
+    )
+
+    batch.save(update_fields=[
+        'total_distributed_tags',
+        'total_remaining_tags',
+        'status'
+    ])
+
+
+@receiver(post_save, sender=TagDistributionBatch)
+def calculate_tag_distribution_detail(sender, instance: TagDistributionBatch, **kwargs):
+    """
+    calculate distribution & remaining distributed tags
+    """
+
+    if getattr(instance, 'flag', False):
+        return
+
+    tag_dist_batch = instance
+    parent = tag_dist_batch.parent
+    if parent:
+        parent.total_distributed_tag_count = parent.children.aggregate(
+            total=Coalesce(Sum('total_tag_count'), 0)
+        )['total']
+        parent.remaining_tag_count = (
+                parent.total_tag_count - parent.total_distributed_tag_count
+        )
+        parent.parent_flag = True
+        parent.save(update_fields=['remaining_tag_count', 'total_distributed_tag_count'])
+
+    if not getattr(instance, 'parent_flag', False):
+        tag_dist_batch.remaining_tag_count = tag_dist_batch.total_tag_count
+        instance.flag = True
+        tag_dist_batch.save(update_fields=['remaining_tag_count'])

apps/tag/web/api/v1/api.py

@@ -16,13 +16,15 @@ from apps.core.mixins.soft_delete_mixin import SoftDeleteMixin
 from apps.tag import exceptions as tag_exceptions
 from apps.tag import models as tag_models
 from apps.tag.models import TagBatch
+from apps.tag.services.tag_batch_service import TagBatchService
+from apps.tag.services.tag_distribution_services import TagDistributionService
 from apps.tag.services.tag_services import TagService
 from common.helpers import get_organization_by_user
 from common.liara_tools import upload_to_liara
 from .serializers import (
     TagSerializer,
     TagAssignmentSerializer,
-    AllocatedTagsSerializer, TagBatchSerializer
+    AllocatedTagsSerializer, TagBatchSerializer, TagDistributionSerializer, TagDistributionBatchSerializer
 )
 
 
@@ -33,6 +35,7 @@ class TagViewSet(BaseViewSet, TagService, SoftDeleteMixin, DynamicSearchMixin, v
     filter_backends = [SearchFilter]
     search_fields = [
         'serial',
+        'status',
         'tag_code',
         'organization__name',
         'organization__type__key',
@@ -68,7 +71,6 @@ class TagViewSet(BaseViewSet, TagService, SoftDeleteMixin, DynamicSearchMixin, v
 
         org = get_organization_by_user(request.user)  # noqa
         serial_start_range, serial_end_range = request.data.pop('serial_range')  # serial_range is like [500, 550]
-        print(serial_start_range, serial_end_range)
         data = request.data.copy()
 
         # create tag & batch
@@ -115,6 +117,25 @@ class TagViewSet(BaseViewSet, TagService, SoftDeleteMixin, DynamicSearchMixin, v
         response = self.tag_detail(by_id=pk)
         return Response(response)
 
+    @action(
+        methods=['get'],
+        detail=True,
+        url_name='tags_by_batch',
+        url_path='tags_by_batch',
+        name='tags_by_batch',
+    )
+    def get_tags_by_batch_id(self, request, pk=None):
+        """
+        get tags by batch id
+        """
+        tags = self.queryset.filter(batches__id=pk)
+
+        page = self.paginate_queryset(tags)
+        if page is not None:  # noqa
+            serializer = self.get_serializer(page, many=True)
+            return self.get_paginated_response(serializer.data)
+        return Response(self.serializer_class(tags).data)
+
     @action(
         methods=['get'],
         detail=False,
@@ -285,7 +306,7 @@ class AllocatedTagsViewSet(SoftDeleteMixin, viewsets.ModelViewSet):
     serializer_class = AllocatedTagsSerializer
 
 
-class TagBatchViewSet(BaseViewSet, SoftDeleteMixin, DynamicSearchMixin, viewsets.ModelViewSet):
+class TagBatchViewSet(BaseViewSet, SoftDeleteMixin, DynamicSearchMixin, TagBatchService, viewsets.ModelViewSet):
     queryset = TagBatch.objects.all()
     serializer_class = TagBatchSerializer
     filter_backends = [SearchFilter]
@@ -303,6 +324,11 @@ class TagBatchViewSet(BaseViewSet, SoftDeleteMixin, DynamicSearchMixin, viewsets
 
         queryset = self.get_queryset(visibility_by_org_scope=True).order_by('-create_date')
 
+        params = self.request.query_params  # noqa
+
+        if params.get('species_code'):
+            queryset = queryset.filter(species_code=int(params.get('species_code')))
+
         # filter queryset
         queryset = self.filter_query(self.filter_queryset(queryset))
 
@@ -312,6 +338,44 @@ class TagBatchViewSet(BaseViewSet, SoftDeleteMixin, DynamicSearchMixin, viewsets
             return self.get_paginated_response(serializer.data)
         return Response(self.serializer_class(queryset).data)
 
+    @action(
+        methods=['get'],
+        detail=False,
+        url_name='main_dashboard',
+        url_path='main_dashboard',
+        name='main_dashboard',
+    )
+    def main_dashboard(self, request):
+        """
+        dashboard of tag batches main page
+        """
+        org = get_organization_by_user(request.user)
+
+        dashboard_data = self.tag_batch_main_dashboard(org=org)
+
+        return Response(dashboard_data, status=status.HTTP_200_OK)
+
+    @action(
+        methods=['get'],
+        detail=True,
+        url_name='inner_dashboard',
+        url_path='inner_dashboard',
+        name='inner_dashboard',
+    )
+    def inner_dashboard(self, request, pk=None):
+        """
+        dashboard of tag batches inner page by id
+        """
+
+        org = get_organization_by_user(request.user)
+
+        dashboard_data = self.tag_batch_main_dashboard(
+            org=org,
+            batch=self.queryset.filter(id=self.get_object().id)
+        )
+
+        return Response(dashboard_data, status=status.HTTP_200_OK)
+
     def destroy(self, request, pk=None, *args, **kwargs):
         """
         soft delete batch with tag items
@@ -323,3 +387,304 @@ class TagBatchViewSet(BaseViewSet, SoftDeleteMixin, DynamicSearchMixin, viewsets
             tag.soft_delete()
 
         return Response(status=status.HTTP_200_OK)
+
+
+class TagDistributionViewSet(
+    BaseViewSet,
+    SoftDeleteMixin,
+    DynamicSearchMixin,
+    viewsets.ModelViewSet,
+    TagDistributionService
+):
+    queryset = tag_models.TagDistribution.objects.all()
+    serializer_class = TagDistributionSerializer
+    filter_backends = [SearchFilter]
+    search_fields = [
+        'batch__batch_identity',
+        'tag__tag_code',
+        'assigner_org__name',
+        'assigned_org__name',
+        'species_code',
+    ]
+
+    def list(self, request, *args, **kwargs):
+        """
+        list of tag distributions
+        """
+        queryset = self.get_queryset(visibility_by_org_scope=True).filter(is_closed=False).order_by('-create_date')
+
+        queryset = self.filter_queryset(self.filter_query(queryset))
+
+        page = self.paginate_queryset(queryset)
+        if page is not None:  # noqa
+            serializer = self.get_serializer(page, many=True)
+            return self.get_paginated_response(serializer.data)
+        return Response(self.serializer_class(queryset).data)
+
+    def create(self, request, *args, **kwargs):
+        """
+        create tag distributions with batch or without batch in random
+        """
+        org = get_organization_by_user(request.user)
+        data = request.data.copy()
+
+        distribution_data = self.create_distribution_from_batch(
+            org=org,
+            data=data
+        )
+
+        serializer = self.serializer_class(distribution_data.get('tag_distributions'), many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def update(self, request, pk=None, *args, **kwargs):
+        """
+        edit tag distribution with/without batch in random
+        """
+
+        org = get_organization_by_user(request.user)
+        data = request.data.copy()
+        dist_batch = tag_models.TagDistributionBatch.objects.get(id=pk)
+
+        distribution_data = self.edit_distribution_from_batch(org=org, data=data, dist_batch=dist_batch)
+
+        serializer = self.serializer_class(distribution_data.get('tag_distributions'), many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @action(
+        methods=['post'],
+        detail=True,
+        url_path='distribute_distribution',
+        url_name='distribute_distribution',
+        name='distribute_distribution',
+    )
+    def create_distribute_from_distribution(self, request, pk=None):
+        """
+        distribute from a tag distribution
+        """
+
+        data = request.data.copy()
+        org = get_organization_by_user(request.user)
+        dist_batch = tag_models.TagDistributionBatch.objects.get(id=pk)
+
+        distribution_data = self.create_distribution_from_distribution(
+            org=org,
+            tag_batch=dist_batch,
+            data=data
+        )
+
+        serializer = self.serializer_class(distribution_data.get('tag_distributions'), many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @action(
+        methods=['put'],
+        detail=True,
+        url_path='edit_distribute_distribution',
+        url_name='edit_distribute_distribution',
+        name='edit_distribute_distribution',
+    )
+    def update_distribute_from_distribution(self, request, pk=None):
+        """
+        update created distribution from distribution
+        """
+
+        data = request.data.copy()
+        org = get_organization_by_user(request.user)
+        dist_batch = tag_models.TagDistributionBatch.objects.get(id=pk)
+
+        distribution_data = self.edit_distribution_from_distribution(
+            org=org,
+            tag_batch=dist_batch,
+            data=data
+        )
+
+        serializer = self.serializer_class(distribution_data.get('tag_distributions'), many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @action(
+        methods=['get'],
+        detail=True,
+        url_name='dist_by_batch',
+        url_path='dist_by_batch',
+        name='dist_by_batch'
+    )
+    def get_dist_by_batch(self, request, pk=None):
+        """
+        get distributions by batch
+        """
+        batch = tag_models.TagDistributionBatch.objects.get(id=pk)
+        distributions = batch.distributions.all()
+
+        page = self.paginate_queryset(distributions)
+        if page is not None:  # noqa
+            serializer = self.get_serializer(page, many=True)
+            return self.get_paginated_response(serializer.data)
+        return Response(self.serializer_class(distributions).data)
+
+    @action(
+        methods=['post'],
+        detail=True,
+        url_name='close_distribution',
+        url_path='close_distribution',
+        name='close_distribution',
+    )
+    def close_tag_distribution(self, request, pk=None):
+        distribution = self.get_object()
+        distribution.is_closed = True
+        distribution.save()
+
+        return Response(status=status.HTTP_200_OK)
+
+    @action(
+        methods=['get'],
+        detail=False,
+        url_path='close_distributions_list',
+        url_name='close_distributions_list',
+        name='close_distributions_list',
+    )
+    def close_distributions_list(self, request):
+        """
+        list of closed distributions
+        """
+
+        queryset = self.get_queryset(visibility_by_org_scope=True).filter(is_closed=True).order_by('-create_date')
+        queryset = self.filter_query(queryset)
+
+        page = self.paginate_queryset(queryset)
+        if page is not None:  # noqa
+            serializer = self.get_serializer(page, many=True)
+            return self.get_paginated_response(serializer.data)
+        return Response(self.serializer_class(queryset).data)
+
+
+class TagDistributionBatchViewSet(
+    BaseViewSet,
+    viewsets.ModelViewSet,
+    SoftDeleteMixin,
+    DynamicSearchMixin,
+    TagDistributionService
+):
+    queryset = tag_models.TagDistributionBatch.objects.all()
+    serializer_class = TagDistributionBatchSerializer
+    filter_backends = [SearchFilter]
+    search_filter = [
+        'dist_batch_identity',
+        'assigner_org__name',
+        'assigned_org__name',
+        'total_tag_count',
+        'is_closed',
+    ]
+
+    def list(self, request, *args, **kwargs):
+        """
+        list of tag distribution batches
+        """
+
+        queryset = self.get_queryset(visibility_by_org_scope=True).filter(is_closed=False).order_by('-create_date')
+
+        queryset = self.filter_query(self.filter_queryset(queryset))
+
+        page = self.paginate_queryset(queryset)
+        if page is not None:  # noqa
+            serializer = self.get_serializer(page, many=True)
+            return self.get_paginated_response(serializer.data)
+        return Response(self.serializer_class(queryset).data)
+
+    def retrieve(self, request, pk=None, *args, **kwargs):
+        """
+        detail of distribution batch
+        """
+
+        distribution_batch = self.get_object()
+        serializer = self.serializer_class(distribution_batch)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @action(
+        methods=['post'],
+        detail=True,
+        url_name='close_dist_batch',
+        url_path='close_dist_batch',
+        name='close_dist_batch',
+    )
+    def close_tag_dist_batch(self, request, pk=None):
+        dist_batch = self.get_object()
+
+        # close distribution batch
+        dist_batch.is_closed = True
+        dist_batch.save()
+        dist_batch.distributions.all().update(is_closed=True)  # close distributions of batch
+        for distribute in dist_batch.distributions.all():
+            distribute.tag.all().update(status='F')
+
+        return Response(status=status.HTTP_200_OK)
+
+    @action(
+        methods=['get'],
+        detail=False,
+        url_path='closed_tag_dist_batch_list',
+        url_name='closed_tag_dist_batch_list',
+        name='closed_tag_dist_batch_list',
+    )
+    def close_tag_dist_batch_list(self, request):
+        """
+        list of closed tag distributions batch
+        """
+
+        queryset = self.get_queryset(visibility_by_org_scope=True).filter(is_closed=True).order_by('create_date')
+        queryset = self.filter_query(self.filter_queryset(queryset))
+
+        page = self.paginate_queryset(queryset)
+        if page is not None:  # noqa
+            serializer = self.get_serializer(page, many=True)
+            return self.get_paginated_response(serializer.data)
+        return Response(self.serializer_class(queryset).data)
+
+    @action(
+        methods=['post'],
+        detail=True,
+        url_name='reactivate_tag_dist_batch',
+        url_path='reactivate_tag_dist_batch',
+        name='reactivate_tag_dist_batch',
+    )
+    def reactivate_tag_dist_batch(self, request, pk=None):
+        """
+        reactivate canceled distribution batch
+        """
+
+        dist_batch = self.get_object()
+        dist_batch.is_closed = False
+        dist_batch.save(update_fields=['is_closed'])  #
+
+        return Response(status=status.HTTP_200_OK)
+
+    @action(
+        methods=['get'],
+        detail=False,
+        url_path='main_dashboard',
+        url_name='main_dashboard',
+        name='main_dashboard'
+    )
+    def main_dashboard(self, request):
+        """
+        dashboard of main page
+        """
+        org = get_organization_by_user(request.user)
+        params = self.request.query_params  # noqa
+        dashboard_data = self.distribution_batch_main_dashboard(org=org, is_closed=params.get('is_closed'))
+
+        return Response(dashboard_data, status=status.HTTP_200_OK)
+
+    def destroy(self, request, pk=None, *args, **kwargs):
+        """
+        delete tag distribution batch and free their tag from distribute
+        """
+
+        dist_batch = self.get_object()
+
+        for distribute in dist_batch.distributions.all():
+            distribute.tag.all().update(status='F')
+            distribute.tag.clear()
+            distribute.soft_delete()
+
+        dist_batch.soft_delete()
+
+        return Response(status=status.HTTP_200_OK)

apps/tag/web/api/v1/serializers.py

@@ -136,6 +136,11 @@ class TagBatchSerializer(serializers.ModelSerializer):
     def to_representation(self, instance):
         representation = super().to_representation(instance)
 
+        representation['organization'] = {
+            'id': instance.organization.id,
+            'name': instance.organization.name
+        }
+
         representation['tag'] = [{
             'tag_code': tag.tag_code,
             'species_code': tag.species_code,
@@ -143,3 +148,67 @@ class TagBatchSerializer(serializers.ModelSerializer):
         } for tag in instance.tag.all()]
 
         return representation
+
+
+class TagDistributionSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = tag_models.TagDistribution
+        fields = '__all__'
+
+    def to_representation(self, instance):
+        """
+        customize output of serializer
+        """
+        representation = super().to_representation(instance)
+
+        if instance.batch:
+            representation['batch'] = {
+                'id': instance.batch.id,
+                'batch_creator': instance.batch.organization.name,
+                'batch_identity': instance.batch.batch_identity
+            }
+
+        representation['assigner_org'] = {
+            'id': instance.assigner_org.id,
+            'name': instance.assigner_org.name
+        }
+
+        representation['assigned_org'] = {
+            'id': instance.assigned_org.id,
+            'name': instance.assigned_org.name
+        }
+
+        return representation
+
+
+class TagDistributionBatchSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = tag_models.TagDistributionBatch
+        fields = '__all__'
+
+    def to_representation(self, instance):
+        representation = super().to_representation(instance)
+
+        representation['assigner_org'] = {
+            'id': instance.assigner_org.id,
+            'name': instance.assigner_org.name,
+        }
+
+        representation['assigned_org'] = {
+            'id': instance.assigned_org.id,
+            'name': instance.assigned_org.name
+        }
+
+        representation['distributions'] = [{
+            'id': dist.id,
+            'dist_identity': dist.dist_identity,
+            'batch_identity': dist.batch.batch_identity if dist.batch else None,
+            'species_code': dist.species_code,
+            'distributed_number': dist.distributed_number,
+            'total_tag_count': dist.total_tag_count,
+            'remaining_number': dist.remaining_number,
+            'serial_from': dist.batch.serial_from if dist.batch else None,
+            'serial_to': dist.batch.serial_to if dist.batch else None,
+        } for dist in instance.distributions.all()]
+
+        return representation

apps/tag/web/api/v1/urls.py

@@ -4,7 +4,7 @@ from rest_framework.routers import DefaultRouter
 from .api import (
     TagViewSet,
     TagAssignmentViewSet,
-    AllocatedTagsViewSet, TagBatchViewSet
+    AllocatedTagsViewSet, TagBatchViewSet, TagDistributionViewSet, TagDistributionBatchViewSet
 )
 
 router = DefaultRouter()
@@ -12,6 +12,8 @@ router.register(r'tag', TagViewSet, basename='tag')
 router.register(r'tag_assignment', TagAssignmentViewSet, basename='tag_assignment')
 router.register(r'allocated_tag', AllocatedTagsViewSet, basename='allocated_tag')
 router.register(r'tag_batch', TagBatchViewSet, basename='tag_batch')
+router.register(r'tag_distribution', TagDistributionViewSet, basename='tag_distribution')
+router.register(r'tag_distribution_batch', TagDistributionBatchViewSet, basename='tag_distribution_batch')
 
 urlpatterns = [
     path('v1/', include(router.urls))

apps/warehouse/services/transaction_dashboard_service.py

@@ -12,7 +12,14 @@ from apps.warehouse.models import InventoryQuotaSaleTransaction, InventoryQuotaS
 class TransactionDashboardService:
 
     @staticmethod
-    def get_dashboard(org: Organization, start_date: str = None, end_date: str = None, status: str = None):
+    def get_dashboard(
+            org: Organization,
+            free_visibility_tr_objects=None,
+            free_visibility_tr_item_objects=None,
+            start_date: str = None,
+            end_date: str = None,
+            status: str = None
+    ):
 
         orgs_child = get_all_org_child(org=org)
         orgs_child.append(org)
@@ -23,13 +30,18 @@ class TransactionDashboardService:
             items = InventoryQuotaSaleItem.objects.all().select_related("gov_product", "free_product")
 
         else:
-            transactions = InventoryQuotaSaleTransaction.objects.filter(
+            if free_visibility_tr_objects:
-                seller_organization__in=orgs_child
+                transactions = free_visibility_tr_objects
-            )
+                items = InventoryQuotaSaleItem.objects.filter(
-
+                    transaction__in=transactions
-            items = InventoryQuotaSaleItem.objects.filter(
+                ).select_related("gov_product", "free_product")
-                transaction__seller_organization__in=orgs_child
+            else:
-            ).select_related("gov_product", "free_product")
+                transactions = InventoryQuotaSaleTransaction.objects.filter(
+                    seller_organization__in=orgs_child
+                )
+                items = InventoryQuotaSaleItem.objects.filter(
+                    transaction__seller_organization__in=orgs_child
+                ).select_related("gov_product", "free_product")
 
         # filter queryset (transactions & items) by date
         if start_date and end_date:

apps/warehouse/web/api/v1/api.py

@@ -280,13 +280,31 @@ class InventoryQuotaSaleTransactionViewSet(
         transaction_status = query_param.get('status') if 'status' in query_param.keys() else None
 
         org = get_organization_by_user(request.user)
-        # filer by date & transaction status
+        if org.free_visibility_by_scope:
-        transaction_dashboard_data = self.get_dashboard(
+
-            org,
+            tr_objects = self.get_queryset(visibility_by_org_scope=True)
-            start_date=start_date,
+
-            end_date=end_date,
+            tr_item_view = InventoryQuotaSaleItemViewSet()
-            status=transaction_status
+            tr_item_view.request = request
-        )
+            tr_item_view.kwargs = {'pk': None}
+            tr_item_objects = tr_item_view.get_queryset(visibility_by_org_scope=True)
+
+            transaction_dashboard_data = self.get_dashboard(
+                org,
+                free_visibility_tr_objects=tr_objects,
+                free_visibility_tr_item_objects=tr_item_objects,
+                start_date=start_date,
+                end_date=end_date,
+                status=transaction_status,
+            )
+        else:
+            # filer by date & transaction status
+            transaction_dashboard_data = self.get_dashboard(
+                org,
+                start_date=start_date,
+                end_date=end_date,
+                status=transaction_status,
+            )
 
         return Response(transaction_dashboard_data, status=status.HTTP_200_OK)
 

common/generics.py

@@ -1,4 +1,5 @@
 import base64
+import random
 from datetime import datetime
 from functools import lru_cache
 
@@ -56,3 +57,10 @@ def parse_birthdate(jalali_str):
         gregorian_dt,
         timezone.get_current_timezone()
     )
+
+
+def generate_unique_code(prefix: str):
+    now = timezone.now()
+    date_part = now.strftime("%Y%m%d")
+    rand_part = random.randint(100000, 999999)
+    return f"{prefix}{date_part}{rand_part}"