@platform-modules/foreign-ministry 1.1.16 → 1.1.18

package/HELPDESK_SCHEMA_DESIGN.md

@@ -0,0 +1,479 @@
+# Helpdesk Service Schema Design
+
+## Overview
+This document outlines the schema design for the Helpdesk Service, which routes tickets based on Category (service), Subcategory (sub_service), and Issue Type, with automatic group assignment for routing.
+
+## Business Requirements
+1. **UI Selection**: User selects Category → Subcategory → Issue Type
+2. **Auto-Routing**: Group Name auto-populated based on selection
+3. **Role-Based Access**: HOD, HOS, and other roles determine who can view/approve requests
+4. **Generic Storage**: Uses existing `general_service_requests` table structure
+
+---
+
+## Schema Changes
+
+### 1. Update `ServiceRequestsModel` (general_service_requests)
+
+**Add new columns:**
+
+```typescript
+@Column({ type: 'int', nullable: true })
+issue_type_id: number | null;  // Reference to issue types table
+
+@Column({ type: 'varchar', length: 255, nullable: true })
+issue_type_name: string | null;  // Denormalized for quick access
+
+@Column({ type: 'varchar', length: 255, nullable: true })
+group_name: string | null;  // Auto-populated routing group
+
+@Column({ type: 'int', nullable: true })
+assigned_group_id: number | null;  // Reference to routing groups table (optional)
+```
+
+**Rationale:**
+- `issue_type_id`: Links to issue types configuration
+- `issue_type_name`: Denormalized for performance (no join needed for listing)
+- `group_name`: Auto-populated based on routing rules
+- `assigned_group_id`: Optional reference if you want a groups table
+
+---
+
+### 2. Create `IssueTypes` Model (NEW)
+
+**Purpose**: Master data for issue types
+
+```typescript
+@Entity({ name: 'issue_types' })
+export class IssueTypes extends BaseModel {
+  @Column({ type: 'varchar', length: 100 })
+  name: string;  // e.g., "Hardware Issue", "Software Issue", "Network Problem"
+
+  @Column({ type: 'varchar', length: 500, nullable: true })
+  description: string | null;
+
+  @Column({ type: 'int' })
+  service_id: number;  // Category
+
+  @Column({ type: 'int' })
+  sub_service_id: number;  // Subcategory
+
+  @Column({ type: 'boolean', default: true })
+  is_active: boolean;
+
+  @Column({ type: 'int', nullable: true })
+  priority: number | null;  // 1=High, 2=Medium, 3=Low
+
+  constructor(
+    name: string,
+    service_id: number,
+    sub_service_id: number,
+    description?: string
+  ) {
+    super();
+    this.name = name;
+    this.service_id = service_id;
+    this.sub_service_id = sub_service_id;
+    this.description = description || null;
+    this.is_active = true;
+  }
+}
+```
+
+---
+
+### 3. Create `RoutingGroups` Model (NEW)
+
+**Purpose**: Define routing groups and their assignments
+
+```typescript
+@Entity({ name: 'routing_groups' })
+export class RoutingGroups extends BaseModel {
+  @Column({ type: 'varchar', length: 255 })
+  group_name: string;  // e.g., "IT-Hardware-Support", "HR-Payroll-Team"
+
+  @Column({ type: 'varchar', length: 500, nullable: true })
+  description: string | null;
+
+  @Column({ type: 'int' })
+  service_id: number;
+
+  @Column({ type: 'int' })
+  sub_service_id: number;
+
+  @Column({ type: 'int', nullable: true })
+  issue_type_id: number | null;  // If null, applies to all issue types in sub-service
+
+  @Column({ type: 'int', nullable: true })
+  default_role_id: number | null;  // Primary role for this group (e.g., HOD, HOS)
+
+  @Column({ type: 'int', nullable: true })
+  department_id: number | null;  // If specific to department
+
+  @Column({ type: 'int', nullable: true })
+  section_id: number | null;  // If specific to section
+
+  @Column({ type: 'jsonb', nullable: true })
+  assigned_role_ids: number[] | null;  // Array of role IDs that can handle this group
+
+  @Column({ type: 'boolean', default: true })
+  is_active: boolean;
+
+  constructor(
+    group_name: string,
+    service_id: number,
+    sub_service_id: number,
+    issue_type_id?: number | null
+  ) {
+    super();
+    this.group_name = group_name;
+    this.service_id = service_id;
+    this.sub_service_id = sub_service_id;
+    this.issue_type_id = issue_type_id || null;
+    this.is_active = true;
+  }
+}
+```
+
+---
+
+### 4. Create `RoutingRules` Model (NEW - Alternative Approach)
+
+**Purpose**: More flexible routing configuration
+
+```typescript
+@Entity({ name: 'routing_rules' })
+export class RoutingRules extends BaseModel {
+  @Column({ type: 'int' })
+  service_id: number;
+
+  @Column({ type: 'int' })
+  sub_service_id: number;
+
+  @Column({ type: 'int', nullable: true })
+  issue_type_id: number | null;  // null = applies to all issue types
+
+  @Column({ type: 'varchar', length: 255 })
+  group_name: string;  // Auto-populated group name
+
+  @Column({ type: 'int', nullable: true })
+  workflow_definition_id: number | null;  // Link to workflow
+
+  @Column({ type: 'int', nullable: true })
+  priority: number | null;  // Rule priority (lower = higher priority)
+
+  @Column({ type: 'jsonb', nullable: true })
+  conditions: any | null;  // Additional conditions (e.g., department, section)
+
+  @Column({ type: 'boolean', default: true })
+  is_active: boolean;
+
+  constructor(
+    service_id: number,
+    sub_service_id: number,
+    group_name: string,
+    issue_type_id?: number | null
+  ) {
+    super();
+    this.service_id = service_id;
+    this.sub_service_id = sub_service_id;
+    this.group_name = group_name;
+    this.issue_type_id = issue_type_id || null;
+    this.is_active = true;
+  }
+}
+```
+
+---
+
+## Auto-Population Logic
+
+### When Creating a Request:
+
+```typescript
+async createHelpdeskRequest(requestData: any) {
+  const { service_id, sub_service_id, issue_type_id, user } = requestData;
+
+  // Step 1: Find routing rule
+  const routingRule = await RoutingRulesRepository.findOne({
+    where: {
+      service_id,
+      sub_service_id,
+      issue_type_id: issue_type_id || null,  // Try specific first
+      is_active: true
+    },
+    order: { priority: 'ASC' }
+  });
+
+  // Step 2: If no specific rule, try generic (issue_type_id = null)
+  if (!routingRule) {
+    const genericRule = await RoutingRulesRepository.findOne({
+      where: {
+        service_id,
+        sub_service_id,
+        issue_type_id: null,
+        is_active: true
+      }
+    });
+    
+    if (genericRule) {
+      routingRule = genericRule;
+    }
+  }
+
+  // Step 3: Auto-populate group_name
+  const groupName = routingRule?.group_name || 
+    `GROUP-${service_id}-${sub_service_id}-${issue_type_id || 'ALL'}`;
+
+  // Step 4: Create request with group_name
+  const serviceRequest = new GeneralServiceRequests(
+    user.id,
+    user.employee_id,
+    user.employee_name,
+    user.email_address,
+    user.contact_number,
+    service_id,
+    sub_service_id,
+    user.section_id,
+    user.reporting_manager
+  );
+
+  serviceRequest.issue_type_id = issue_type_id;
+  serviceRequest.issue_type_name = issueType?.name || null;
+  serviceRequest.group_name = groupName;
+  serviceRequest.assigned_group_id = routingRule?.id || null;
+
+  return await ServiceRequestsRepository.save(serviceRequest);
+}
+```
+
+---
+
+## Query Patterns for Role-Based Access
+
+### 1. Get My Requests (Requester View)
+
+```typescript
+async getMyHelpdeskRequests(userId: number) {
+  return await ServiceRequestsRepository.find({
+    where: {
+      user_id: userId,
+      is_deleted: false
+    },
+    order: { created_at: 'DESC' },
+    relations: ['approvals', 'workflows', 'attachments']
+  });
+}
+```
+
+### 2. Get Requests for My Approval (Role-Based)
+
+```typescript
+async getRequestsForMyApproval(userId: number, roleIds: number[]) {
+  // Get user's department and section
+  const user = await UserRepository.findOne({ where: { id: userId } });
+
+  return await ServiceRequestsRepository
+    .createQueryBuilder('sr')
+    .innerJoin('general_service_approvals', 'sa', 'sa.service_request_id = sr.id')
+    .where('sa.approval_status = :status', { status: 'Pending' })
+    .andWhere('sa.approver_role_id IN (:...roleIds)', { roleIds })
+    .andWhere('sr.is_deleted = :isDeleted', { isDeleted: false })
+    .andWhere('sa.is_deleted = :isDeleted', { isDeleted: false })
+    // Optional: Filter by group if user belongs to specific groups
+    .andWhere(
+      '(sa.department_id = :deptId OR sa.department_id IS NULL)',
+      { deptId: user.department_id }
+    )
+    .andWhere(
+      '(sa.section_id = :sectionId OR sa.section_id IS NULL)',
+      { sectionId: user.section_id }
+    )
+    .orderBy('sr.created_at', 'DESC')
+    .getMany();
+}
+```
+
+### 3. Get Requests by Group (Group Admin View)
+
+```typescript
+async getRequestsByGroup(groupName: string, userId: number) {
+  // Check if user has access to this group
+  const userRoles = await getUserRoles(userId);
+  const routingGroup = await RoutingGroupsRepository.findOne({
+    where: { group_name: groupName, is_active: true }
+  });
+
+  if (!routingGroup) {
+    throw new Error('Group not found');
+  }
+
+  // Check if user has required role
+  const hasAccess = routingGroup.assigned_role_ids?.some(roleId => 
+    userRoles.includes(roleId)
+  ) || userRoles.includes(routingGroup.default_role_id);
+
+  if (!hasAccess) {
+    throw new Error('Access denied to this group');
+  }
+
+  return await ServiceRequestsRepository.find({
+    where: {
+      group_name: groupName,
+      is_deleted: false
+    },
+    order: { created_at: 'DESC' },
+    relations: ['approvals', 'workflows']
+  });
+}
+```
+
+### 4. Get Requests by Category/Subcategory/Issue Type (Admin View)
+
+```typescript
+async getRequestsByFilters(filters: {
+  service_id?: number;
+  sub_service_id?: number;
+  issue_type_id?: number;
+  group_name?: string;
+  status?: string;
+}) {
+  const query = ServiceRequestsRepository.createQueryBuilder('sr')
+    .where('sr.is_deleted = :isDeleted', { isDeleted: false });
+
+  if (filters.service_id) {
+    query.andWhere('sr.service_id = :serviceId', { serviceId: filters.service_id });
+  }
+  if (filters.sub_service_id) {
+    query.andWhere('sr.sub_service_id = :subServiceId', { subServiceId: filters.sub_service_id });
+  }
+  if (filters.issue_type_id) {
+    query.andWhere('sr.issue_type_id = :issueTypeId', { issueTypeId: filters.issue_type_id });
+  }
+  if (filters.group_name) {
+    query.andWhere('sr.group_name = :groupName', { groupName: filters.group_name });
+  }
+  if (filters.status) {
+    query.andWhere('sr.request_status = :status', { status: filters.status });
+  }
+
+  return await query
+    .orderBy('sr.created_at', 'DESC')
+    .getMany();
+}
+```
+
+---
+
+## Workflow Integration
+
+The existing workflow system already supports routing based on `service_id` and `sub_service_id`. You can extend it to also consider `issue_type_id`:
+
+```typescript
+async getWorkflowHierarchy(serviceId: number, subServiceId: number, issueTypeId?: number) {
+  // Option 1: Use existing workflow (service + sub_service)
+  let workflowDefinition = await WorkflowDefinitionsRepository.findOne({
+    where: {
+      service_id: serviceId,
+      sub_service_id: subServiceId,
+      is_active: true,
+      status: 'published'
+    }
+  });
+
+  // Option 2: If issue_type specific workflow exists, use that
+  if (issueTypeId) {
+    // You could add issue_type_id to WorkflowDefinitions if needed
+    // Or use routing_rules to map to specific workflow
+    const routingRule = await RoutingRulesRepository.findOne({
+      where: {
+        service_id: serviceId,
+        sub_service_id: subServiceId,
+        issue_type_id: issueTypeId,
+        is_active: true
+      }
+    });
+
+    if (routingRule?.workflow_definition_id) {
+      workflowDefinition = await WorkflowDefinitionsRepository.findOne({
+        where: { id: routingRule.workflow_definition_id }
+      });
+    }
+  }
+
+  // Get hierarchy as usual
+  const hierarchy = await WorkflowHierarchyRepository.find({
+    where: {
+      workflow_definition_id: workflowDefinition.id,
+      is_deleted: false
+    },
+    order: { step_order: 'ASC' }
+  });
+
+  return { workflowDefinition, hierarchy };
+}
+```
+
+---
+
+## Recommended Approach
+
+### **Option A: Simple (Recommended for MVP)**
+- Add `issue_type_id`, `issue_type_name`, `group_name` to `ServiceRequestsModel`
+- Create `IssueTypes` table
+- Create `RoutingRules` table (simpler than RoutingGroups)
+- Auto-populate `group_name` using routing rules lookup
+
+### **Option B: Advanced (For Complex Routing)**
+- Everything from Option A
+- Add `RoutingGroups` table for group management
+- Add `assigned_group_id` to requests
+- Support group-based permissions and assignments
+
+---
+
+## Migration Steps
+
+1. **Create new tables**: `issue_types`, `routing_rules` (or `routing_groups`)
+2. **Alter `general_service_requests`**: Add new columns
+3. **Populate master data**: Insert issue types and routing rules
+4. **Update service layer**: Implement auto-population logic
+5. **Update API endpoints**: Add filters for issue_type and group_name
+
+---
+
+## Example Data Structure
+
+### Issue Types
+```
+id | name              | service_id | sub_service_id | is_active
+1  | Hardware Issue    | 5          | 12             | true
+2  | Software Issue    | 5          | 12             | true
+3  | Network Problem   | 5          | 13             | true
+```
+
+### Routing Rules
+```
+id | service_id | sub_service_id | issue_type_id | group_name              | workflow_def_id
+1  | 5          | 12             | 1             | IT-Hardware-Support     | 10
+2  | 5          | 12             | 2             | IT-Software-Support     | 11
+3  | 5          | 12             | null          | IT-General-Support      | 12
+```
+
+### Request Example
+```
+id | user_id | service_id | sub_service_id | issue_type_id | issue_type_name | group_name          | request_status
+1  | 100     | 5          | 12             | 1             | Hardware Issue  | IT-Hardware-Support | Pending
+```
+
+---
+
+## Next Steps
+
+1. Review and approve this schema design
+2. Create the new models in `shared_models/src/models/`
+3. Update `ServiceRequestsModel` with new columns
+4. Create migration scripts
+5. Implement auto-population logic in service layer
+6. Update API endpoints for filtering
+

package/dist/data-source.js

@@ -88,6 +88,13 @@ const UpdateAttendanceRequestModel_1 = require("./models/UpdateAttendanceRequest
 const UpdateAttendanceApprovalModel_1 = require("./models/UpdateAttendanceApprovalModel");
 const UpdateAttendanceChatModel_1 = require("./models/UpdateAttendanceChatModel");
 const UpdateAttendanceWorkflowModel_1 = require("./models/UpdateAttendanceWorkflowModel");
+const IssueTypesModel_1 = require("./models/IssueTypesModel");
+const RoutingGroupsModel_1 = require("./models/RoutingGroupsModel");
+const ServiceRequestsModel_1 = require("./models/ServiceRequestsModel");
+const ServiceApprovalsModel_1 = require("./models/ServiceApprovalsModel");
+const ServiceWorkFlowModel_1 = require("./models/ServiceWorkFlowModel");
+const ServiceAttachmentsModel_1 = require("./models/ServiceAttachmentsModel");
+const ServiceChatsModel_1 = require("./models/ServiceChatsModel");
 exports.AppDataSource = new typeorm_1.DataSource({
     type: 'postgres',
     host: process.env.DB_HOST || 'localhost',
@@ -180,6 +187,13 @@ exports.AppDataSource = new typeorm_1.DataSource({
         UpdateAttendanceRequestModel_1.UpdateAttendanceRequests,
         UpdateAttendanceApprovalModel_1.UpdateAttendanceApprovalDetails,
         UpdateAttendanceChatModel_1.UpdateAttendanceRequestChat,
-        UpdateAttendanceWorkflowModel_1.UpdateAttendanceWorkFlow
+        UpdateAttendanceWorkflowModel_1.UpdateAttendanceWorkFlow,
+        IssueTypesModel_1.IssueTypes,
+        RoutingGroupsModel_1.RoutingGroups,
+        ServiceRequestsModel_1.GeneralServiceRequests,
+        ServiceApprovalsModel_1.GeneralServiceApprovals,
+        ServiceWorkFlowModel_1.GeneralServiceWorkFlow,
+        ServiceAttachmentsModel_1.GeneralServiceAttachments,
+        ServiceChatsModel_1.GeneralServiceChats
     ],
 });

package/dist/index.d.ts

@@ -81,3 +81,10 @@ export * from './models/UpdateAttendanceRequestModel';
 export * from './models/UpdateAttendanceApprovalModel';
 export * from './models/UpdateAttendanceChatModel';
 export * from './models/UpdateAttendanceWorkflowModel';
+export * from './models/IssueTypesModel';
+export * from './models/RoutingGroupsModel';
+export * from './models/ServiceRequestsModel';
+export * from './models/ServiceApprovalsModel';
+export * from './models/ServiceWorkFlowModel';
+export * from './models/ServiceAttachmentsModel';
+export * from './models/ServiceChatsModel';

package/dist/index.js

@@ -97,3 +97,10 @@ __exportStar(require("./models/UpdateAttendanceRequestModel"), exports);
 __exportStar(require("./models/UpdateAttendanceApprovalModel"), exports);
 __exportStar(require("./models/UpdateAttendanceChatModel"), exports);
 __exportStar(require("./models/UpdateAttendanceWorkflowModel"), exports);
+__exportStar(require("./models/IssueTypesModel"), exports);
+__exportStar(require("./models/RoutingGroupsModel"), exports);
+__exportStar(require("./models/ServiceRequestsModel"), exports);
+__exportStar(require("./models/ServiceApprovalsModel"), exports);
+__exportStar(require("./models/ServiceWorkFlowModel"), exports);
+__exportStar(require("./models/ServiceAttachmentsModel"), exports);
+__exportStar(require("./models/ServiceChatsModel"), exports);

package/dist/models/IssueTypesModel.d.ts

@@ -0,0 +1,14 @@
+import { BaseModel } from './BaseModel';
+import { FMServices } from './FMServices';
+import { FMSubServices } from './FMSubservices';
+export declare class IssueTypes extends BaseModel {
+    name: string;
+    description: string | null;
+    service_id: number;
+    service?: FMServices;
+    sub_service_id: number;
+    sub_service?: FMSubServices;
+    is_active: boolean;
+    priority: number | null;
+    constructor(name: string, service_id: number, sub_service_id: number, description?: string, priority?: number | null);
+}

package/dist/models/IssueTypesModel.js

@@ -0,0 +1,66 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueTypes = void 0;
+const typeorm_1 = require("typeorm");
+const BaseModel_1 = require("./BaseModel");
+const FMServices_1 = require("./FMServices");
+const FMSubservices_1 = require("./FMSubservices");
+let IssueTypes = class IssueTypes extends BaseModel_1.BaseModel {
+    constructor(name, service_id, sub_service_id, description, priority) {
+        super();
+        this.name = name;
+        this.service_id = service_id;
+        this.sub_service_id = sub_service_id;
+        this.description = description || null;
+        this.is_active = true;
+        this.priority = priority || null;
+    }
+};
+exports.IssueTypes = IssueTypes;
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', length: 100 }),
+    __metadata("design:type", String)
+], IssueTypes.prototype, "name", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', length: 500, nullable: true }),
+    __metadata("design:type", Object)
+], IssueTypes.prototype, "description", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int' }),
+    __metadata("design:type", Number)
+], IssueTypes.prototype, "service_id", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => FMServices_1.FMServices),
+    (0, typeorm_1.JoinColumn)({ name: 'service_id' }),
+    __metadata("design:type", FMServices_1.FMServices)
+], IssueTypes.prototype, "service", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int' }),
+    __metadata("design:type", Number)
+], IssueTypes.prototype, "sub_service_id", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => FMSubservices_1.FMSubServices),
+    (0, typeorm_1.JoinColumn)({ name: 'sub_service_id' }),
+    __metadata("design:type", FMSubservices_1.FMSubServices)
+], IssueTypes.prototype, "sub_service", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'boolean', default: true }),
+    __metadata("design:type", Boolean)
+], IssueTypes.prototype, "is_active", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Object)
+], IssueTypes.prototype, "priority", void 0);
+exports.IssueTypes = IssueTypes = __decorate([
+    (0, typeorm_1.Entity)({ name: 'issue_types' }),
+    __metadata("design:paramtypes", [String, Number, Number, String, Object])
+], IssueTypes);

package/dist/models/LeaveApprovalsModel.d.ts

@@ -2,7 +2,8 @@ import { BaseModel } from './BaseModel';
 export declare enum ApprovalStatus {
     PENDING = "Pending",
     APPROVED = "Approved",
-    REJECTED = "Rejected"
+    REJECTED = "Rejected",
+    IN_PROGRESS = "In Progress"
 }
 export declare class LeaveApprovalDetails extends BaseModel {
     leave_request_id: number;

package/dist/models/LeaveApprovalsModel.js

@@ -17,6 +17,7 @@ var ApprovalStatus;
     ApprovalStatus["PENDING"] = "Pending";
     ApprovalStatus["APPROVED"] = "Approved";
     ApprovalStatus["REJECTED"] = "Rejected";
+    ApprovalStatus["IN_PROGRESS"] = "In Progress";
 })(ApprovalStatus || (exports.ApprovalStatus = ApprovalStatus = {}));
 //This model is used to store the store the leave apporval details of the user for the leave request
 let LeaveApprovalDetails = class LeaveApprovalDetails extends BaseModel_1.BaseModel {

package/dist/models/RoutingGroupsModel.d.ts

@@ -0,0 +1,19 @@
+import { BaseModel } from './BaseModel';
+import { FMServices } from './FMServices';
+import { FMSubServices } from './FMSubservices';
+import { IssueTypes } from './IssueTypesModel';
+export declare class RoutingGroups extends BaseModel {
+    group_name: string;
+    description: string | null;
+    service_id: number;
+    service?: FMServices;
+    sub_service_id: number;
+    sub_service?: FMSubServices;
+    issue_type_id: number | null;
+    issue_type?: IssueTypes;
+    assigned_role_id: number | null;
+    department_id: number | null;
+    section_id: number | null;
+    is_active: boolean;
+    constructor(group_name: string, service_id: number, sub_service_id: number, issue_type_id?: number | null, assigned_role_id?: number | null, description?: string);
+}