flowchart TD
  subgraph PL["Presentation"]
    V1["KPI Form"]
    V2["KPI Dashboard"]
  end
  subgraph AP["Application (Controllers)"]
    C1["KpiController"]
  end
  subgraph DM["Domain (Services/Workflow)"]
    S1["KpiWorkflowService"]
    S2["PermissionResolver"]
    S3["KpiYearResolver"]
  end
  subgraph DA["Data (Models/Tables)"]
    M1["Kpi (kpi)"]
    M2["Setting (settings)"]
    M3["Employee"]
  end
  subgraph EX["External"]
    X1["Excel Export"]
  end
  V1 --> C1
  V2 --> C1
  C1 --> S1
  C1 --> S2
  S1 --> S3
  S1 --> M1
  S2 --> M1
  S3 --> M2
  M1 --> M3
  C1 --> X1

flowchart LR
  subgraph Controller["KpiController"]
    a1["store()"]
    a2["update(id)"]
    a3["show(role, year)"]
    a4["dashboard()"]
    a5["destroy(id)"]
  end
  subgraph Workflow["KpiWorkflowService"]
    m1["getStatus()"]
    m2["getPermissions(role)"]
    m3["getButtonsForRole()"]
  end
  subgraph Entity["Kpi Model"]
    r1["employee() belongsTo"]
    r2["getKPIYearFromDate()"]
  end
  a1 --> m1
  a2 --> m2
  a3 --> m2
  a4 --> m1
  a2 --> m3
  m1 --> r1
  m2 --> r2

flowchart LR
  Emp["Employee"]
  First["Line Manager"]
  Final["Final Approver"]
  Admin["HR / KPI Admin"]
  subgraph SB["Annual KPI - System Boundary"]
    uc1(["Set Objectives"])
    uc2(["Submit KPI"])
    uc3(["First Evaluation"])
    uc4(["Final Evaluation"])
    uc5(["Return / Cancel"])
    uc6(["View Dashboard"])
    uc7(["Override and Export"])
  end
  Emp --- uc1
  Emp --- uc2
  Emp --- uc6
  First --- uc3
  Final --- uc4
  First --- uc5
  Admin --- uc7
  Admin --- uc6
  uc2 -.->|include| uc1
  uc4 -.->|extend| uc3
  uc5 -.->|extend| uc3

sequenceDiagram
  actor Emp as Employee
  actor Mgr as First Approver
  actor Fin as Final Approver
  participant C as KpiController
  participant S as KpiWorkflowService
  participant DB as kpi table
  Emp->>C: submit objectives + self rating
  C->>S: resolveStatus()
  S->>DB: save Pending First Approval
  Mgr->>C: first evaluation ratings + plan
  C->>S: recordFirstApproval()
  alt manager_count = 1
    S->>DB: set Evaluated
  else manager_count = 2
    S->>DB: set Pending Final Approval
    Fin->>C: final evaluation Toty_Rating
    C->>S: recordFinalApproval()
    S->>DB: set Evaluated
  end
  opt Return to sender
    Mgr->>C: return with reason
    C-->>Emp: notify returned
  end
  DB-->>C: resolved status
  C-->>Emp: updated KPI view

flowchart LR
  E1["Employee"]
  E2["First Approver"]
  E3["Final Approver"]
  E4["HR / KPI Admin"]
  p1(("1.0 Set and Submit"))
  p2(("2.0 First Evaluate"))
  p3(("3.0 Final Evaluate"))
  p4(("4.0 Dashboard and Export"))
  d1[("D1 kpi")]
  d2[("D2 settings")]
  E1 -->|objectives, self rating| p1
  p1 -->|draft / pending| d1
  d2 -->|fiscal window| p1
  E2 -->|per objective ratings| p2
  p2 -->|first summary| d1
  E3 -->|Toty_Rating| p3
  p3 -->|final summary| d1
  d1 -->|status| p4
  p4 -->|report / excel| E4

flowchart LR
  E2["First Approver"]
  p21(("2.1 Open KPI"))
  p22(("2.2 Rate Objectives"))
  p23(("2.3 Development Plan"))
  p24(("2.4 First Summary"))
  p25(("2.5 Resolve Status"))
  d1[("D1 kpi")]
  E2 -->|open assigned KPI| p21
  p21 -->|load record| d1
  d1 -->|objectives| p22
  p22 -->|Review_Manager_Rating| d1
  E2 -->|development inputs| p23
  p23 -->|development fields| d1
  p22 -->|ratings| p24
  p24 -->|First_Approval_Summary_Rating| d1
  p24 --> p25
  p25 -->|pending final / evaluated| d1

classDiagram
  class KpiController {
    +store(Request) Response
    +update(Request, id) Response
    +show(role, year) View
    +dashboard() View
  }
  class WorkflowService {
    <<interface>>
    +resolveStatus(Kpi) string
    +transition(Kpi, action) void
  }
  class KpiWorkflowService {
    +resolveStatus(Kpi) string
    +transition(Kpi, action) void
  }
  class NotificationService {
    <<interface>>
    +notify(Employee, event) void
  }
  class KpiRepository {
    <<interface>>
    +find(id) Kpi
    +save(Kpi) void
  }
  class Kpi {
    +int id
    +string First_Approval
    +string Final_Approval
    +int manager_count
    +float Toty_Rating
    +getStatus() string
    +getPermissions(role) array
  }
  class Employee {
    +int id
    +string empName
  }
  KpiController ..> WorkflowService
  KpiController ..> NotificationService
  KpiController ..> KpiRepository
  KpiWorkflowService ..|> WorkflowService
  KpiWorkflowService --> Kpi
  KpiRepository ..> Kpi
  Kpi "1" --> "1" Employee : belongsTo

flowchart TD
  subgraph PL["Presentation"]
    V1["Mid-KPI Form"]
    V2["Mid-KPI Dashboard"]
  end
  subgraph AP["Application (Controllers)"]
    C1["MidKpiController"]
  end
  subgraph DM["Domain (Services/Workflow)"]
    S1["MidKpiWorkflowService"]
    S2["PermissionResolver"]
    S3["KpiYearResolver"]
  end
  subgraph DA["Data (Models/Tables)"]
    M1["MidKpi (mid_kpi)"]
    M2["Setting (settings)"]
    M3["Employee"]
  end
  subgraph EX["External"]
    X1["Excel Export"]
  end
  V1 --> C1
  V2 --> C1
  C1 --> S1
  C1 --> S2
  S1 --> S3
  S1 --> M1
  S2 --> M1
  S3 --> M2
  M1 --> M3
  C1 --> X1

flowchart LR
  subgraph Controller["MidKpiController"]
    a1["store()"]
    a2["update(id)"]
    a3["show(role, year)"]
    a4["dashboard()"]
    a5["destroy(id)"]
  end
  subgraph Workflow["MidKpiWorkflowService"]
    m1["getStatus()"]
    m2["getPermissions(role)"]
    m3["getButtonsForRole()"]
  end
  subgraph Entity["MidKpi Model"]
    r1["employee() belongsTo"]
    r2["getKPIYearFromDate()"]
  end
  a1 --> m1
  a2 --> m2
  a3 --> m2
  a4 --> m1
  a2 --> m3
  m1 --> r1
  m2 --> r2

flowchart LR
  Emp["Employee"]
  First["Line Manager"]
  Final["Final Approver"]
  Admin["HR / KPI Admin"]
  subgraph SB["Mid-Year KPI - System Boundary"]
    uc1(["Set Mid Objectives"])
    uc2(["Submit Mid-KPI"])
    uc3(["First Evaluation"])
    uc4(["Final Evaluation"])
    uc5(["Return / Cancel"])
    uc6(["View Dashboard"])
  end
  Emp --- uc1
  Emp --- uc2
  Emp --- uc6
  First --- uc3
  Final --- uc4
  First --- uc5
  Admin --- uc6
  uc2 -.->|include| uc1
  uc4 -.->|extend| uc3
  uc5 -.->|extend| uc3

sequenceDiagram
  actor Emp as Employee
  actor Mgr as First Approver
  actor Fin as Final Approver
  participant C as MidKpiController
  participant S as MidKpiWorkflowService
  participant DB as mid_kpi table
  Emp->>C: submit mid objectives + self rating
  C->>S: resolveStatus()
  S->>DB: save Pending First Approval
  Mgr->>C: first evaluation ratings + plan
  C->>S: recordFirstApproval()
  alt manager_count = 1
    S->>DB: set Evaluated
  else manager_count = 2
    S->>DB: set Pending Final Approval
    Fin->>C: final evaluation Toty_Rating
    C->>S: recordFinalApproval()
    S->>DB: set Evaluated
  end
  opt Return to sender
    Mgr->>C: return with reason
    C-->>Emp: notify returned
  end
  DB-->>C: resolved status
  C-->>Emp: updated Mid-KPI view

flowchart LR
  E1["Employee"]
  E2["First Approver"]
  E3["Final Approver"]
  E4["HR / KPI Admin"]
  p1(("1.0 Set and Submit"))
  p2(("2.0 First Evaluate"))
  p3(("3.0 Final Evaluate"))
  p4(("4.0 Mid Dashboard"))
  d1[("D1 mid_kpi")]
  d2[("D2 settings")]
  E1 -->|mid objectives, self rating| p1
  p1 -->|draft / pending| d1
  d2 -->|mid window| p1
  E2 -->|per objective ratings| p2
  p2 -->|first summary| d1
  E3 -->|Toty_Rating| p3
  p3 -->|final summary| d1
  d1 -->|status| p4
  p4 -->|report| E4

flowchart LR
  E3["Final Approver"]
  p31(("3.1 Open Evaluated KPI"))
  p32(("3.2 Review First Summary"))
  p33(("3.3 Set Final Summary"))
  p34(("3.4 Set Toty_Rating"))
  p35(("3.5 Resolve Status"))
  d1[("D1 mid_kpi")]
  E3 -->|open pending final| p31
  p31 -->|load record| d1
  d1 -->|first summary| p32
  p32 -->|final remark| d1
  E3 -->|Final_Summary_Rating| p33
  p33 -->|store| d1
  E3 -->|Toty_Rating| p34
  p34 -->|store| d1
  p34 --> p35
  p35 -->|evaluated| d1

classDiagram
  class MidKpiController {
    +store(Request) Response
    +update(Request, id) Response
    +show(role, year) View
    +dashboard() View
  }
  class WorkflowService {
    <<interface>>
    +resolveStatus(MidKpi) string
    +transition(MidKpi, action) void
  }
  class MidKpiWorkflowService {
    +resolveStatus(MidKpi) string
    +transition(MidKpi, action) void
  }
  class NotificationService {
    <<interface>>
    +notify(Employee, event) void
  }
  class MidKpiRepository {
    <<interface>>
    +find(id) MidKpi
    +save(MidKpi) void
  }
  class MidKpi {
    +int id
    +string First_Approval
    +string Final_Approval
    +int manager_count
    +float Toty_Rating
    +getStatus() string
    +getPermissions(role) array
  }
  class Employee {
    +int id
    +string empName
  }
  MidKpiController ..> WorkflowService
  MidKpiController ..> NotificationService
  MidKpiController ..> MidKpiRepository
  MidKpiWorkflowService ..|> WorkflowService
  MidKpiWorkflowService --> MidKpi
  MidKpiRepository ..> MidKpi
  MidKpi "1" --> "1" Employee : belongsTo

flowchart TD
  subgraph P["Presentation"]
    RequestForm["Certificate Request Form"]
    VerifyView["Public Verification View"]
  end
  subgraph AP["Application (Controllers)"]
    CertCtrl["CertificatesController"]
  end
  subgraph DM["Domain (Services/Workflow)"]
    ReviewWF["Reviewer Stage"]
    ApproveWF["Approver Stage"]
    QrGen["generateQrCode()"]
  end
  subgraph DA["Data (Models/Tables)"]
    CertModel["Certificates (certificate)"]
    TypeModel["CertificatesType (certificate_type)"]
    SnapStore["employee_snapshot (json)"]
  end
  subgraph EX["External"]
    MailSvc["Mail (SMTP)"]
    QrLib["QR Encoder"]
  end
  RequestForm --> CertCtrl
  VerifyView --> CertCtrl
  CertCtrl --> ReviewWF
  CertCtrl --> ApproveWF
  CertCtrl --> QrGen
  ReviewWF --> CertModel
  ApproveWF --> CertModel
  ApproveWF --> SnapStore
  CertModel --> TypeModel
  CertCtrl --> MailSvc
  QrGen --> QrLib

flowchart TD
  subgraph CTRL["CertificatesController"]
    StoreEn["storeEnglishcertificate()"]
    StoreAr["storeArabicCertificate()"]
    RetRev["returncertificatereviewer()"]
    ConfApp["confirm approval"]
    RetApp["returncertificateapproval()"]
  end
  subgraph MODEL["Certificates Model"]
    MyRole["myRole()"]
    Approval["approval()"]
    GenQr["generateQrCode()"]
  end
  StoreEn --> MyRole
  StoreAr --> MyRole
  RetRev --> MyRole
  ConfApp --> Approval
  ConfApp --> GenQr
  RetApp --> MyRole
  GenQr --> QrOut["Encrypted QR URL"]

flowchart LR
  Emp["Employee"]
  Rev["Certificate Reviewer"]
  App["Certificate Approver"]
  Pub["Public Verifier"]
  subgraph SB["Certificate Request - System Boundary"]
    UC1(["Submit Certificate Request"])
    UC2(["Review or Return Request"])
    UC3(["Approve and Finalise"])
    UC4(["Scan QR Code"])
    UC5(["View Read-only Certificate"])
  end
  Emp --- UC1
  Rev --- UC2
  App --- UC3
  Pub --- UC4
  Pub --- UC5
  UC2 -.->|extend| UC3
  UC4 -.->|include| UC5

sequenceDiagram
  actor Emp as Employee
  actor Rev as Reviewer
  actor App as Approver
  participant C as CertificatesController
  participant M as Certificates Model
  participant Mail as Mail SMTP
  Emp->>C: submit request (ref, remark)
  C->>M: create record, status fields null
  C-->>Mail: notify requester and reviewers
  Rev->>C: open pending request
  alt Confirm
    Rev->>M: set review_status ConfirmCertificate
    C-->>Mail: notify approver
    App->>C: confirm approval
    M->>M: freeze employee_snapshot
    C->>M: enable signature, stamp and QR
    App-->>Emp: certificate issued
  else Return
    Rev->>M: set review_status Return To Sender
    C-->>Mail: notify requester
  end

flowchart LR
  Emp["Employee"]
  Rev["Certificate Reviewer"]
  App["Certificate Approver"]
  Pub["Public Verifier"]
  p1(("1.0 Submit Request"))
  p2(("2.0 Review Request"))
  p3(("3.0 Approve and Issue"))
  p4(("4.0 Verify QR"))
  d1[("D1 certificate")]
  d2[("D2 certificate_type")]
  d3[("D3 employee_snapshot")]
  Emp -->|request ref, remark| p1
  p1 -->|new record| d1
  p1 -->|template ref| d2
  Rev -->|confirm or return| p2
  p2 -->|review status| d1
  App -->|approval decision| p3
  p3 -->|frozen snapshot| d3
  p3 -->|issued flag| d1
  Pub -->|scan encrypted id| p4
  d1 -->|certificate data| p4
  p4 -->|read-only view| Pub

flowchart LR
  App["Certificate Approver"]
  Pub["Public Verifier"]
  p31(("3.1 Validate Approval"))
  p32(("3.2 Freeze Snapshot"))
  p33(("3.3 Enable Signature and Stamp"))
  p34(("3.4 Generate QR"))
  d1[("D1 certificate")]
  d3[("D3 employee_snapshot")]
  App -->|approval decision| p31
  p31 -->|approval status| d1
  p31 --> p32
  p32 -->|employee fields json| d3
  p32 --> p33
  p33 --> p34
  p34 -->|encrypted id URL| d1
  d1 -->|verifiable certificate| Pub

classDiagram
  class CertificateWorkflow {
    <<interface>>
    +confirm(id, remark)
    +returnToSender(id, reason)
  }
  class ReviewerStageService {
    +confirm(id, remark)
    +returnToSender(id, reason)
  }
  class ApproverStageService {
    +confirm(id, remark)
    +freezeSnapshot(id)
  }
  class CertificatesController {
    +storeEnglishcertificate(request)
    +storeArabicCertificate(request)
    +returncertificatereviewer(request, id)
    +returncertificateapproval(request, id)
  }
  class Certificates {
    +int id
    +string ref
    +string review_status
    +string approval_status
    +json employee_snapshot
    +myRole()
    +generateQrCode()
  }
  class CertificatesType {
    +int id
    +string type
  }
  class EmployeesCertificate {
    +int id
    +int certificate_id
    +int employee_id
  }
  class Employee {
    +int id
    +string empName
    +int company_id
  }
  CertificateWorkflow <|.. ReviewerStageService
  CertificateWorkflow <|.. ApproverStageService
  CertificatesController ..> CertificateWorkflow
  ReviewerStageService ..> Certificates
  ApproverStageService ..> Certificates
  Certificates "*" --> "1" CertificatesType : certificateType_id
  Certificates "*" --> "1" Employee : Emp_id
  Certificates "1" --> "*" EmployeesCertificate : issues

flowchart TD
  subgraph PR["Presentation"]
    V1["Claim Line-Item Form"]
    V2["Reviewer Console"]
  end
  subgraph AP["Application (Controllers)"]
    C1["ExpensesController.store()"]
    C2["ExpensesController.hrfuncontent()"]
    C3["ExpensesController.exportExpenses()"]
  end
  subgraph DM["Domain (Services/Workflow)"]
    S1["Approval Chain Workflow"]
    S2["Per-Stage JSON Audit"]
  end
  subgraph DA["Data (Models/Tables)"]
    M1["ExpensesRequestsItems"]
    M2["ExpensesDraftItems"]
    M3["Employee"]
  end
  subgraph EX["External"]
    E1["Finance Internal Memo"]
    E2["Excel / ZIP Export"]
  end
  V1 --> C1
  V2 --> C2
  V2 --> C3
  C1 --> S1
  C2 --> S1
  S1 --> S2
  C1 --> M2
  S1 --> M1
  S2 --> M1
  M1 --> M3
  S1 --> E1
  C3 --> E2

flowchart TD
  A["ExpensesController.store()"] --> B{"isdraft?"}
  B -->|"yes"| C["Persist ExpensesDraftItems"]
  B -->|"no"| D["Create ExpensesRequestsItems"]
  D --> E["Set stage = hr_checked"]
  E --> F["Set status = pending"]
  F --> G["hrfuncontent() reviewer action"]
  G --> H{"decision"}
  H -->|"approve"| I["Advance stage & append JSON remark"]
  H -->|"reject"| J["status = rejected + reason"]
  H -->|"send back"| K["Move to preceding stage"]
  I --> L["updateexpensesfun() amend amount / cost center"]

flowchart LR
  EMP["Employee"]
  HRC["HR Checked"]
  DIR["HR Director"]
  FIN["Finance"]
  subgraph SB["HR Expenses - System Boundary"]
    U1(["Submit Expense Claim"])
    U2(["Save Draft"])
    U3(["Review & Approve"])
    U4(["Reject With Reason"])
    U5(["Send Back One Stage"])
    U6(["Finance Memo Remark"])
    U7(["Export Excel / ZIP"])
  end
  EMP --- U1
  EMP --- U2
  HRC --- U3
  DIR --- U3
  HRC --- U4
  HRC --- U5
  FIN --- U6
  FIN --- U7
  U1 -.->|"include"| U3
  U3 -.->|"extend"| U5

sequenceDiagram
  actor EMP as Employee
  participant C as ExpensesController
  participant W as ApprovalWorkflow
  participant M as ExpensesRequestsItems
  participant FIN as Finance
  EMP->>C: submit claim with attachment
  C->>M: create item stage hr_checked status pending
  loop HR approval chain
    C->>W: reviewer decision
    alt approve
      W->>M: advance stage and append JSON audit
    else send back
      W->>M: move to preceding stage
    else reject
      W-->>EMP: status rejected with reason
    end
  end
  W->>M: status approval stage hr_internalmemeofinance
  FIN->>C: attach memo remark
  C->>M: status approved
  C-->>FIN: internal memo generated

flowchart LR
  EMP["Employee"]
  REV["HR / Finance Reviewers"]
  p1(("1.0 Capture Claim"))
  p2(("2.0 Route Approval Chain"))
  p3(("3.0 Finance Memo"))
  p4(("4.0 Reports & Export"))
  d1[("D1 employee_expenses_draft_items")]
  d2[("D2 employee_expenses_requests_items")]
  EMP -->|"claim line items"| p1
  p1 -->|"draft"| d1
  p1 -->|"submitted item"| d2
  REV -->|"decisions"| p2
  p2 -->|"stage + JSON audit"| d2
  d2 -->|"approved item"| p3
  p3 -->|"memo remark"| d2
  d2 -->|"records"| p4
  p4 -->|"Excel / ZIP"| REV

flowchart LR
  REV["HR / Finance Reviewers"]
  d2[("D2 employee_expenses_requests_items")]
  p21(("2.1 Validate Stage Access"))
  p22(("2.2 Approve & Advance Stage"))
  p23(("2.3 Reject With Reason"))
  p24(("2.4 Send Back One Stage"))
  p25(("2.5 Amend Amount / Cost Center"))
  p26(("2.6 Append JSON Audit"))
  REV -->|"reviewer action"| p21
  p21 -->|"approve"| p22
  p21 -->|"reject"| p23
  p21 -->|"send back"| p24
  p21 -->|"amend"| p25
  p22 -->|"next stage"| d2
  p23 -->|"status rejected"| d2
  p24 -->|"preceding stage"| d2
  p25 -->|"preserve prior value"| d2
  p22 --> p26
  p26 -->|"per-stage remark"| d2

classDiagram
  class ApprovalWorkflow {
    <<interface>>
    +approve(item, stage)
    +reject(item, reason)
    +sendBack(item)
    +amend(item, field, value)
  }
  class ExpensesChainWorkflow {
    +approve(item, stage)
    +reject(item, reason)
    +sendBack(item)
    +amend(item, field, value)
  }
  class ExpensesController {
    +store(request, stage, isdraft)
    +hrfuncontent(request, page, time)
    +updateexpensesfun(request)
    +exportExpenses(request, page, time)
  }
  class ExpensesRequestsItems {
    +int id
    +int employee_id
    +string entailment_type
    +string cost_center
    +int amount_cents
    +string stage
    +string status
    +json remarks
    +employee()
  }
  class ExpensesDraftItems {
    +int id
    +int employee_id
    +string invoice_number
    +employee()
  }
  class Employee {
    +int id
    +string name
    +int company_id
  }
  ApprovalWorkflow <|.. ExpensesChainWorkflow
  ExpensesController ..> ApprovalWorkflow
  ExpensesChainWorkflow ..> ExpensesRequestsItems
  ExpensesController ..> ExpensesDraftItems
  ExpensesRequestsItems "1" --> "1" Employee
  ExpensesDraftItems "*" --> "1" Employee

flowchart TD
  subgraph PRES["Presentation"]
    UI["Leave Request Form and Leaves Center"]
    SHOW["Leave Show Page"]
  end
  subgraph APPL["Application (Controllers)"]
    LC["LeavesController"]
    LSC["LeaveStagesController"]
  end
  subgraph DOM["Domain (Services / Workflow)"]
    LMS["LeaveMailService"]
    LSS["LeaveStatusService"]
    LCA["LeaveShowCacheService"]
  end
  subgraph DAT["Data (Models / Tables)"]
    LV["Leave (leaves)"]
    LST["LeaveStage (user_leaves_stages)"]
    LT["LeaveType (leave_types)"]
    EL["EmployeeLeave (employee_leaves)"]
  end
  subgraph EXT["External (Mail, Scheduler)"]
    MAIL["SMTP Mail"]
    CRON["Travel Reminder Scheduler"]
  end
  UI --> LC
  SHOW --> LSC
  LC --> LSC
  LC --> LSS
  LSC --> LMS
  LSC --> LCA
  LC --> LV
  LSC --> LST
  LMS --> MAIL
  CRON --> LMS
  LV --> LT
  LV --> EL

flowchart TD
  STORE["store(status action)"]
  GUARD["HR-only guard and validateHandoverData"]
  UPD["updateStage"]
  PROG["handleWorkflowProgression"]
  ANS["activateNextStage (skip not_applicable)"]
  MAD["ensureManagerApprovalDecisionExists"]
  BTS["backToSender (snapshot and restore)"]
  GATE{"clearanceEmailsAllowed?"}
  CLR["Activate parallel clearance stages"]
  EMAIL["sendEmailNotifications"]
  DEDUCT["Deduct balance on JoiningReportManagementApproval"]
  CACHE["Invalidate LeaveShowCache"]
  STORE --> GUARD
  GUARD --> UPD
  UPD --> PROG
  PROG --> ANS
  PROG --> MAD
  PROG -->|"return"| BTS
  ANS --> GATE
  GATE -->|"yes"| CLR
  GATE -->|"no"| EMAIL
  CLR --> EMAIL
  ANS -->|"final report approved"| DEDUCT
  PROG --> CACHE

flowchart LR
  EMP["Employee / Applicant"]
  MGR["Line / Senior Manager"]
  HR["HR / Employee Relations"]
  CLRO["Clearance Officer"]
  FIN["Final Approver"]
  ADM["Leaves Admin"]
  SCH["Scheduler"]
  subgraph BND["Leaves - System Boundary"]
    U1(["Submit leave request"])
    U2(["Approve manager stage"])
    U3(["HR approval and clearance setup"])
    U4(["Handover Decision"])
    U5(["Departmental clearance"])
    U6(["Final approval"])
    U7(["Return or reject request"])
    U8(["Admin search / edit / export"])
    U9(["Send travel reminder"])
  end
  EMP --- U1
  EMP --- U4
  MGR --- U2
  HR --- U3
  CLRO --- U5
  FIN --- U6
  MGR --- U7
  ADM --- U8
  SCH --- U9
  U3 -.->|"include"| U5
  U9 -.->|"extend"| U5

sequenceDiagram
  actor EMP as Employee
  participant LC as LeavesController
  participant LSC as LeaveStagesController
  participant MS as LeaveMailService
  participant DB as MySQL
  EMP->>LC: store(leave request)
  LC->>DB: persist leave and first stage
  LC->>MS: sendActionNotification(submitted)
  MS-->>EMP: submission email
  loop Manager approval chain
    EMP->>LSC: store(approved)
    LSC->>DB: mark stage resolved and activate next
    LSC->>MS: sendActionNotification(approved)
    MS-->>EMP: stage-change email
  end
  opt HR and Handover Decision
    LSC->>DB: EmployeeRelation, HrApproval, ManagerApprovalDecision
  end
  alt Clearance allowed
    LSC->>MS: sendActionNotification(clearance)
    MS->>MS: clearanceEmailsAllowed gate
    MS-->>CLRO: clearance emails
  else Returned or rejected
    LSC->>DB: backToSender or rejected
    LSC->>MS: sendActionNotification(returned)
    MS-->>EMP: return notice
  end
  opt Final approval and deduction
    EMP->>LSC: store(JoiningReportManagementApproval approved)
    LSC->>DB: deduct employee_leaves balance
  end

flowchart LR
  EMP["Employee"]
  MGR["Manager"]
  HR["HR"]
  CLRO["Clearance Officer"]
  SCH["Scheduler"]
  P1(("1.0 Submit Request"))
  P2(("2.0 Route Approvals"))
  P3(("3.0 Handover Decision"))
  P4(("4.0 Clearance"))
  P5(("5.0 Finalize and Deduct Balance"))
  P6(("6.0 Notify"))
  D1[("D1 leaves")]
  D2[("D2 user_leaves_stages")]
  D3[("D3 employee_leaves")]
  D4[("D4 leave_types")]
  EMP -->|"request details"| P1
  P1 -->|"leave record"| D1
  P1 -->|"read type"| D4
  MGR -->|"approval"| P2
  P2 -->|"stage rows"| D2
  HR -->|"clearance setup"| P2
  EMP -->|"handover choice"| P3
  P3 --> P4
  CLRO -->|"signoff"| P4
  P4 --> P5
  P5 -->|"deduct days"| D3
  P2 --> P6
  SCH -->|"daily trigger"| P6
  P6 -->|"emails"| EMP

flowchart LR
  MGR["Manager"]
  HR["HR"]
  APP["Applicant"]
  CLRO["Clearance Officer"]
  FIN["Final Approver"]
  P21(("2.1 Manager Chain"))
  P22(("2.2 HR / Employee Relation"))
  P23(("2.3 Handover Decision"))
  P24(("2.4 Parallel Clearance"))
  P25(("2.5 Final Approvals"))
  D1[("D1 leaves")]
  D2[("D2 user_leaves_stages")]
  MGR -->|"approve level"| P21
  P21 -->|"chain done"| P22
  HR -->|"set clearance and ticket"| P22
  P22 -->|"create decision"| P23
  APP -->|"has handover"| P23
  P23 -->|"gate open"| P24
  CLRO -->|"department signoff"| P24
  P24 -->|"all cleared"| P25
  FIN -->|"admin / hr-final / immigration"| P25
  P21 --> D2
  P24 --> D2
  P25 -->|"approved"| D1

classDiagram
  class LeaveWorkflowStage {
    <<interface>>
    +activateNextStage()
    +handleWorkflowProgression()
    +backToSender()
  }
  class LeaveNotifier {
    <<interface>>
    +sendActionNotification(stage, action)
    +clearanceEmailsAllowed(leave) bool
  }
  class LeaveBalanceCalculator {
    <<interface>>
    +available(employee, type) int
    +deduct(leave)
  }
  class LeavesController {
    +store(request)
    +index(request)
    +export(request)
  }
  class LeaveStagesController {
    +store(request)
    -updateStage()
    -activateNextStage()
  }
  class LeaveMailService {
    +sendActionNotification(stage, action)
    -clearanceEmailsAllowed(leave)
  }
  class Leave {
    +int id
    +int leave_type_id
    +int employee_id
    +json extraInfo
    +string status
  }
  class LeaveStage {
    +int id
    +int leave_id
    +string stage_name
    +string status
    +json extraInfo
  }
  class LeaveType {
    +int id
    +string name
    +int quantity
  }
  class EmployeeLeave {
    +int employee_id
    +int leave_type
    +int leave_days
  }
  LeaveStagesController ..|> LeaveWorkflowStage
  LeaveMailService ..|> LeaveNotifier
  LeaveStagesController ..|> LeaveBalanceCalculator
  LeavesController ..> LeaveWorkflowStage
  LeavesController ..> LeaveNotifier
  LeavesController ..> LeaveBalanceCalculator
  Leave "1" --> "many" LeaveStage : has
  Leave "many" --> "1" LeaveType : categorized
  LeaveType "1" --> "many" EmployeeLeave : allocates
  Leave "many" --> "1" EmployeeLeave : consumes

flowchart TD
  subgraph PR["Presentation"]
    V1["Designation Catalogue Form"]
    V2["JD Review Console"]
  end
  subgraph AP["Application (Controllers)"]
    C1["DesignationController.store()"]
    C2["DesignationController.reviewDesignation()"]
    C3["UserDesignationsController.import()"]
  end
  subgraph DM["Domain (Services/Workflow)"]
    S1["JD Review Workflow"]
    S2["Grade / Seniority Feed"]
  end
  subgraph DA["Data (Models/Tables)"]
    M1["Designation"]
    M2["DesignationReview"]
    M3["UserDesignation"]
  end
  subgraph EX["External"]
    E1["Performance Review Grade"]
    E2["Excel Designation Import"]
  end
  V1 --> C1
  V2 --> C2
  C3 --> E2
  C1 --> M1
  C2 --> S1
  S1 --> M2
  S1 --> M1
  M1 --> S2
  S2 --> E1
  C1 --> M3
  M2 --> M1

flowchart TD
  A["DesignationController.store()"] --> B["Create / Update Designation"]
  B --> C["Create DesignationReview status Pending(0)"]
  C --> D["reviewDesignation() reviewer action"]
  D --> E{"decision"}
  E -->|"approve"| F["status Approved(1)"]
  F --> G["Designation fields updated"]
  E -->|"reject"| H["status Rejected(2) + rejected_cause"]
  E -->|"send back"| I["status Back to Sender(3)"]
  I --> J["Sender revises & resubmits"]
  J --> C
  G --> K["Capture review fields"]

flowchart LR
  EMP["Employee"]
  REV["Job-Description Reviewer"]
  ADM["Administrator"]
  HR["HR"]
  subgraph SB["Job Description - System Boundary"]
    U1(["Submit Job Description"])
    U2(["Review Job Description"])
    U3(["Approve Designation"])
    U4(["Reject With Cause"])
    U5(["Send Back To Sender"])
    U6(["Revise & Resubmit"])
    U7(["Import Designations Excel"])
  end
  EMP --- U1
  EMP --- U6
  REV --- U2
  REV --- U3
  REV --- U4
  REV --- U5
  ADM --- U7
  HR --- U2
  U2 -.->|"include"| U3
  U5 -.->|"extend"| U6

sequenceDiagram
  actor EMP as Sender
  participant C as DesignationController
  participant W as ReviewWorkflow
  participant DR as DesignationReview
  participant D as Designation
  EMP->>C: submit JD summary qualifications responsibilities
  C->>DR: create review status Pending
  C->>W: reviewDesignation decision
  alt approve
    W->>DR: status Approved(1)
    W->>D: update designation fields
  else reject
    W->>DR: status Rejected(2) with rejected_cause
  else send back
    W->>DR: status Back to Sender(3)
    W-->>EMP: return for revision
    EMP->>C: revise and resubmit as Pending
  end
  D-->>C: approved designation feeds grade

flowchart LR
  SND["Sender (Employee)"]
  REV["JD Reviewer"]
  ADM["Administrator"]
  p1(("1.0 Submit Job Description"))
  p2(("2.0 Review Decision"))
  p3(("3.0 Update Catalogue"))
  p4(("4.0 Grade / Seniority Feed"))
  d1[("D1 designations")]
  d2[("D2 designation_review")]
  SND -->|"JD content"| p1
  p1 -->|"review record"| d2
  REV -->|"decision"| p2
  p2 -->|"status + rejected_cause"| d2
  p2 -->|"approved fields"| p3
  p3 -->|"designation"| d1
  d1 -->|"class prefix + designation"| p4
  ADM -->|"Excel import"| p3

flowchart LR
  REV["JD Reviewer"]
  d1[("D1 designations")]
  d2[("D2 designation_review")]
  p21(("2.1 Load Pending Review"))
  p22(("2.2 Capture Review Fields"))
  p23(("2.3 Approve Designation"))
  p24(("2.4 Reject With Cause"))
  p25(("2.5 Send Back To Sender"))
  REV -->|"open review"| p21
  p21 -->|"pending record"| d2
  p21 --> p22
  p22 -->|"approve"| p23
  p22 -->|"reject"| p24
  p22 -->|"send back"| p25
  p23 -->|"update fields"| d1
  p23 -->|"status Approved(1)"| d2
  p24 -->|"status Rejected(2)"| d2
  p25 -->|"status Back to Sender(3)"| d2

classDiagram
  class ReviewWorkflow {
    <<interface>>
    +submit(designation)
    +approve(review)
    +reject(review, cause)
    +sendBack(review)
  }
  class DesignationReviewWorkflow {
    +submit(designation)
    +approve(review)
    +reject(review, cause)
    +sendBack(review)
  }
  class DesignationController {
    +store(request)
    +reviewDesignation(request)
    +index(request)
    +destroy(id)
  }
  class Designation {
    +int id
    +int company_id
    +string name
    +text job_summary
    +text qualifications_for_position
    +text responsibilities
    +company()
    +reviews(status)
  }
  class DesignationReview {
    +int id
    +int sender_id
    +int designation_id
    +text job_summary_review
    +text qualifications_review
    +text responsibilities_review
    +json rejected_cause
    +int status
    +designation()
    +sender()
  }
  class Company {
    +int id
    +string name
  }
  class Employee {
    +int id
    +string name
  }
  ReviewWorkflow <|.. DesignationReviewWorkflow
  DesignationController ..> ReviewWorkflow
  DesignationReviewWorkflow ..> DesignationReview
  Designation "1" --> "*" DesignationReview
  DesignationReview "*" --> "1" Employee
  Designation "*" --> "1" Company

flowchart TD
  subgraph PL["Presentation"]
    V1["Campaign Setup"]
    V2["Rater Form"]
    V3["Aggregated Report"]
  end
  subgraph AP["Application (Controllers)"]
    C1["DegreeController"]
  end
  subgraph DM["Domain (Services/Workflow)"]
    S1["EncryptedLinkService"]
    S2["ResponseValidator"]
    S3["StatsAggregator"]
  end
  subgraph DA["Data (Models/Tables)"]
    M1["ManagerEvaluation"]
    M2["ManagerEvaluationQuestions"]
    M3["Employee"]
  end
  subgraph EX["External"]
    X1["PDF Generator"]
    X2["Mail (rater links)"]
  end
  V1 --> C1
  V2 --> C1
  V3 --> C1
  C1 --> S1
  C1 --> S2
  C1 --> S3
  S1 --> X2
  S2 --> M2
  S3 --> M2
  M2 --> M1
  M1 --> M3
  C1 --> X1

flowchart LR
  subgraph Controller["DegreeController"]
    a1["generateEncryptedLink(ids)"]
    a2["showFirstForm(token, page)"]
    a3["storequestions(req, ids)"]
    a4["show(id, page)"]
    a5["downloadAllFeedback(id)"]
  end
  subgraph Link["EncryptedLinkService"]
    m1["encrypt(payload)"]
    m2["verify(token)"]
    m3["checkExpiry(7 days)"]
  end
  subgraph Stats["StatsAggregator"]
    s1["calculateAllStats(id)"]
    s2["getRatingCounts(column)"]
  end
  a1 --> m1
  a2 --> m2
  m2 --> m3
  a3 --> s2
  a4 --> s1
  a5 --> s1
  s1 --> s2

flowchart LR
  HR["HR"]
  Rater["360 Rater"]
  Mgr["Manager (Subject)"]
  subgraph SB["360 Feedback - System Boundary"]
    uc1(["Launch Campaign"])
    uc2(["Issue Rater Links"])
    uc3(["Open Invitation"])
    uc4(["Submit Likert Answers"])
    uc5(["View Distribution"])
    uc6(["Download 360 PDF"])
  end
  HR --- uc1
  HR --- uc5
  HR --- uc6
  Rater --- uc3
  Rater --- uc4
  Mgr --- uc5
  uc1 -.->|include| uc2
  uc3 -.->|include| uc4
  uc6 -.->|extend| uc5

sequenceDiagram
  actor HR as HR
  actor Rater as 360 Rater
  participant C as DegreeController
  participant L as EncryptedLinkService
  participant DB as manager_evaluation
  HR->>C: launch campaign with rater list
  C->>DB: create ManagerEvaluation
  loop each rater
    C->>L: generateEncryptedLink(ids)
    L-->>Rater: unique link expires 7 days
  end
  Rater->>C: open invitation token
  C->>L: verify(token)
  alt expired or already submitted
    L-->>Rater: blocked page
  else valid link
    L-->>C: decrypted payload
    Rater->>C: submit 20 Likert answers
    C->>DB: store questions
  end
  HR->>C: view report(id)
  C->>DB: aggregate distribution
  C-->>HR: distribution and PDF

flowchart LR
  E1["HR"]
  E2["360 Rater"]
  E3["Manager"]
  p1(("1.0 Launch Campaign"))
  p2(("2.0 Issue Links"))
  p3(("3.0 Collect Responses"))
  p4(("4.0 Aggregate Report"))
  d1[("D1 manager_evaluation")]
  d2[("D2 manager_evaluation_questions")]
  E1 -->|manager + rater list| p1
  p1 -->|campaign record| d1
  d1 -->|rater ids| p2
  p2 -->|unique link| E2
  E2 -->|20 Likert answers| p3
  p3 -->|responses| d2
  d2 -->|ratings| p4
  p4 -->|distribution + PDF| E1
  p4 -->|summary| E3

flowchart LR
  E2["360 Rater"]
  p31(("3.1 Verify Token"))
  p32(("3.2 Check Expiry"))
  p33(("3.3 Check Submitted"))
  p34(("3.4 Render Form"))
  p35(("3.5 Store Answers"))
  d2[("D2 manager_evaluation_questions")]
  E2 -->|token| p31
  p31 -->|decrypted ids| p32
  p32 -->|within 7 days| p33
  d2 -->|prior submission| p33
  p33 -->|not submitted| p34
  E2 -->|15 manager + 5 self answers| p35
  p34 --> p35
  p35 -->|Likert 1-5 rows| d2

classDiagram
  class DegreeController {
    +store(Request) Response
    +generateEncryptedLink(evaluateId, manId, empId) string
    +showFirstForm(token, page) View
    +storequestions(req, ids) Response
    +downloadAllFeedback(id) Pdf
  }
  class LinkService {
    <<interface>>
    +issue(payload) string
    +verify(token) array
  }
  class EncryptedLinkService {
    +issue(payload) string
    +verify(token) array
    +isExpired(createdAt) bool
  }
  class ReportService {
    <<interface>>
    +aggregate(evaluationId) array
    +export(evaluationId) Pdf
  }
  class StatsAggregator {
    +aggregate(evaluationId) array
    +getRatingCounts(column) array
  }
  class ManagerEvaluation {
    +int id
    +int employee_id
    +string manager_name
    +employee() Employee
  }
  class ManagerEvaluationQuestions {
    +int id
    +int manager_evaluate_id
    +int rating
    +employee() Employee
  }
  DegreeController ..> LinkService
  DegreeController ..> ReportService
  EncryptedLinkService ..|> LinkService
  StatsAggregator ..|> ReportService
  ManagerEvaluation "1" --> "0..*" ManagerEvaluationQuestions : has
  ManagerEvaluation "1" --> "1" Employee : subject

flowchart TD
  subgraph Presentation
    V1["Confirmation Views (index/show)"]
    V2["Create Request Form"]
  end
  subgraph Application["Application (Controllers)"]
    C1["EmploymentConfirmationController"]
  end
  subgraph Domain["Domain (Services/Workflow)"]
    S1["Approval Chain Workflow"]
    S2["EmploymentProbationExport"]
    S3["Confirmation Letter PDF"]
  end
  subgraph Data["Data (Models/Tables)"]
    M1["EmploymentConfirmationRequest"]
    M2["EmploymentConfirmationFirstApproval"]
    M3["EmploymentConfirmationNextApproval"]
    M4["EmploymentConfirmationReturn"]
    M5["Employee"]
  end
  subgraph External
    SCH["Scheduler (cron 09:00)"]
    MAIL["Mail (SMTP)"]
  end
  V1 --> C1
  V2 --> C1
  C1 --> S1
  C1 --> S2
  C1 --> S3
  S1 --> M1
  S1 --> M2
  S1 --> M3
  S1 --> M4
  M1 --> M5
  SCH --> C1
  S1 --> MAIL

flowchart LR
  subgraph EmploymentConfirmationController
    m1["store()"]
    m2["storeFirstApproval()"]
    m3["storeNextApproval()"]
    m4["return()"]
    m5["sendEmail()"]
    m6["downloadconfirmationletter()"]
  end
  m1 -->|"status = Pending 1st Approval"| R["EmploymentConfirmationRequest"]
  m2 -->|"Confirm/Extend + next"| FA["EmploymentConfirmationFirstApproval"]
  m3 -->|"type 2nd/3rd/4th/HR"| NA["EmploymentConfirmationNextApproval"]
  m4 -->|"Return to stage"| RET["EmploymentConfirmationReturn"]
  m3 -->|"letter_count + 1"| R
  m6 --> PDF["Confirmation Letter PDF"]
  m5 --> MAIL["Mail Notification"]

flowchart LR
  Emp["Employee"]
  A1["1st Approver"]
  AN["2nd/3rd/4th Approver"]
  HRR["HR Review"]
  HRD["HR Director"]
  SCH["Scheduler"]
  subgraph SB["Employment Probation - System Boundary"]
    uc8(["Send Probation Reminder"])
    uc1(["Submit Confirmation Request"])
    uc2(["Evaluate Probation"])
    uc4(["Resubmit Employee Review"])
    uc5(["HR Review Decision"])
    uc6(["Final Confirm or Extend"])
    uc7(["Generate Decision Letter"])
  end
  SCH --- uc8
  Emp --- uc1
  Emp --- uc4
  A1 --- uc2
  AN --- uc2
  HRR --- uc5
  HRD --- uc6
  HRD --- uc7
  uc8 -.->|"triggers"| uc1
  uc6 -.->|"include"| uc7

sequenceDiagram
    participant SCH as Scheduler
    participant EMP as Employee
    participant CTRL as ConfirmationController
    participant DB as Confirmation Models
    participant MAIL as Mail Service
    SCH->>MAIL: send Probation Request after 60 days
    MAIL-->>EMP: Probation Request email
    EMP->>CTRL: store() JD details + 1st approver
    CTRL->>DB: create Request (Pending 1st Approval)
    CTRL->>MAIL: notify 1st approver
    loop Approval chain 1st to 4th
        CTRL->>DB: storeFirstApproval / storeNextApproval
        alt Confirm and next approver
            CTRL->>MAIL: notify next approver
        else Return to prior stage
            CTRL->>DB: create Return record
            CTRL->>MAIL: notify prior stage
        end
    end
    CTRL->>DB: Pending HR Review then HR Director
    CTRL->>DB: Approved and letter_count incremented
    CTRL-->>EMP: confirmation or extension letter

flowchart LR
  E1["Employee"]
  E2["Approvers"]
  E3["HR and HR Director"]
  E4["Scheduler"]
  p1(("1.0 Send Reminder"))
  p2(("2.0 Submit Request"))
  p3(("3.0 Run Approval Chain"))
  p4(("4.0 HR Decision"))
  p5(("5.0 Issue Letter and Report"))
  d1[("D1 Confirmation Requests")]
  d2[("D2 Approvals")]
  d4[("D4 Employee Master")]
  E4 --> p1
  p1 -->|"Probation Request"| E1
  E1 -->|"JD + 1st approver"| p2
  p2 --> d1
  p2 --> p3
  E2 -->|"Confirm/Extend"| p3
  p3 --> d2
  p3 --> p4
  E3 -->|"final decision"| p4
  p4 --> d1
  p4 --> p5
  p5 -->|"decision letter"| E1
  d4 --> p5

flowchart LR
  E1["Employee"]
  E2["1st Approver"]
  E3["Next Approver"]
  E4["HR Review"]
  p31(("3.1 First Approval"))
  p32(("3.2 Next Approvals 2nd-4th"))
  p33(("3.3 Employee Review"))
  p34(("3.4 Route to HR Review"))
  p35(("3.5 Return Handling"))
  d1[("D1 Confirmation Requests")]
  d2[("D2 Approvals")]
  d3[("D3 Returns")]
  E2 --> p31
  p31 -->|"next approver"| p32
  E3 --> p32
  p32 --> p33
  E1 --> p33
  p33 --> p34
  E4 --> p34
  p31 --> d2
  p32 --> d2
  p34 --> d1
  p35 --> d3
  p33 -.->|"return"| p35
  p34 -.->|"return"| p35

classDiagram
    class ApprovalWorkflow {
        <<interface>>
        +submitRequest()
        +evaluateStage()
        +routeNext()
    }
    class NotificationService {
        <<interface>>
        +notify()
    }
    class LetterGenerator {
        <<interface>>
        +generate()
    }
    class EmploymentConfirmationController {
        +store()
        +storeFirstApproval()
        +storeNextApproval()
        +return()
    }
    class ChainApprovalWorkflow {
        +evaluateStage()
        +routeNext()
    }
    class MailNotificationService {
        +notify()
    }
    class PdfLetterGenerator {
        +generate()
    }
    class EmploymentConfirmationRequest {
        +int id
        +string status
        +json job_description_details
        +int next_approval_employee_id
    }
    class EmploymentConfirmationFirstApproval {
        +int id
        +string evaluation
        +string status
    }
    class EmploymentConfirmationNextApproval {
        +int id
        +string type
        +string evaluation
        +int letter_count
    }
    class EmploymentConfirmationReturn {
        +int id
        +string status
        +string reasons
    }
    class Employee {
        +int id
        +string empName
        +date joiningDate
    }
    EmploymentConfirmationController ..> ApprovalWorkflow
    EmploymentConfirmationController ..> NotificationService
    EmploymentConfirmationController ..> LetterGenerator
    ChainApprovalWorkflow ..|> ApprovalWorkflow
    MailNotificationService ..|> NotificationService
    PdfLetterGenerator ..|> LetterGenerator
    Employee "1" --> "0..*" EmploymentConfirmationRequest
    EmploymentConfirmationRequest "1" --> "1" EmploymentConfirmationFirstApproval
    EmploymentConfirmationRequest "1" --> "0..*" EmploymentConfirmationNextApproval
    EmploymentConfirmationRequest "1" --> "0..*" EmploymentConfirmationReturn

flowchart TD
  subgraph P["Presentation"]
    ResForm["Resignation Form"]
    ExitForm["Public Exit Interview Form"]
    ListView["Resignation List View"]
  end
  subgraph AP["Application (Controllers)"]
    ResCtrl["ResignationController"]
  end
  subgraph DM["Domain (Services/Workflow)"]
    Policy["ResignationRequestPolicy"]
    ApprovalChain["Dynamic Approval Chain"]
    HrPipeline["HR Stage Pipeline"]
    MailSvc["ResignationMailService"]
  end
  subgraph DA["Data (Models/Tables)"]
    ResModel["ResignationRequest"]
    StagesJson["stages (json)"]
    FormJson["form_data (json)"]
  end
  subgraph EX["External"]
    Mail["Mail (SMTP)"]
  end
  ResForm --> ResCtrl
  ExitForm --> ResCtrl
  ListView --> ResCtrl
  ResCtrl --> Policy
  ResCtrl --> ApprovalChain
  ResCtrl --> HrPipeline
  ResCtrl --> MailSvc
  ApprovalChain --> ResModel
  HrPipeline --> ResModel
  ResModel --> StagesJson
  ResModel --> FormJson
  MailSvc --> Mail

flowchart TD
  subgraph CTRL["ResignationController"]
    Store["store(request)"]
    Show["show(id)"]
    UpdStatus["updateStatus(request, id)"]
    ExitPub["showExitInterviewPublic(token)"]
  end
  UpdStatus --> Decide{"stage action"}
  Decide -->|approve| Next["advance stage"]
  Decide -->|return| Back["return to sender"]
  Decide -->|reject| Rej["reject request"]
  Next --> Archive["archive approval_N"]
  Next --> Route["route to HR shortcut"]
  Archive --> Persist["save stages and form_data"]
  Route --> Persist

flowchart LR
  Emp["Employee"]
  Mgr["Manager"]
  Hr["HR Employee Relations"]
  Ext["Exit Interviewee"]
  subgraph SB["Resignation - System Boundary"]
    UC1(["Submit Resignation"])
    UC2(["Complete Exit Interview"])
    UC3(["Approve or Return or Reject"])
    UC4(["Route to HR"])
    UC5(["Process HR Stages"])
    UC6(["Track Approval Trail"])
  end
  Emp --- UC1
  Emp --- UC6
  Mgr --- UC3
  Mgr --- UC4
  Hr --- UC5
  Ext --- UC2
  UC1 -.->|include| UC2
  UC3 -.->|extend| UC4
  UC5 -.->|include| UC6

sequenceDiagram
  actor Emp as Employee
  actor Mgr as Manager
  actor Hr as HR Relations
  participant C as ResignationController
  participant R as ResignationRequest
  participant Mail as ResignationMailService
  Emp->>C: submit resignation (form_data)
  C->>R: create (current_stage approval)
  C->>Mail: notify next manager
  loop Manager chain
    Mgr->>C: review request
    alt Approve to next manager
      C->>R: archive approval_N, set next_approval
      C->>Mail: notify next approver
    else Route to HR
      C->>R: set current_stage hr_check
    else Return or Reject
      C->>R: update status
      C->>Mail: notify employee
    end
  end
  Hr->>C: process HR stages
  C->>R: hr_check through hr_director to completed
  C-->>Emp: resignation completed

flowchart LR
  Emp["Employee"]
  Mgr["Manager"]
  Hr["HR Relations"]
  Ext["Exit Interviewee"]
  p1(("1.0 Submit Resignation"))
  p2(("2.0 Manager Approval"))
  p3(("3.0 HR Pipeline"))
  p4(("4.0 Capture Exit Interview"))
  d1[("D1 resignation_requests")]
  d2[("D2 form_data")]
  d3[("D3 stages")]
  Emp -->|resignation details| p1
  p1 -->|new request| d1
  p1 -->|exit responses| d2
  Ext -->|public token form| p4
  p4 -->|interview answers| d2
  Mgr -->|approve return reject| p2
  p2 -->|archived approval_N| d3
  p2 -->|stage update| d1
  Hr -->|stage decisions| p3
  p3 -->|hr stage trail| d3
  p3 -->|final status| d1

flowchart LR
  Hr["HR Relations"]
  p31(("3.1 Employee Relations Check"))
  p32(("3.2 HR Recruitment"))
  p33(("3.3 HR Review"))
  p34(("3.4 Final Decision"))
  p35(("3.5 HR Director"))
  d1[("D1 resignation_requests")]
  d3[("D3 stages")]
  Hr -->|stage action| p31
  p31 --> p32
  p32 --> p33
  p33 --> p34
  p34 --> p35
  p35 -->|current_stage completed| d1
  p31 -->|stage log| d3
  p35 -->|stage log| d3

classDiagram
  class ResignationStageHandler {
    <<interface>>
    +advance(request, actor)
    +returnToSender(request, reason)
    +reject(request, reason)
  }
  class ManagerApprovalService {
    +advance(request, actor)
    +routeToHr(request)
  }
  class HrPipelineService {
    +advance(request, actor)
    +complete(request)
  }
  class ResignationRequestPolicy {
    +view(employee, request)
    +update(employee, request)
  }
  class ResignationController {
    +store(request)
    +show(id)
    +updateStatus(request, id)
    +showExitInterviewPublic(token)
  }
  class ResignationRequest {
    +int id
    +int employee_id
    +string current_stage
    +string status
    +json stages
    +json form_data
    +employee()
  }
  class Employee {
    +int id
    +string empName
    +int company_id
    +isHasPermission(name)
  }
  ResignationStageHandler <|.. ManagerApprovalService
  ResignationStageHandler <|.. HrPipelineService
  ResignationController ..> ResignationStageHandler
  ResignationController ..> ResignationRequestPolicy
  ManagerApprovalService ..> ResignationRequest
  HrPipelineService ..> ResignationRequest
  ResignationRequest "*" --> "1" Employee : employee_id

flowchart TD
  subgraph P["Presentation"]
    SigView["Signature Block View"]
    IdentityForm["Identity Update Form"]
  end
  subgraph AP["Application (Controllers)"]
    SigCtrl["SignatureController"]
  end
  subgraph DM["Domain (Services/Workflow)"]
    ResolveSig["getCompanySignatureData()"]
    UpdateIdentity["update()"]
  end
  subgraph DA["Data (Models/Tables)"]
    EmpModel["Employee (employees)"]
    CompModel["Company (companies)"]
  end
  subgraph EX["External"]
    AuthGuard["Employee Auth Guard"]
    Assets["Company Logo Assets"]
  end
  SigView --> SigCtrl
  IdentityForm --> SigCtrl
  SigCtrl --> AuthGuard
  SigCtrl --> ResolveSig
  SigCtrl --> UpdateIdentity
  ResolveSig --> CompModel
  ResolveSig --> Assets
  UpdateIdentity --> EmpModel
  EmpModel --> CompModel

flowchart TD
  subgraph CTRL["SignatureController"]
    Index["index()"]
    Update["update()"]
    Resolve["getCompanySignatureData(companyId)"]
  end
  Index --> LoadEmp["load employee with company"]
  LoadEmp --> Resolve
  Resolve --> Block["companySignatureData array"]
  Block --> View["signature.index view"]
  Update --> Validate["validate identity rules"]
  Validate --> Save["employee.update(validated)"]
  Save --> Json["JSON success response"]

flowchart LR
  Emp["Employee"]
  subgraph SB["Email Signature - System Boundary"]
    UC1(["View Signature Block"])
    UC2(["Load Company Signature Data"])
    UC3(["Edit Identity Fields"])
    UC4(["Submit Identity Update"])
    UC5(["Validate and Save Fields"])
  end
  Emp --- UC1
  Emp --- UC3
  Emp --- UC4
  UC1 -.->|include| UC2
  UC4 -.->|include| UC5
  UC5 -.->|extend| UC1

sequenceDiagram
  actor Emp as Employee
  participant C as SignatureController
  participant E as Employee Model
  participant Co as Company Model
  Emp->>C: open signature page
  C->>E: load employee with company
  E->>Co: resolve company_id
  Co-->>C: company signature data
  C-->>Emp: render signature block
  opt Edit identity
    Emp->>C: submit identity fields
    C->>C: validate rules
    alt Valid
      C->>E: update employee record
      E-->>C: saved
      C-->>Emp: JSON success
    else Invalid
      C-->>Emp: JSON validation errors
    end
  end

flowchart LR
  Emp["Employee"]
  p1(("1.0 Resolve Signature Data"))
  p2(("2.0 Render Signature Block"))
  p3(("3.0 Update Identity Fields"))
  d1[("D1 employees")]
  d2[("D2 companies")]
  Emp -->|open page| p1
  d1 -->|identity fields| p1
  d2 -->|company signature data| p1
  p1 -->|resolved data| p2
  p2 -->|signature block| Emp
  Emp -->|edited fields| p3
  p3 -->|validated fields| d1
  p3 -->|updated block| Emp

flowchart LR
  Emp["Employee"]
  p31(("3.1 Receive AJAX Request"))
  p32(("3.2 Validate Fields"))
  p33(("3.3 Persist Identity"))
  p34(("3.4 Return JSON Result"))
  d1[("D1 employees")]
  Emp -->|identity fields| p31
  p31 --> p32
  p32 -->|valid data| p33
  p32 -->|errors| p34
  p33 -->|update record| d1
  p33 --> p34
  p34 -->|success or errors| Emp

classDiagram
  class SignatureDataProvider {
    <<interface>>
    +getCompanySignatureData(companyId)
  }
  class CompanySignatureProvider {
    +getCompanySignatureData(companyId)
  }
  class SignatureController {
    +index()
    +update(request)
  }
  class Employee {
    +int id
    +string empName
    +string emailWork
    +string mobile
    +int company_id
    +company()
    +update(fields)
  }
  class Company {
    +int id
    +string name
    +string website
    +string cr_number
    +string logo_path
  }
  SignatureController ..> SignatureDataProvider
  SignatureDataProvider <|.. CompanySignatureProvider
  SignatureController ..> Employee
  Employee "*" --> "1" Company : company_id

flowchart TD
  subgraph Pres["Presentation"]
    V1["Public Application Form"]
    V2["HR & Interviewer Views"]
  end
  subgraph App["Application (Controllers)"]
    C1["CandidatesController"]
    C2["RecruitmentRequestsController"]
  end
  subgraph Dom["Domain (Services/Workflow)"]
    S1["Interview Status Workflow"]
    S2["Evaluation Scoring Logic"]
  end
  subgraph Dat["Data (Models/Tables)"]
    M1["CandidateRequest"]
    M2["CandidatesApplication"]
    M3["CandidateInterviewEvaluation"]
    M4["CandidateHrCheck"]
    M5["CandidateImmigration / CandidateHrDirector"]
  end
  subgraph Ext["External"]
    X1["Mail Notification"]
  end
  V1 --> C1
  V2 --> C1
  V2 --> C2
  C1 --> S1
  C1 --> S2
  S1 --> M1
  S1 --> M2
  S2 --> M3
  M3 --> M4
  M4 --> M5
  S1 --> X1

flowchart TD
  A["CandidatesController.storeEvaluation()"]
  B["validate sections A-D and scores"]
  C["computeTotalScore()"]
  D["setRecommendation(hire / doNotHire)"]
  E["CandidateInterviewEvaluation.save()"]
  F{"is last interviewer?"}
  G["advanceStatus(Pending HR Check)"]
  H["assignNextInterviewer()"]
  A --> B
  B --> C
  C --> D
  D --> E
  E --> F
  F -->|Yes| G
  F -->|No| H

flowchart LR
  HR["HR / Recruitment Officer"]
  CAND["Candidate"]
  INT["Interviewer"]
  DIR["HR Director"]
  subgraph SB["Candidate Interview - System Boundary"]
    U1(["Create Candidate Request"])
    U2(["Submit Public Application"])
    U3(["Approve HR Review"])
    U4(["Submit Interview Evaluation"])
    U5(["Complete HR Check"])
    U6(["Record Immigration"])
    U7(["Make Final Decision"])
  end
  HR --- U1
  HR --- U3
  HR --- U5
  HR --- U6
  CAND --- U2
  INT --- U4
  DIR --- U7
  U2 -.->|include| U3
  U5 -.->|include| U6

sequenceDiagram
  actor HR as HR Officer
  actor CAND as Candidate
  actor INT as Interviewer
  participant C as CandidatesController
  participant S as Interview Workflow
  participant DB as Database
  HR->>C: createCandidateRequest()
  C->>S: init Pending Application
  S->>DB: insert CandidateRequest
  CAND->>C: submitApplication(token)
  C->>DB: store Pending HR Reviewed
  HR->>C: approveReview()
  C->>S: advance Pending 1st Interviewer
  loop each interviewer
    INT->>C: submitEvaluation(scores)
    C->>DB: insert CandidateInterviewEvaluation
  end
  alt last interviewer done
    S->>DB: set Pending HR Check
  end
  HR->>DB: HR check and immigration
  S-->>HR: notify HR Director stage

flowchart LR
  E1["Candidate"]
  E2["HR Officer"]
  E3["Interviewer"]
  E4["HR Director"]
  P1(("1.0 Register Candidate"))
  P2(("2.0 Capture Application"))
  P3(("3.0 Evaluate Interviews"))
  P4(("4.0 HR Check and Immigration"))
  P5(("5.0 Final Decision"))
  D1[("D1 Candidate Records")]
  D2[("D2 Evaluations")]
  E2 -->|request| P1
  P1 -->|placeholder| D1
  E1 -->|application| P2
  P2 -->|profile| D1
  E3 -->|scores| P3
  P3 -->|evaluation| D2
  P4 -->|check package| D1
  E4 -->|verdict| P5
  P5 -->|status| D1

flowchart LR
  IN["Interviewer"]
  HR["HR Officer"]
  P31(("3.1 Load Assigned Candidate"))
  P32(("3.2 Score Sections A-D"))
  P33(("3.3 Set Hire Recommendation"))
  P34(("3.4 Compute Total Score"))
  P35(("3.5 Advance After Last Interviewer"))
  D1[("D1 Candidate Records")]
  D2[("D2 Evaluations")]
  IN -->|open| P31
  P31 -->|form| P32
  P32 -->|section scores| P33
  P33 -->|recommendation| P34
  P34 -->|total| D2
  P34 -->|sequence check| P35
  P35 -->|Pending HR Check| D1
  P35 -->|notify| HR

classDiagram
  class InterviewWorkflow {
    <<interface>>
    +advanceStatus(candidate)
    +assignInterviewer(candidate)
  }
  class InterviewWorkflowService {
    +advanceStatus(candidate)
    +assignInterviewer(candidate)
    +computeTotalScore(evaluation)
  }
  class CandidatesController {
    +storeEvaluation(request)
    +approveReview(id)
  }
  class CandidateRequest {
    +int id
    +string status
    +assignInterviewers()
  }
  class CandidatesApplication {
    +int candidate_id
    +decimal expectedSalary
  }
  class CandidateInterviewEvaluation {
    +int interviewer_no
    +int totalScore
    +string recommendation
  }
  class CandidateHrCheck {
    +decimal offeredSalary
    +string state
  }
  class CandidateImmigration {
    +bool transferOfSponsorship
    +string decision
  }
  InterviewWorkflow <|.. InterviewWorkflowService
  CandidatesController ..> InterviewWorkflow
  CandidateRequest "1" --> "1" CandidatesApplication
  CandidateRequest "1" --> "1..4" CandidateInterviewEvaluation
  CandidateRequest "1" --> "1" CandidateHrCheck
  CandidateRequest "1" --> "1" CandidateImmigration

flowchart TD
  subgraph Presentation
    V1["Review Views (index/show)"]
    V2["Create Review Form"]
  end
  subgraph Application["Application (Controllers)"]
    C1["PerformanceReviewController"]
  end
  subgraph Domain["Domain (Services/Workflow)"]
    S1["Line Approval Chain"]
    S2["Pay and Grade Proposal"]
    S3["Decision Letter PDF"]
  end
  subgraph Data["Data (Models/Tables)"]
    M1["PerformanceReviewRequest"]
    M2["PerformanceReviewApproval"]
    M3["PerformanceReviewHRChecked"]
    M4["PerformanceReviewReturn"]
    M5["Designation"]
    M6["Employee"]
  end
  subgraph External
    ST["File Storage"]
  end
  V1 --> C1
  V2 --> C1
  C1 --> S1
  C1 --> S2
  C1 --> S3
  S1 --> M1
  S1 --> M2
  S2 --> M3
  S2 --> M5
  S2 --> M6
  M4 --> M1
  C1 --> ST

flowchart LR
  subgraph PerformanceReviewController
    m1["store()"]
    m2["approverAction()"]
    m3["storeHRChecked()"]
    m4["hrApprovalAction()"]
    m5["hrDirectorAction()"]
    m6["downloadLetter()"]
  end
  m1 -->|"Pending Approver 1"| R["PerformanceReviewRequest"]
  m2 -->|"approve/reject/next"| A["PerformanceReviewApproval"]
  m3 -->|"pay/grade proposal"| H["PerformanceReviewHRChecked"]
  m4 -->|"new_proposed_salary"| H
  m5 -->|"apply salary + grade"| E["Employee"]
  m2 -.->|"return"| RET["PerformanceReviewReturn"]
  m6 --> PDF["Decision Letter PDF"]

flowchart LR
  AP["Appraiser"]
  L1["Line Approver 1"]
  L23["Line Approver 2/3"]
  HC["HR Checked"]
  HA["HR Approval"]
  HD["HR Director"]
  subgraph SB["Performance Review - System Boundary"]
    uc1(["Create Appraisal"])
    uc2(["Line Approval"])
    uc3(["Enter Pay and Grade Proposal"])
    uc4(["HR Approval Decision"])
    uc5(["Approve and Apply Changes"])
    uc6(["Download Decision Letter"])
  end
  AP --- uc1
  L1 --- uc2
  L23 --- uc2
  HC --- uc3
  HA --- uc4
  HD --- uc5
  HD --- uc6
  uc4 -.->|"include"| uc3
  uc5 -.->|"extend"| uc6

sequenceDiagram
    participant AP as Appraiser
    participant CTRL as ReviewController
    participant LA as Line Approvers
    participant HR as HR Chain
    participant DB as Review Models
    participant EMP as Employee Master
    AP->>CTRL: store() create review
    CTRL->>DB: Pending Approver 1
    loop Approvers 1 to 3
        LA->>CTRL: approverAction (approve or next)
        CTRL->>DB: save Approval
        alt Next approver
            CTRL->>DB: Pending Approver 2 or 3
        else Reject
            CTRL->>DB: Rejected (terminal)
        end
    end
    CTRL->>DB: Pending HR Checked
    HR->>CTRL: storeHRChecked pay/grade proposal
    CTRL->>DB: new_proposed_salary = sum of new components
    HR->>CTRL: hrApprovalAction approve
    HR->>CTRL: hrDirectorAction approve
    CTRL->>EMP: apply salary and grade
    CTRL-->>AP: decision letter

flowchart LR
  E1["Appraiser"]
  E2["Line Approvers"]
  E3["HR Checked/Approval"]
  E4["HR Director"]
  p1(("1.0 Create Appraisal"))
  p2(("2.0 Line Approval Chain"))
  p3(("3.0 HR Pay and Grade Check"))
  p4(("4.0 HR Approval and Director"))
  p5(("5.0 Apply Salary and Grade"))
  d1[("D1 Review Requests")]
  d2[("D2 Approvals")]
  d3[("D3 HR Checked")]
  d4[("D4 Employee Master")]
  E1 -->|"appraisal + approver 1"| p1
  p1 --> d1
  p1 --> p2
  E2 -->|"approve/next"| p2
  p2 --> d2
  p2 --> p3
  E3 -->|"pay/grade proposal"| p3
  p3 --> d3
  p3 --> p4
  E4 -->|"final approve"| p4
  p4 --> p5
  p5 --> d4

flowchart LR
  E3["HR Checked"]
  E4["HR Approval"]
  E5["HR Director"]
  p31(("3.1 Capture Old Pay"))
  p32(("3.2 Propose New Pay Components"))
  p33(("3.3 Compute Proposed Salary"))
  p34(("3.4 Set Target Designation"))
  p35(("3.5 Approve and Apply"))
  d3[("D3 HR Checked")]
  d5[("D5 Designations")]
  d4[("D4 Employee Master")]
  E3 --> p31
  p31 --> p32
  E4 --> p32
  p32 --> p33
  p33 -->|"sum of seven components"| d3
  E3 --> p34
  d5 --> p34
  p34 --> d3
  E5 --> p35
  p35 --> d4

classDiagram
    class ReviewWorkflow {
        <<interface>>
        +initiate()
        +approveStage()
        +routeNext()
    }
    class PayGradeProposal {
        <<interface>>
        +buildProposal()
        +computeSalary()
    }
    class LetterGenerator {
        <<interface>>
        +generate()
    }
    class PerformanceReviewController {
        +store()
        +approverAction()
        +storeHRChecked()
        +hrApprovalAction()
        +hrDirectorAction()
    }
    class SequentialReviewWorkflow {
        +approveStage()
        +routeNext()
    }
    class HrPayGradeService {
        +buildProposal()
        +computeSalary()
    }
    class PdfLetterGenerator {
        +generate()
    }
    class PerformanceReviewRequest {
        +int id
        +int appraiser_id
        +int approver_1_id
        +string status
    }
    class PerformanceReviewApproval {
        +int id
        +string stage
        +string proposed_designation_name
    }
    class PerformanceReviewHRChecked {
        +int id
        +decimal new_proposed_salary
        +date effective_date
    }
    class PerformanceReviewReturn {
        +int id
        +string status
        +string other_reason
    }
    class Designation {
        +int id
        +string name
    }
    class Employee {
        +int id
        +decimal basicSalary
        +string designation
    }
    PerformanceReviewController ..> ReviewWorkflow
    PerformanceReviewController ..> PayGradeProposal
    PerformanceReviewController ..> LetterGenerator
    SequentialReviewWorkflow ..|> ReviewWorkflow
    HrPayGradeService ..|> PayGradeProposal
    PdfLetterGenerator ..|> LetterGenerator
    Employee "1" --> "0..*" PerformanceReviewRequest
    PerformanceReviewRequest "1" --> "0..*" PerformanceReviewApproval
    PerformanceReviewRequest "1" --> "1" PerformanceReviewHRChecked
    PerformanceReviewRequest "1" --> "0..*" PerformanceReviewReturn
    PerformanceReviewRequest "0..*" --> "1" Designation

flowchart TD
  subgraph pres["Presentation"]
    ADM["Program Maintenance Form"]
    VIEW["introduction_program View"]
  end
  subgraph app["Application (Controllers)"]
    IPC["IntroductionProgramController"]
  end
  subgraph dom["Domain (Services/Workflow)"]
    UPS["Update-instead-of-insert Merge"]
    DEC["Decrypt and De-obfuscate Id"]
  end
  subgraph data["Data (Models/Tables)"]
    IP["IntroductionProgram (introduction_program)"]
    CO["Company"]
  end
  subgraph ext["External"]
    FS["assets/images Storage"]
    YT["YouTube Embed"]
  end
  ADM --> IPC
  IPC --> UPS
  UPS --> IP
  UPS --> FS
  IP --> CO
  VIEW --> DEC
  DEC --> IP
  IP --> YT

flowchart TD
  STORE["store() upsert by company_id"]
  MERGE["merge old and new attachments"]
  YID["extractYouTubeVideoId(url)"]
  SHOW["show(id) decrypt and divide"]
  DEL["deleteAttachment() splice"]
  subgraph model["IntroductionProgram"]
    FIND["where company_id first"]
    UPD["update(youtube_urls, attachments)"]
    CRT["create fresh record"]
  end
  STORE --> YID
  STORE --> FIND
  FIND --> MERGE
  MERGE --> UPD
  FIND --> CRT
  SHOW --> FIND
  DEL --> UPD

flowchart LR
  ADM["Administrator"]
  EMP["Employee"]
  subgraph sb["Induction - System Boundary"]
    UC1(["Maintain Induction Program"])
    UC2(["Add Videos and Attachments"])
    UC3(["Delete Attachment"])
    UC4(["Open Induction Link"])
    UC5(["View Videos and Attachments"])
  end
  ADM --- UC1
  ADM --- UC3
  EMP --- UC4
  UC1 -.->|include| UC2
  UC4 -.->|include| UC5

sequenceDiagram
  actor ADM as Administrator
  actor EMP as Employee
  participant IPC as IntroductionProgramController
  participant IP as introduction_program
  participant FS as File Storage
  ADM->>IPC: store(company_id, videos, attachments)
  IPC->>IP: where company_id first
  alt record exists
    IPC->>IP: merge and update attachments
  else new company
    IPC->>IP: create record
  end
  ADM->>FS: upload attachment files
  EMP->>IPC: open link (encrypted id)
  IPC->>IPC: decrypt and divide by 975684
  IPC->>IP: find(id)
  IP-->>EMP: render introduction_program view

flowchart LR
  ADM["Administrator"]
  EMP["Employee"]
  P1(("1.0 Maintain Program"))
  P2(("2.0 Resolve Link"))
  P3(("3.0 Render Program"))
  D1[("D1 introduction_program")]
  D2[("D2 assets/images")]
  ADM -->|videos and files| P1
  P1 -->|merged record| D1
  P1 -->|files| D2
  EMP -->|encrypted id| P2
  D1 -->|program record| P2
  P2 -->|resolved program| P3
  P3 -->|videos and attachments| EMP

flowchart LR
  ADM["Administrator"]
  P11(("1.1 Extract YouTube Id"))
  P12(("1.2 Store Uploaded Files"))
  P13(("1.3 Lookup by company_id"))
  P14(("1.4 Merge or Insert"))
  D1[("D1 introduction_program")]
  D2[("D2 assets/images")]
  ADM -->|youtube url| P11
  ADM -->|attachment files| P12
  P12 -->|file names| D2
  P11 -->|video id| P14
  P13 -->|existing record| P14
  D1 -->|current record| P13
  P14 -->|merged attachments| D1

classDiagram
  class ProgramProvider {
    <<interface>>
    +maintain(companyId, data)
    +resolveByLink(token)
  }
  class IntroductionProgramController {
    +index()
    +store(request)
    +show(id)
    +deleteAttachment(request)
  }
  class IntroductionProgram {
    +int id
    +int company_id
    +string name
    +string youtube_urls
    +string video_from_pc
    +json attachments
    +company()
  }
  class Company {
    +int id
    +string name
    +introductionProgram()
  }
  IntroductionProgramController ..> ProgramProvider
  ProgramProvider <|.. IntroductionProgram
  IntroductionProgram "*" --> "1" Company

flowchart TD
  subgraph pres["Presentation"]
    ADM["Program Maintenance Form"]
    PV["Policy View"]
    PRV["Procedures View"]
  end
  subgraph app["Application (Controllers)"]
    PC["InternalpolicyProgramController"]
    PRC["ProcedureProgramController"]
  end
  subgraph dom["Domain (Services/Workflow)"]
    UPS["Update-instead-of-insert Merge"]
    DEC["Decrypt and De-obfuscate Id"]
  end
  subgraph data["Data (Models/Tables)"]
    IPP["Internal_PolicyProgram"]
    PP["ProceduresProgram"]
    CO["Company"]
  end
  ADM --> PC
  ADM --> PRC
  PC --> UPS
  PRC --> UPS
  UPS --> IPP
  UPS --> PP
  IPP --> CO
  PP --> CO
  PV --> DEC
  PRV --> DEC
  DEC --> IPP
  DEC --> PP

flowchart TD
  STORE["store() upsert by company_id"]
  MERGE["merge old and new attachments"]
  YID["extractYouTubeVideoId(url)"]
  SHOW["show(id) decrypt and divide"]
  VIEW["internal_policy_program View"]
  subgraph model["Internal_PolicyProgram"]
    FIND["where company_id first"]
    UPD["update(youtube_urls, attachments)"]
    CRT["create fresh record"]
  end
  STORE --> YID
  STORE --> FIND
  FIND --> MERGE
  MERGE --> UPD
  FIND --> CRT
  SHOW --> FIND
  FIND --> VIEW

flowchart LR
  ADM["Administrator"]
  EMP["Employee"]
  subgraph sb["Internal Policy and Procedures - System Boundary"]
    UC1(["Maintain Policy Program"])
    UC2(["Maintain Procedures Program"])
    UC3(["Open Policy Link"])
    UC4(["Open Procedures Link"])
    UC5(["View Content"])
  end
  ADM --- UC1
  ADM --- UC2
  EMP --- UC3
  EMP --- UC4
  UC3 -.->|include| UC5
  UC4 -.->|include| UC5

sequenceDiagram
  actor ADM as Administrator
  actor EMP as Employee
  participant PC as InternalpolicyProgramController
  participant IPP as internal_policy
  participant PP as procedures_program
  ADM->>PC: store(company_id, videos, attachments)
  PC->>IPP: where company_id first
  alt record exists
    PC->>IPP: merge and update attachments
  else new company
    PC->>IPP: create record
  end
  ADM->>PP: maintain procedures program
  EMP->>PC: open policy link (encrypted id)
  PC->>PC: decrypt and divide by 975684
  PC->>IPP: find(id)
  IPP-->>EMP: render internal_policy_program view

flowchart LR
  ADM["Administrator"]
  EMP["Employee"]
  P1(("1.0 Maintain Policy Program"))
  P2(("2.0 Maintain Procedures Program"))
  P3(("3.0 Resolve and Render Link"))
  D1[("D1 internal_policy")]
  D2[("D2 procedures_program")]
  ADM -->|policy content| P1
  P1 -->|merged record| D1
  ADM -->|procedures content| P2
  P2 -->|merged record| D2
  EMP -->|encrypted id| P3
  D1 -->|policy record| P3
  D2 -->|procedures record| P3
  P3 -->|videos and attachments| EMP

flowchart LR
  ADM["Administrator"]
  P11(("1.1 Extract YouTube Id"))
  P12(("1.2 Store Uploaded Files"))
  P13(("1.3 Lookup by company_id"))
  P14(("1.4 Merge or Insert"))
  D1[("D1 internal_policy")]
  D2[("D2 assets/images")]
  ADM -->|youtube url| P11
  ADM -->|attachment files| P12
  P12 -->|file names| D2
  P11 -->|video id| P14
  P13 -->|existing record| P14
  D1 -->|current record| P13
  P14 -->|merged attachments| D1

classDiagram
  class ProgramProvider {
    <<interface>>
    +maintain(companyId, data)
    +resolveByLink(token)
  }
  class InternalpolicyProgramController {
    +store(request)
    +show(id)
    +deleteAttachment(request)
  }
  class ProcedureProgramController {
    +store(request)
    +show(id)
  }
  class Internal_PolicyProgram {
    +int id
    +int company_id
    +string youtube_urls
    +json attachments
    +company()
  }
  class ProceduresProgram {
    +int id
    +int company_id
    +string youtube_urls
    +json attachments
    +company()
  }
  class Company {
    +int id
    +string name
  }
  InternalpolicyProgramController ..> ProgramProvider
  ProcedureProgramController ..> ProgramProvider
  ProgramProvider <|.. Internal_PolicyProgram
  ProgramProvider <|.. ProceduresProgram
  Internal_PolicyProgram "*" --> "1" Company
  ProceduresProgram "*" --> "1" Company

flowchart TD
  subgraph pres["Presentation"]
    ADM["Program Maintenance Form"]
    VIEW["circulated_memo_program View"]
  end
  subgraph app["Application (Controllers)"]
    CMC["CircularmemoProgramController"]
  end
  subgraph dom["Domain (Services/Workflow)"]
    UPS["Update-instead-of-insert Merge"]
    DEC["Decrypt and De-obfuscate Id"]
  end
  subgraph data["Data (Models/Tables)"]
    CM["Circular_Memo (circular_memo)"]
    CO["Company"]
  end
  subgraph ext["External"]
    FS["assets/images Storage"]
  end
  ADM --> CMC
  CMC --> UPS
  UPS --> CM
  UPS --> FS
  CM --> CO
  VIEW --> DEC
  DEC --> CM

flowchart TD
  STORE["store() upsert by company_id"]
  MERGE["merge old and new attachments"]
  YID["extractYouTubeVideoId(url)"]
  SHOW["show(id) decrypt and divide"]
  DEL["deleteAttachment() splice"]
  subgraph model["Circular_Memo"]
    FIND["where company_id first"]
    UPD["update(youtube_urls, attachments)"]
    CRT["create fresh record"]
  end
  STORE --> YID
  STORE --> FIND
  FIND --> MERGE
  MERGE --> UPD
  FIND --> CRT
  SHOW --> FIND
  DEL --> UPD

flowchart LR
  ADM["Administrator"]
  EMP["Employee"]
  subgraph sb["Circular Memos - System Boundary"]
    UC1(["Maintain Memo Program"])
    UC2(["Add Videos and Attachments"])
    UC3(["Delete Attachment"])
    UC4(["Open Memo Link"])
    UC5(["Acknowledge Memo"])
  end
  ADM --- UC1
  ADM --- UC3
  EMP --- UC4
  UC1 -.->|include| UC2
  UC4 -.->|include| UC5

sequenceDiagram
  actor ADM as Administrator
  actor EMP as Employee
  participant CMC as CircularmemoProgramController
  participant CM as circular_memo
  participant FS as File Storage
  ADM->>CMC: store(company_id, videos, attachments)
  CMC->>CM: where company_id first
  alt record exists
    CMC->>CM: merge and update attachments
  else new company
    CMC->>CM: create record
  end
  ADM->>FS: upload attachment files
  EMP->>CMC: open link (encrypted id)
  CMC->>CMC: decrypt and divide by 975684
  CMC->>CM: find(id)
  CM-->>EMP: render circulated_memo_program view

flowchart LR
  ADM["Administrator"]
  EMP["Employee"]
  P1(("1.0 Maintain Memo Program"))
  P2(("2.0 Resolve Link"))
  P3(("3.0 Render for Acknowledgement"))
  D1[("D1 circular_memo")]
  D2[("D2 assets/images")]
  ADM -->|videos and files| P1
  P1 -->|merged record| D1
  P1 -->|files| D2
  EMP -->|encrypted id| P2
  D1 -->|memo record| P2
  P2 -->|resolved program| P3
  P3 -->|videos and attachments| EMP

flowchart LR
  ADM["Administrator"]
  P11(("1.1 Extract YouTube Id"))
  P12(("1.2 Store Uploaded Files"))
  P13(("1.3 Lookup by company_id"))
  P14(("1.4 Merge or Insert"))
  D1[("D1 circular_memo")]
  D2[("D2 assets/images")]
  ADM -->|youtube url| P11
  ADM -->|attachment files| P12
  P12 -->|file names| D2
  P11 -->|video id| P14
  P13 -->|existing record| P14
  D1 -->|current record| P13
  P14 -->|merged attachments| D1

classDiagram
  class ProgramProvider {
    <<interface>>
    +maintain(companyId, data)
    +resolveByLink(token)
  }
  class CircularmemoProgramController {
    +index()
    +store(request)
    +show(id)
    +deleteAttachment(request)
  }
  class Circular_Memo {
    +int id
    +int company_id
    +string name
    +string youtube_urls
    +json attachments
    +company()
  }
  class Company {
    +int id
    +string name
    +circularMemo()
  }
  CircularmemoProgramController ..> ProgramProvider
  ProgramProvider <|.. Circular_Memo
  Circular_Memo "*" --> "1" Company

flowchart TD
  subgraph Presentation["Presentation"]
    UI1["Welcome Note Form"]
    UI2["Excel Import UI"]
    UI3["Manager Recipient View"]
  end
  subgraph Application["Application (Controllers)"]
    C1["Employee WelcomeNoteController"]
    C2["Admin WelcomeNoteController"]
  end
  subgraph Domain["Domain (Services/Workflow)"]
    W1["Employee Creation & Dispatch"]
    W2["State Change Handler"]
    W3["WelcomeNoteImport"]
  end
  subgraph Data["Data (Models/Tables)"]
    M1["Employee"]
    M2["WelcomeNoteRequest"]
  end
  subgraph External["External"]
    E1["Excel Spreadsheet"]
  end
  UI1 --> C1
  UI3 --> C1
  UI2 --> C1
  C1 --> W1
  C1 --> W2
  C1 --> W3
  E1 --> W3
  W1 --> M1
  W1 --> M2
  W2 --> M2
  W3 --> M1
  C2 --> M2

flowchart TD
  subgraph WNC["WelcomeNoteController"]
    a1["getManagers() : filter by entity"]
    a2["store() : create Employee"]
    a3["store() : dispatch per manager"]
    a4["changeState() : group update"]
    a5["import() : bulk onboarding"]
  end
  M1[("employees")]
  M2[("welcome_notes_requests")]
  a1 --> a3
  a2 --> M1
  a2 -->|"shared request_id (rand)"| a3
  a3 -->|"row per receiver (pending)"| M2
  a4 -->|"where request_id group"| M2
  a4 -->|"evaluated / canceled"| M2
  a5 --> M1

flowchart LR
  HR["HR / Recruitment Officer"]
  MG["Manager (Recipient)"]
  subgraph SB["Welcome Note - System Boundary"]
    U1(["Create Welcome Note"])
    U2(["Create Employee Record"])
    U3(["Bulk Import (Excel)"])
    U4(["View Welcome Note"])
    U5(["Mark Evaluated"])
    U6(["Cancel with Reason"])
  end
  HR --- U1
  HR --- U3
  MG --- U4
  MG --- U5
  MG --- U6
  U1 -.->|"include"| U2
  U5 -.->|"extend"| U4
  U6 -.->|"extend"| U4

sequenceDiagram
  actor HR as HR Officer
  actor MG as Manager
  participant C as WelcomeNoteController
  participant E as Employee
  participant W as WelcomeNoteRequest
  HR->>C: store()
  C->>E: create employee record
  loop Each selected manager
    C->>W: create row (shared request_id, pending)
  end
  MG->>C: index() view note
  alt Evaluated
    MG->>C: changeState(evaluated)
    C->>W: update group + signature
  else Canceled
    MG->>C: changeState(canceled)
    C->>W: update group + reason
  end

flowchart LR
  HR["HR Officer"]
  MG["Manager"]
  XL["Excel Spreadsheet"]
  p1(("1.0 Create Welcome Note"))
  p2(("2.0 Dispatch to Managers"))
  p3(("3.0 Bulk Import"))
  p4(("4.0 Change State"))
  d1[("D1 Employees")]
  d2[("D2 Welcome Note Requests")]
  HR -->|"employee data + managers"| p1
  p1 --> d1
  p1 -->|"shared request_id"| p2
  p2 -->|"pending rows"| d2
  XL -->|"rows"| p3
  p3 --> d1
  MG -->|"evaluate / cancel"| p4
  d2 -->|"recipient group"| p4
  p4 -->|"evaluated / canceled"| d2

flowchart LR
  d2[("D2 Welcome Note Requests")]
  MG["Manager"]
  p41(("4.1 Resolve request_id Group"))
  p42(("4.2 Set Status"))
  p43(("4.3 Attach Signature"))
  p44(("4.4 Record Cancel Reason"))
  MG -->|"chosen state"| p41
  d2 -->|"rows sharing request_id"| p41
  p41 --> p42
  p42 -->|"status cascade"| d2
  p42 -->|"evaluated"| p43
  p42 -->|"canceled"| p44
  p43 -->|"signature file"| d2
  p44 -->|"cancellation reason"| d2

classDiagram
  class WelcomeNoteController {
    +store()
    +changeState()
    +import()
  }
  class NoteDispatcher {
    <<interface>>
    +dispatch(employee, managers)
  }
  class ManagerDispatcher {
    +dispatch(employee, managers)
  }
  class ExcelDispatcher {
    +dispatch(employee, managers)
  }
  class WelcomeNoteRequest {
    +int id
    +int new_emp_request
    +int emp_receiver_request
    +string request_id
    +string status
    +newemployee()
    +employeeReceiver()
  }
  class Employee {
    +int id
    +string empName
    +string welcomeNote
    +int company_id
  }
  WelcomeNoteController ..> NoteDispatcher
  NoteDispatcher <|.. ManagerDispatcher
  NoteDispatcher <|.. ExcelDispatcher
  Employee "1" --> "*" WelcomeNoteRequest : onboarded in
  WelcomeNoteRequest "*" --> "1" Employee : addressed to

flowchart TD
  subgraph pres["Presentation"]
    V1["Letter Request List"]
    V2["Create Paired Request"]
  end
  subgraph app["Application (Controllers)"]
    LC["LetterController"]
  end
  subgraph dom["Domain (Services/Workflow)"]
    ST["changeState Transition"]
    STAT["Statistics Aggregation"]
  end
  subgraph data["Data (Models/Tables)"]
    LR["LetterRequest (letters)"]
    EMP["Employee"]
    CO["Company"]
  end
  V1 --> LC
  V2 --> LC
  LC --> STAT
  LC --> ST
  STAT --> LR
  ST --> LR
  LR --> EMP
  LR --> CO

flowchart TD
  IDX["index() list plus statistics"]
  STORE["store() create paired rows"]
  CHG["changeState(id, status, all)"]
  SHOW["show() render letter"]
  subgraph model["LetterRequest (letters)"]
    QRY["where request_id"]
    CRT["create sender and receiver rows"]
    UPD["update status and signature"]
  end
  IDX --> QRY
  STORE --> CRT
  CHG --> QRY
  QRY --> UPD
  SHOW --> QRY

flowchart LR
  EMP["Employee Sender"]
  RCV["Receiver / Manager"]
  HR["HR Staff"]
  subgraph sb["Separation Letters - System Boundary"]
    UC1(["Create Paired Request"])
    UC2(["View Request List"])
    UC3(["Change State"])
    UC4(["Upload Signature"])
    UC5(["Monitor Statistics"])
  end
  EMP --- UC1
  EMP --- UC2
  RCV --- UC3
  HR --- UC5
  UC3 -.->|include| UC4

sequenceDiagram
  actor EMP as Employee Sender
  actor RCV as Receiver
  participant LC as LetterController
  participant LR as letters table
  EMP->>LC: store(letter_type, receiver)
  LC->>LR: create sender and receiver rows (request_id)
  LR-->>EMP: pending request listed
  RCV->>LC: changeState(id, status)
  opt signature provided
    LC->>LC: move signature image to storage
  end
  LC->>LR: update all rows sharing request_id
  LR-->>RCV: status evaluated or canceled

flowchart LR
  EMP["Employee Sender"]
  RCV["Receiver / Manager"]
  HR["HR Staff"]
  P1(("1.0 Create Paired Request"))
  P2(("2.0 Change State"))
  P3(("3.0 Report Statistics"))
  D1[("D1 letters")]
  EMP -->|letter details| P1
  P1 -->|paired rows| D1
  RCV -->|status and signature| P2
  P2 -->|updated status| D1
  D1 -->|counts| P3
  P3 -->|statistics| HR

flowchart LR
  RCV["Receiver / Manager"]
  P21(("2.1 Validate State Change"))
  P22(("2.2 Store Signature Image"))
  P23(("2.3 Update Paired Rows"))
  P24(("2.4 Record Cancellation Reason"))
  D1[("D1 letters")]
  D2[("D2 signature files")]
  RCV -->|status and signature| P21
  P21 -->|image file| P22
  P22 -->|file name| D2
  P21 -->|request_id| P23
  P23 -->|status update| D1
  P21 -->|reason| P24
  P24 -->|cancellation_reasons| D1

classDiagram
  class LetterWorkflow {
    <<interface>>
    +createPairedRequest(data)
    +changeState(id, status, signature)
  }
  class LetterService {
    +createPairedRequest(data)
    +changeState(id, status, signature)
  }
  class LetterController {
    +index()
    +store(request)
    +changeState(request, id, status, all)
  }
  class LetterRequest {
    +int request_id
    +string letter_type
    +string status
    +string signature
    +employeeSender()
    +employeeReceiver()
    +newemployee()
  }
  class Employee {
    +int id
    +string empName
  }
  class Company {
    +int id
    +string name
  }
  LetterController ..> LetterWorkflow
  LetterWorkflow <|.. LetterService
  LetterService --> LetterRequest
  LetterRequest "*" --> "1" Employee : sender and receiver
  LetterRequest "*" --> "1" Company

flowchart TD
  subgraph Pres["Presentation"]
    V1["Manpower Requisition View"]
    V2["Candidate List & Excel Tools"]
  end
  subgraph App["Application (Controllers)"]
    C1["ManpowerController"]
    C2["ManpowerCandidateController"]
  end
  subgraph Dom["Domain (Services/Workflow)"]
    S1["createCandidatesFromManpower()"]
    S2["Totals & Balance Calculator"]
    S3["Excel Import / Export"]
  end
  subgraph Dat["Data (Models/Tables)"]
    M1["Manpower (manpower)"]
    M2["ManpowerCandidate (manpowercandidates)"]
  end
  subgraph Ext["External"]
    X1["Excel Files"]
  end
  V1 --> C1
  V2 --> C2
  C1 --> S1
  C1 --> S2
  C2 --> S3
  S1 --> M2
  S2 --> M1
  S3 --> M2
  S3 --> X1

flowchart TD
  A["ManpowerController.store()"]
  B["computeGrandTotals()"]
  C["createCandidatesFromManpower()"]
  D{"demand unit remaining?"}
  E["spawn ManpowerCandidate (Pending)"]
  F["remaining = grandTotal - candidatesCount"]
  G["persist Manpower"]
  A --> B
  B --> C
  C --> D
  D -->|Yes| E
  E --> D
  D -->|No| F
  F --> G

flowchart LR
  HR["HR / Recruitment Officer"]
  subgraph SB["Recruitment - System Boundary"]
    U1(["Submit Manpower Requisition"])
    U2(["Auto-Generate Candidates"])
    U3(["Import Candidates via Excel"])
    U4(["Change Candidate Status"])
    U5(["Export Candidates"])
    U6(["View Remaining Balance"])
  end
  HR --- U1
  HR --- U3
  HR --- U4
  HR --- U5
  HR --- U6
  U1 -.->|include| U2
  U3 -.->|extend| U4

sequenceDiagram
  actor HR as HR Officer
  participant C as ManpowerController
  participant S as Requisition Service
  participant XL as Excel Handler
  participant DB as Database
  HR->>C: submitRequisition(designationCounts)
  C->>S: computeGrandTotals()
  S->>DB: save Manpower
  C->>S: createCandidatesFromManpower()
  loop each demand unit
    S->>DB: insert ManpowerCandidate Pending
  end
  S-->>C: remaining balance
  HR->>C: importExcel(file)
  C->>XL: validateHeaders()
  alt duplicate passport or over balance
    XL-->>HR: reject rows
  else valid rows
    XL->>DB: insert candidates
  end
  HR->>C: updateStatus(Approved)
  C->>DB: set status

flowchart LR
  E1["HR Officer"]
  E2["Excel File"]
  P1(("1.0 Capture Requisition"))
  P2(("2.0 Compute Balance"))
  P3(("3.0 Generate Candidates"))
  P4(("4.0 Import and Export"))
  P5(("5.0 Update Status"))
  D1[("D1 Manpower")]
  D2[("D2 ManpowerCandidates")]
  E1 -->|counts| P1
  P1 -->|requisition| D1
  D1 -->|totals| P2
  P2 -->|demand units| P3
  P3 -->|placeholders| D2
  E2 -->|rows| P4
  P4 -->|validated| D2
  E1 -->|decision| P5
  P5 -->|status| D2

flowchart LR
  HR["HR Officer"]
  XL["Excel File"]
  P41(("4.1 Validate Headers"))
  P42(("4.2 Reject Duplicate Passports"))
  P43(("4.3 Check Remaining Balance"))
  P44(("4.4 Insert Candidates"))
  P45(("4.5 Export Sheets"))
  D2[("D2 ManpowerCandidates")]
  XL -->|upload| P41
  P41 -->|clean rows| P42
  P42 -->|unique| P43
  P43 -->|within balance| P44
  P44 -->|new rows| D2
  D2 -->|records| P45
  P45 -->|file| HR

classDiagram
  class RequisitionService {
    <<interface>>
    +computeGrandTotals(manpower)
    +createCandidatesFromManpower(manpower)
  }
  class ManpowerRequisitionService {
    +computeGrandTotals(manpower)
    +createCandidatesFromManpower(manpower)
    +remainingBalance(manpower)
  }
  class ManpowerController {
    +store(request)
    +import(file)
    +export()
  }
  class Manpower {
    +int id
    +string designation
    +int grandTotal
    +int remaining
    +candidates()
  }
  class ManpowerCandidate {
    +int manpower_id
    +string passport
    +string status
    +manpower()
  }
  RequisitionService <|.. ManpowerRequisitionService
  ManpowerController ..> RequisitionService
  Manpower "1" --> "0..*" ManpowerCandidate

flowchart TD
  subgraph Pres["Presentation"]
    V1["Employee Master List"]
    V2["Settings & Permission Views"]
  end
  subgraph App["Application (Controllers)"]
    C1["EmployeeController"]
    C2["DepartmentController"]
    C3["KPIController"]
  end
  subgraph Dom["Domain (Services/Workflow)"]
    S1["Employee Import / Export"]
    S2["Permission Cache (isHasPermission)"]
    S3["Company Partition (switchCompany)"]
  end
  subgraph Dat["Data (Models/Tables)"]
    M1["Employee (employees)"]
    M2["Company (companies)"]
    M3["Department"]
    M4["UserPermission / Setting"]
  end
  subgraph Ext["External"]
    X1["Excel Files"]
  end
  V1 --> C1
  V2 --> C2
  V2 --> C3
  C1 --> S1
  C1 --> S2
  C1 --> S3
  S1 --> M1
  S2 --> M4
  S3 --> M2
  S3 --> M3
  S1 --> X1

flowchart TD
  A["EmployeeController.assignPermission()"]
  B["normalize (trim + lowercase)"]
  C{"grant or revoke?"}
  D["insert user_permissions row"]
  E["delete user_permissions row"]
  F["flush cached permission set"]
  G["isHasPermission(name) check"]
  A --> B
  B --> C
  C -->|grant| D
  C -->|revoke| E
  D --> F
  E --> F
  F --> G

flowchart LR
  ADM["Administrator"]
  HR["HR"]
  EMP["Employee"]
  SYS["System"]
  subgraph SB["Employee Settings - System Boundary"]
    U1(["Manage Employee Records"])
    U2(["Import / Export Excel"])
    U3(["Assign RBAC Permission"])
    U4(["Switch Company"])
    U5(["Manage Departments"])
    U6(["Configure KPI Fiscal Year"])
    U7(["Update Own Profile"])
  end
  ADM --- U1
  HR --- U2
  ADM --- U3
  HR --- U4
  HR --- U5
  ADM --- U6
  EMP --- U7
  U1 -.->|include| U2
  SYS -.->|enforce| U3

sequenceDiagram
  actor ADM as Administrator
  actor HR as HR
  participant C as EmployeeController
  participant PS as Permission Service
  participant XL as Excel Handler
  participant DB as Database
  HR->>C: openMasterList(company_id)
  C->>DB: query employees by company
  DB-->>C: employee rows
  HR->>C: importEmployees(file)
  C->>XL: validate and parse
  XL->>DB: upsert employees
  ADM->>C: assignPermission(employee, name)
  C->>PS: normalize(trim, lowercase)
  PS->>DB: write user_permissions
  PS->>PS: flush cache
  opt separation status
    DB-->>C: hide as approver and block login
  end

flowchart LR
  E1["Administrator"]
  E2["HR"]
  E3["Employee"]
  P1(("1.0 Manage Employees"))
  P2(("2.0 Import and Export"))
  P3(("3.0 Assign Permissions"))
  P4(("4.0 Partition by Company"))
  P5(("5.0 Configure Settings"))
  D1[("D1 Employees")]
  D2[("D2 User Permissions")]
  D3[("D3 Companies and Settings")]
  E2 -->|record data| P1
  P1 -->|profile| D1
  E2 -->|file| P2
  P2 -->|rows| D1
  E1 -->|grant or revoke| P3
  P3 -->|permission| D2
  P4 -->|company scope| D1
  E1 -->|kpi year| P5
  P5 -->|config| D3
  E3 -->|own profile| P1

flowchart LR
  ADM["Administrator"]
  SYS["Session Middleware"]
  P31(("3.1 Select Employee"))
  P32(("3.2 Normalize Name"))
  P33(("3.3 Grant or Revoke"))
  P34(("3.4 Write user_permissions"))
  P35(("3.5 Cache Permission Check"))
  D2[("D2 User Permissions")]
  ADM -->|permission name| P31
  P31 -->|target| P32
  P32 -->|trimmed lowercase| P33
  P33 -->|change| P34
  P34 -->|rows| D2
  D2 -->|cached set| P35
  P35 -->|authorize| SYS

classDiagram
  class PermissionChecker {
    <<interface>>
    +isHasPermission(employee, name)
    +grant(employee, name)
    +revoke(employee, name)
  }
  class PermissionCacheService {
    +isHasPermission(employee, name)
    +grant(employee, name)
    +revoke(employee, name)
    +normalize(name)
  }
  class EmployeeController {
    +index(company_id)
    +import(file)
    +assignPermission(request)
  }
  class Employee {
    +int id
    +string code
    +int company_id
    +string grade
    +permissions()
  }
  class Company {
    +int id
    +string name
    +string logo
    +employees()
  }
  class Department {
    +int id
    +int company_id
    +string name
    +managers()
  }
  class UserPermission {
    +int employee_id
    +string name
  }
  class Setting {
    +string kpi_year
  }
  PermissionChecker <|.. PermissionCacheService
  EmployeeController ..> PermissionChecker
  Employee "1" --> "0..*" UserPermission
  Company "1" --> "0..*" Employee
  Company "1" --> "0..*" Department

flowchart TD
  subgraph Presentation["Presentation"]
    UI1["Offer Letter Editor"]
    UI2["Approval Queues"]
    UI3["Signatory Config (Admin)"]
  end
  subgraph Application["Application (Controllers)"]
    C1["Employee OfferLetterController"]
    C2["Admin OfferLetterController"]
  end
  subgraph Domain["Domain (Services/Workflow)"]
    W1["Offer Generation"]
    W2["Approval Chain Engine"]
    W3["Return / Reject Handler"]
  end
  subgraph Data["Data (Models/Tables)"]
    M1["OfferLetter"]
    M2["OfferLetterApproval"]
    M3["OfferLetterManage"]
    M4["OfferLetterReturnReject"]
    M5["CandidateRequest"]
  end
  subgraph External["External"]
    E1["PDF Renderer"]
  end
  UI1 --> C1
  UI2 --> C1
  UI3 --> C2
  C1 --> W1
  C1 --> W2
  C1 --> W3
  C2 --> M3
  W1 --> M1
  W1 --> M5
  W2 --> M2
  W3 --> M4
  M1 --> E1

flowchart TD
  subgraph OLC["OfferLetterController"]
    a1["store() : updateOrCreate"]
    a2["approve() : stage transition"]
    a3["returnReject() : reasons + role"]
    a4["deleteOfferLetter()"]
  end
  CR[("candidate_requests.has_offer_letter")]
  MG[("offer_letter_manages")]
  M1[("offer_letters.status")]
  M2[("offer_letter_approvals")]
  M4[("offer_letter_return_rejects")]
  a1 -->|"has_offer_letter = 1"| CR
  a1 -->|"Pending Recruitment Reviewed"| M1
  a2 -->|"Recruitment to HR Director to GM"| M1
  MG -->|"signatory snapshot"| a2
  a2 --> M2
  a3 -->|"Return or Reject"| M1
  a3 --> M4
  a4 --> M1

flowchart LR
  HR["HR / Recruitment Officer"]
  HD["HR Director"]
  GM["General Manager"]
  AD["Administrator"]
  subgraph SB["Offer Letter - System Boundary"]
    U1(["Generate Offer Letter"])
    U2(["Edit Offer Content"])
    U3(["Recruitment Review"])
    U4(["HR Director Approve"])
    U5(["GM Approve"])
    U6(["Return or Reject"])
    U7(["Configure Signatories"])
  end
  HR --- U1
  HR --- U2
  HR --- U3
  HD --- U4
  GM --- U5
  HR --- U6
  HD --- U6
  GM --- U6
  AD --- U7
  U1 -.->|"include"| U2
  U4 -.->|"include"| U7

sequenceDiagram
  actor HR as HR Officer
  actor HD as HR Director
  actor GM as General Manager
  participant C as OfferLetterController
  participant OL as OfferLetter
  participant MG as OfferLetterManage
  participant AP as OfferLetterApproval
  HR->>C: store() from Approved candidate
  C->>OL: updateOrCreate (Pending Recruitment Reviewed)
  HR->>C: approve()
  C-->>OL: Pending HR Director
  HD->>C: approve()
  C->>MG: read HR Director signatory
  C->>AP: snapshot signature
  C-->>OL: Pending GM Approval
  GM->>C: approve()
  C->>MG: read GM signatory
  C->>AP: snapshot signature
  C-->>OL: Approved
  opt Any stage
    HR->>C: returnReject()
    C-->>OL: Return or Reject
  end

flowchart LR
  HR["HR Officer"]
  HD["HR Director"]
  GM["General Manager"]
  AD["Administrator"]
  p1(("1.0 Generate Offer"))
  p2(("2.0 Recruitment Review"))
  p3(("3.0 Director & GM Approval"))
  p4(("4.0 Return / Reject"))
  d1[("D1 Offer Letters")]
  d2[("D2 Approvals")]
  d3[("D3 Signatory Config")]
  HR -->|"candidate & content"| p1
  p1 -->|"Pending Recruitment Reviewed"| d1
  HR -->|"review"| p2
  p2 --> d1
  HD -->|"approve"| p3
  GM -->|"approve"| p3
  d3 -->|"name / position / signature"| p3
  p3 --> d2
  p3 -->|"Approved"| d1
  AD -->|"signatory setup"| d3
  HR -->|"return / reject"| p4
  p4 -->|"reasons + role"| d1

flowchart LR
  d1[("D1 Offer Letters")]
  d3[("D3 Signatory Config")]
  HD["HR Director"]
  GM["General Manager"]
  p31(("3.1 HR Director Approve"))
  p32(("3.2 Snapshot Signatory"))
  p33(("3.3 GM Approve"))
  d2[("D2 Approvals")]
  d1 -->|"Pending HR Director"| p31
  HD --> p31
  p31 -->|"Pending GM Approval"| p32
  d3 -->|"per company signatory"| p32
  p32 --> d2
  p32 --> p33
  GM --> p33
  p33 -->|"Approved"| d1
  p33 --> d2

classDiagram
  class OfferLetterController {
    +store()
    +approve()
    +returnReject()
  }
  class ApprovalStage {
    <<interface>>
    +approve(letter)
  }
  class HrDirectorStage {
    +approve(letter)
  }
  class GmApprovalStage {
    +approve(letter)
  }
  class OfferLetter {
    +int id
    +string candidate_request_id
    +string status
    +bool basic_salary_enabled
    +candidateRequest()
  }
  class OfferLetterApproval {
    +int offer_letter_id
    +string name
    +string position
    +string signature
  }
  class OfferLetterManage {
    +int company_id
    +string hr_director_name
    +string gm_approval_name
  }
  class OfferLetterReturnReject {
    +int offer_letter_request_id
    +string reason
    +string role
  }
  OfferLetterController ..> ApprovalStage
  ApprovalStage <|.. HrDirectorStage
  ApprovalStage <|.. GmApprovalStage
  OfferLetter "1" --> "*" OfferLetterApproval : stamped by
  OfferLetter "1" --> "*" OfferLetterReturnReject : logs
  OfferLetterManage "1" --> "*" OfferLetterApproval : supplies

flowchart TD
  subgraph Presentation["Presentation"]
    UI1["HR & Interview UI"]
    UI2["Agency Portal (Session)"]
  end
  subgraph Application["Application (Controllers)"]
    C1["Workers"]
    C2["WorkersEgencyController"]
  end
  subgraph Domain["Domain (Services/Workflow)"]
    W1["Requisition & Status Workflow"]
    W2["Interview Scoring"]
    W3["Acceptance Decision"]
  end
  subgraph Data["Data (Models/Tables)"]
    M1["WorkersRequest"]
    M2["WorkersAgencyApplication"]
    M3["WorkersInterview"]
    M4["WorkersHrUse / HrOffer / Immigration"]
    M6["WorkersEgency"]
  end
  subgraph External["External"]
    E1["Recruitment Agency"]
  end
  UI1 --> C1
  UI2 --> C1
  UI2 --> C2
  E1 --> UI2
  C1 --> W1
  C1 --> W2
  C1 --> W3
  C2 --> M6
  W1 --> M1
  W1 --> M2
  W2 --> M3
  W3 --> M4

flowchart TD
  subgraph Workers["Workers Controller"]
    m1["store() : create blank rows"]
    m2["store_all_applications() : agency submit"]
    m3["confirmRowsHrReviewed() : assign interviewers"]
    m4["storeInterviewerFirst() / storeInterviewerSecond()"]
    m5["storeHrUse() : proceed & salary"]
    m6["storeHrOffer() : offer terms"]
    m7["storeImmigration() : record visa"]
    m8["hrDirectorConfirm() / hrDirectorReject()"]
  end
  DB[("workers_agency_applications.status")]
  m1 -->|"Pending Agency"| DB
  m2 -->|"Pending HR Reviewed"| DB
  m3 -->|"Pending First Interviewer"| DB
  m4 -->|"Pending HR Checked"| DB
  m5 -->|"Pending HR Offer"| DB
  m6 -->|"Pending Immigration"| DB
  m7 -->|"Pending HR Director"| DB
  m8 -->|"Accepted / Rejected"| DB

flowchart LR
  HR["HR / Recruitment Officer"]
  AG["Recruitment Agency"]
  IN["Interviewer"]
  HD["HR Director"]
  subgraph SB["Worker Recruitment - System Boundary"]
    U1(["Create Agency"])
    U2(["Raise Bulk Requisition"])
    U3(["Submit Applications"])
    U4(["Score Interviews"])
    U5(["Record HR Use / Offer"])
    U6(["Record Immigration"])
    U7(["Accept or Reject"])
  end
  HR --- U1
  HR --- U2
  HR --- U5
  HR --- U6
  AG --- U3
  IN --- U4
  HD --- U7
  U2 -.->|"include"| U3
  U3 -.->|"include"| U4
  U7 -.->|"extend"| U6

sequenceDiagram
  actor HR as HR Officer
  actor AG as Recruitment Agency
  actor HD as HR Director
  participant C as Workers Controller
  participant M as WorkersAgencyApplication
  participant I as WorkersInterview
  HR->>C: store() bulk requisition
  C->>M: create blank rows Pending Agency
  AG->>C: store_all_applications()
  C-->>M: update Pending HR Reviewed
  HR->>C: confirmRowsHrReviewed()
  C-->>M: Pending First Interviewer
  loop Each interview
    HR->>C: storeInterviewerFirst()
    C->>I: create interview score
  end
  opt HR Use and Offer
    HR->>C: storeHrUse() and storeHrOffer()
    C-->>M: Pending Immigration
  end
  HD->>C: hrDirectorConfirm()
  C-->>M: Accepted or Rejected

flowchart LR
  HR["HR Officer"]
  AG["Recruitment Agency"]
  HD["HR Director"]
  p1(("1.0 Raise Requisition"))
  p2(("2.0 Submit Applications"))
  p3(("3.0 Conduct Interviews"))
  p4(("4.0 Employment & Immigration"))
  p5(("5.0 Director Decision"))
  d1[("D1 Worker Requests")]
  d2[("D2 Applications")]
  d3[("D3 Interviews")]
  HR -->|"designations & counts"| p1
  p1 -->|"blank rows"| d2
  p1 --> d1
  AG -->|"worker bio & documents"| p2
  p2 --> d2
  d2 -->|"reviewed rows"| p3
  p3 -->|"scores"| d3
  p3 --> p4
  p4 -->|"offer & visa"| d2
  p4 --> p5
  HD -->|"accept / reject"| p5
  p5 -->|"final status"| d2

flowchart LR
  d2[("D2 Applications")]
  HR["HR Officer"]
  p41(("4.1 Record HR Use"))
  p42(("4.2 Build HR Offer"))
  p43(("4.3 Record Immigration"))
  d4[("D4 HR Use")]
  d5[("D5 HR Offer")]
  d6[("D6 Immigration")]
  d2 -->|"Pending HR Checked rows"| p41
  HR -->|"proceed & salary"| p41
  p41 --> d4
  p41 -->|"Pending HR Offer"| p42
  HR -->|"salary, OT, allowances, contract"| p42
  p42 --> d5
  p42 -->|"Pending Immigration"| p43
  HR -->|"visa & recruitment number"| p43
  p43 --> d6
  p43 -->|"Pending HR Director"| d2

classDiagram
  class Workers {
    +store()
    +confirmRowsHrReviewed()
    +storeHrUse()
    +hrDirectorConfirm()
  }
  class RecruitmentStage {
    <<interface>>
    +advance(app)
  }
  class InterviewStage {
    +advance(app)
  }
  class OfferStage {
    +advance(app)
  }
  class WorkersRequest {
    +int id
    +int agency_id
    +string status
    +applications()
  }
  class WorkersAgencyApplication {
    +int id
    +int worker_request_id
    +string status
    +json interviewers
    +worker_request()
  }
  class WorkersInterview {
    +int worker_application_id
    +string selection_status
    +string overall_interview_evaluation
  }
  class WorkersEgency {
    +int id
    +string email
    +string password_show
  }
  Workers ..> RecruitmentStage
  RecruitmentStage <|.. InterviewStage
  RecruitmentStage <|.. OfferStage
  WorkersEgency "1" --> "*" WorkersRequest : receives
  WorkersRequest "1" --> "*" WorkersAgencyApplication : contains
  WorkersAgencyApplication "1" --> "*" WorkersInterview : scored by

flowchart TD
  subgraph pres["Presentation"]
    V1["Announcement Index"]
    V2["Create Announcement"]
  end
  subgraph app["Application (Controllers)"]
    AC["AnnouncementController"]
  end
  subgraph dom["Domain (Services/Workflow)"]
    PUB["Publish and Window Scope"]
    CNF["Confirmation Ledger"]
    GRD["Deletion Guard"]
  end
  subgraph data["Data (Models/Tables)"]
    AN["Announcement (announcements)"]
    AE["AnnouncementEmployee (announcement_employees)"]
  end
  V1 --> AC
  V2 --> AC
  AC --> PUB
  AC --> CNF
  AC --> GRD
  PUB --> AN
  CNF --> AE
  GRD --> AE

flowchart TD
  STORE["store() validate and create"]
  PUB["publish() status Published"]
  CONF["confirm() firstOrCreate ledger"]
  DEL["destroy() guarded delete"]
  subgraph model["Announcement"]
    SP["scopePublished(window)"]
    SNC["scopeNotConfirmedBy(emp)"]
    CNT["confirmations count"]
  end
  AE["AnnouncementEmployee"]
  STORE --> SP
  PUB --> SP
  CONF --> AE
  DEL --> CNT
  SNC --> AE

flowchart LR
  HR["HR / Employee Relations"]
  AUTH["Authorised Employee"]
  EMP["Employee"]
  subgraph sb["HR Announcement - System Boundary"]
    UC1(["Author Announcement"])
    UC2(["Publish / Unpublish"])
    UC3(["View Announcement"])
    UC4(["Confirm Read"])
    UC5(["Delete Announcement"])
  end
  HR --- UC1
  HR --- UC2
  AUTH --- UC1
  EMP --- UC3
  EMP --- UC4
  HR --- UC5
  UC3 -.->|extend| UC4
  UC5 -.->|guarded by| UC4

sequenceDiagram
  actor HR as HR Staff
  actor EMP as Employee
  participant AC as AnnouncementController
  participant AN as announcements
  participant AE as announcement_employees
  HR->>AC: store(title, priority, window)
  AC->>AN: create announcement
  HR->>AC: publish(announcement)
  AC->>AN: status = Published
  EMP->>AC: confirm(announcement)
  AC->>AE: firstOrCreate(read_date = now)
  AE-->>EMP: confirmation recorded
  opt delete requested
    HR->>AC: destroy(announcement)
    AC->>AE: count confirmations
    alt confirmations exist
      AC-->>HR: deletion blocked
    else none exist
      AC->>AN: delete
    end
  end

flowchart LR
  HR["HR Staff"]
  EMP["Employee"]
  P1(("1.0 Author Announcement"))
  P2(("2.0 Publish and Scope"))
  P3(("3.0 Confirm Read"))
  D1[("D1 announcements")]
  D2[("D2 announcement_employees")]
  HR -->|announcement data| P1
  P1 -->|draft record| D1
  HR -->|publish| P2
  P2 -->|status and window| D1
  D1 -->|published items| EMP
  EMP -->|read confirmation| P3
  P3 -->|timestamped row| D2

flowchart LR
  EMP["Employee"]
  HR["HR Staff"]
  P31(("3.1 Check Require Confirmation"))
  P32(("3.2 Record Read Timestamp"))
  P33(("3.3 Evaluate Deletion Guard"))
  D1[("D1 announcements")]
  D2[("D2 announcement_employees")]
  EMP -->|read action| P31
  P31 -->|timestamp| P32
  P32 -->|firstOrCreate| D2
  HR -->|delete request| P33
  D2 -->|confirmation count| P33
  P33 -->|allow or block| D1

classDiagram
  class AnnouncementRepository {
    <<interface>>
    +publish(id)
    +recordConfirmation(id, employeeId)
    +canDelete(id)
  }
  class AnnouncementController {
    +store(request)
    +publish(announcement)
    +confirm(request, announcement)
    +destroy(announcement)
  }
  class Announcement {
    +int id
    +string title
    +string priority
    +date published_date
    +date expiry_date
    +bool require_confirmation
    +string status
    +scopePublished()
    +confirmations()
  }
  class AnnouncementEmployee {
    +int announcement_id
    +int employee_id
    +datetime read_date
    +employee()
    +announcement()
  }
  class Employee {
    +int id
    +string empName
  }
  AnnouncementController ..> AnnouncementRepository
  AnnouncementRepository <|.. Announcement
  Announcement "1" --> "0..*" AnnouncementEmployee : confirmations
  AnnouncementEmployee "*" --> "1" Employee