Department_merge:

        - Inherits from BaseRule.
        - Determines if merging is needed based on ticket load thresholds.
        - Reassigns tickets from overloaded to underutilized departments.

Author: drona-gyawali

management/chat/admin.py

@@ -1,7 +1,6 @@
 from django.contrib import admin
 
-from chat.models import (ChatGroup, FileAttachment, GroupMessage,
-                         ImageAttachment)
+from chat.models import ChatGroup, FileAttachment, GroupMessage, ImageAttachment
 
 admin.site.register(ChatGroup)
 admin.site.register(GroupMessage)

management/chat/api/viewset.py

@@ -3,8 +3,12 @@
 from rest_framework.response import Response
 
 from chat.models import ChatGroup, GroupMessage
-from chat.serializers import (ChatSerializers, FileAttachmentSerializers,
-                              GroupSerializers, ImageAttachmentSerializer)
+from chat.serializers import (
+    ChatSerializers,
+    FileAttachmentSerializers,
+    GroupSerializers,
+    ImageAttachmentSerializer,
+)
 
 
 class ChatMessageView(generics.ListAPIView):

management/chat/serializers.py

@@ -1,9 +1,12 @@
 from rest_framework import serializers
 
-from chat.models import (ChatGroup, FileAttachment, GroupMessage,
-                         ImageAttachment)
-from core.dumps import (FileAttachmentExt, FileAttachmentSize,
-                        ImageAttachmentExt, ImageAttachmentSize)
+from chat.models import ChatGroup, FileAttachment, GroupMessage, ImageAttachment
+from core.dumps import (
+    FileAttachmentExt,
+    FileAttachmentSize,
+    ImageAttachmentExt,
+    ImageAttachmentSize,
+)
 
 
 class GroupSerializers(serializers.ModelSerializer):

management/core/api/payments.py

@@ -176,5 +176,3 @@ def post(self, request):
 
 
 stripe_payment_event = StripeWebhookView.as_view()
-
-# TODO: Esewa and Khalti needs to be also added.

management/core/automation/department_merge.py

@@ -0,0 +1,98 @@
+""" "
+Module: department_merge
+This module provides automation for balancing workload across departments by merging underutilized departments with overloaded ones.
+It identifies departments with low and high ticket loads and reassigns tickets from overloaded departments to underutilized ones,
+ensuring fair distribution of work among agents.
+Classes:
+    Department_merge:
+        - Inherits from BaseRule.
+        - Determines if merging is needed based on ticket load thresholds.
+        - Reassigns tickets from overloaded to underutilized departments.
+Key Concepts:
+    - Load distribution among departments.
+    - Automated ticket reassignment for fair workload.
+    - Utilizes configurable overload and underutilization thresholds.
+
+Copyright (c) Supportix. All rights reserved.
+Written in 2025 by Dorna Raj Gyawali <dronarajgyawali@gmail.com>
+"""
+
+from core.models import Ticket, Department, Agent
+from core.automation.base_rule import BaseRule
+from core.constants import Status
+from django.db import models
+from core.dumps import OVERLOAD_THRESHOLD, UNDERUTILIZED_THRESHOLD
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class Department_merge(BaseRule):
+    """
+    Rule to automatically merged the underutilized department to high load department
+    """
+
+    def __init__(self, ticket, **kwargs):
+        super().__init__(ticket, **kwargs)
+
+    def should_apply(self):
+        try:
+            loads = (
+                Ticket.objects.filter(status=Status.WAITING, agent__isnull=False)
+                .values("agent__department_id")
+                .annotate(count=models.Count("id"))
+            )
+        except Exception as e:
+            logger.error("Error Occured", str(e))
+
+        load_map = {items["agent__department_id"]: items["count"] for items in loads}
+        for dept in Department.objects.all():
+            load_map.setdefault(dept.id, 0)
+
+        max_load = max(load_map.values())
+        min_load = min(load_map.values())
+
+        return max_load > OVERLOAD_THRESHOLD and min_load < UNDERUTILIZED_THRESHOLD
+
+    def apply(self):
+
+        loads = (
+            Ticket.objects.filter(status=Status.WAITING, agent__isnull=False)
+            .values("agent__department_id")
+            .annotate(count=models.Count("id"))
+        )
+
+        load_map = {item["agent__department_id"]: item["count"] for item in loads}
+        for dept in Department.objects.all():
+            load_map.setdefault(dept.id, 0)
+
+        overload_dept_id = max(load_map, key=load_map.get)
+        underload_dept_id = min(load_map, key=load_map.get)
+
+        # exact count e.g. 1,2,4
+        overloaded_count = load_map[overload_dept_id]
+        underloaded_count = load_map[underload_dept_id]
+
+        diff = overloaded_count - underloaded_count
+        num_to_move = max(1, diff // 2)
+
+        logger.info(
+            f"Reassigning {num_to_move} tickets "
+            f"from Dept {overload_dept_id} ({overloaded_count}) "
+            f"to Dept {underload_dept_id} ({underloaded_count})"
+        )
+
+        target_agent = Agent.objects.filter(department_id=underload_dept_id).first()
+
+        tickets_qs = Ticket.objects.filter(
+            status=Status.WAITING, agent__department_id=overload_dept_id
+        ).order_by("created_at")
+        # extract only id not a tuple
+        ticket_ids = list(tickets_qs.values_list("id", flat=True)[:num_to_move])
+
+        if not ticket_ids:
+            logger.info("No tickets to reassign.")
+            return
+
+        updated = Ticket.objects.filter(id__in=ticket_ids).update(agent=target_agent)
+        logger.info(f"Successfully reassigned {updated} tickets.")

management/core/automation/rule_runner.py

@@ -17,12 +17,17 @@
 
 from core.automation.auto_close import AutoClose
 from core.automation.tag_by_content import TagByContent
+from core.automation.department_merge import Department_merge
 
 
 class RuleEngine:
     def __init__(self, ticket_id):
         self.ticket_id = ticket_id
-        self.rules = [AutoClose(ticket_id, inactive_days=1), TagByContent(ticket_id)]
+        self.rules = [
+            AutoClose(ticket_id, inactive_days=1),
+            TagByContent(ticket_id),
+            Department_merge(ticket_id=None),
+        ]
 
     def run(self):
         context = []

management/core/dumps.py

@@ -26,3 +26,5 @@
 FileAttachmentExt = [".pdf"]
 FileAttachmentSize = 20 * 1024 * 1024
 ImageAttachmentSize = 5 * 1024 * 1024
+OVERLOAD_THRESHOLD = 50
+UNDERUTILIZED_THRESHOLD = 10

management/core/tests/test_api.py

@@ -7,6 +7,7 @@
 
 import json
 from datetime import datetime, timedelta
+
 # import uuid
 from decimal import Decimal
 from unittest import mock
@@ -21,8 +22,7 @@
 from rest_framework.test import APIClient
 
 from core.constants import Status
-from core.models import (Agent, Customer, Department, PaymentDetails, Ticket,
-                         User)
+from core.models import Agent, Customer, Department, PaymentDetails, Ticket, User
 
 
 @override_settings(STRIPE_SECRET_KEY="sk_test_123", STRIPE_WEBHOOK_SECRET="whsec_test")

management/core/tests/test_department_merge.py

@@ -0,0 +1,119 @@
+from datetime import timedelta
+
+from django.test import TestCase
+from django.utils import timezone
+
+from core.models import Ticket, Department, Agent, User, Customer
+from core.automation.department_merge import Department_merge
+from core.constants import Status
+from core.dumps import OVERLOAD_THRESHOLD, UNDERUTILIZED_THRESHOLD
+
+
+class DepartmentMergeRuleTest(TestCase):
+    def setUp(self):
+        self.dept_high = Department.objects.create(name="Technical")
+        self.dept_low = Department.objects.create(name="General")
+
+        self.agent_high_user = User.objects.create_user(
+            username="high_agent",
+            email="high@example.com",
+            password="pass",
+            role="agent",
+        )
+        self.agent_high = Agent.objects.create(
+            user=self.agent_high_user,
+            department=self.dept_high,
+            is_available=True,
+            max_customers=100,
+            current_customers=0,
+        )
+
+        self.agent_low_user = User.objects.create_user(
+            username="low_agent",
+            email="low@example.com",
+            password="pass",
+            role="agent",
+        )
+        self.agent_low = Agent.objects.create(
+            user=self.agent_low_user,
+            department=self.dept_low,
+            is_available=True,
+            max_customers=100,
+            current_customers=0,
+        )
+
+        self.customer_user = User.objects.create_user(
+            username="cust",
+            email="cust@example.com",
+            password="pass",
+            role="customer",
+        )
+        self.customer = Customer.objects.create(
+            user=self.customer_user,
+            is_paid=True,
+        )
+
+        for i in range(OVERLOAD_THRESHOLD + 2):
+            Ticket.objects.create(
+                ticket_id=f"TID-TECH-{i}",
+                customer=self.customer,
+                agent=self.agent_high,
+                issue_title="Tech issue",
+                issue_desc="Desc",
+                status=Status.WAITING,
+            )
+        for i in range(UNDERUTILIZED_THRESHOLD - 1):
+            Ticket.objects.create(
+                ticket_id=f"TID-GEN-{i}",
+                customer=self.customer,
+                agent=self.agent_low,
+                issue_title="Gen issue",
+                issue_desc="Desc",
+                status=Status.WAITING,
+            )
+        Ticket.objects.all().update(created_at=timezone.now() - timedelta(days=1))
+
+    def test_should_apply_when_loads_imbalanced(self):
+        rule = Department_merge(ticket=None)
+        self.assertTrue(
+            rule.should_apply(),
+            "should_apply() must return True when one dept is overloaded and another underutilized",
+        )
+
+    def test_apply_moves_half_diff(self):
+        rule = Department_merge(ticket=None)
+
+        count_high = Ticket.objects.filter(agent__department=self.dept_high).count()
+        count_low = Ticket.objects.filter(agent__department=self.dept_low).count()
+        diff = count_high - count_low
+        expected_to_move = max(1, diff // 2)
+
+        candidate_qs = Ticket.objects.filter(
+            status=Status.WAITING, agent__department=self.dept_high
+        ).order_by("created_at")
+        ids_to_move = list(candidate_qs.values_list("id", flat=True)[:expected_to_move])
+
+        rule.apply()
+
+        after_high = Ticket.objects.filter(agent__department=self.dept_high).count()
+        after_low = Ticket.objects.filter(agent__department=self.dept_low).count()
+
+        self.assertEqual(
+            after_high,
+            count_high - expected_to_move,
+            f"{expected_to_move} tickets should be moved out of Technical",
+        )
+        self.assertEqual(
+            after_low,
+            count_low + expected_to_move,
+            f"{expected_to_move} tickets should be reassigned into General",
+        )
+
+        moved_count = Ticket.objects.filter(
+            id__in=ids_to_move, agent=self.agent_low
+        ).count()
+        self.assertEqual(
+            moved_count,
+            expected_to_move,
+            "Reassigned tickets should be assigned to the low-load agent",
+        )

management/core/tests/test_rule_runner.py

@@ -0,0 +1,76 @@
+from django.test import TestCase
+from core.models import Department, User, Agent, Customer, Ticket, Status
+from core.automation.rule_runner import RuleEngine
+from unittest.mock import patch, MagicMock
+
+
+class RuleEngineTest(TestCase):
+    def setUp(self):
+        self.department = Department.objects.create(name="Support")
+
+        self.agent_user = User.objects.create_user(
+            username="testagent",
+            email="testagent@example.com",
+            password="testpassword123",
+            role="agent",
+        )
+        self.agent = Agent.objects.create(
+            user=self.agent_user,
+            department=self.department,
+            is_available=True,
+            max_customers=5,
+            current_customers=0,
+        )
+
+        self.customer_user = User.objects.create_user(
+            username="testcustomer",
+            email="testcustomer@example.com",
+            password="testpassword123",
+            role="customer",
+        )
+        self.customer = Customer.objects.create(
+            user=self.customer_user,
+            is_paid=True,
+        )
+
+        self.ticket = Ticket.objects.create(
+            ticket_id="TID-TEST123",
+            customer=self.customer,
+            agent=self.agent,
+            issue_title="Auto-close test",
+            issue_desc="Desc",
+            status=Status.WAITING,
+        )
+
+    @patch("core.automation.rule_runner.AutoClose")
+    @patch("core.automation.rule_runner.TagByContent")
+    @patch("core.automation.rule_runner.Department_merge")
+    def test_rule_engine_run_applies_applicable_rules(
+        self, MockDeptMerge, MockTagByContent, MockAutoClose
+    ):
+        # Configure mocks
+        mock_auto = MagicMock()
+        mock_auto.should_apply.return_value = True
+        mock_auto.apply.return_value = "AutoClosed"
+        mock_auto.__class__.__name__ = "AutoClose"
+        MockAutoClose.return_value = mock_auto
+
+        mock_tag = MagicMock()
+        mock_tag.should_apply.return_value = True
+        mock_tag.apply.return_value = "Ai-WrittenTag"
+        mock_tag.__class__.__name__ = "TagByContent"
+        MockTagByContent.return_value = mock_tag
+
+        mock_merge = MagicMock()
+        mock_merge.should_apply.return_value = True
+        mock_merge.apply.return_value = "Merged"
+        mock_merge.__class__.__name__ = "Department_merge"
+        MockDeptMerge.return_value = mock_merge
+
+        engine = RuleEngine(self.ticket.id)
+        result = engine.run()
+
+        self.assertEqual(len(result), 3)
+        self.assertIn({"rule": "AutoClose", "details": "AutoClosed"}, result)
+        self.assertIn({"rule": "Department_merge", "details": "Merged"}, result)
+        self.assertIn({"rule": "TagByContent", "details": "Ai-WrittenTag"}, result)