initial refactori trasnfer to laying, and depretitation to 25 week

add excel export for purchase supplier report

See merge request mbugroup/lti-api!563

docs/openapi/read-api.json

@@ -3215,6 +3215,55 @@
         ]
       }
     },
+    "/api/inventory/stock-logs/": {
+      "get": {
+        "description": "Read access to `/api/inventory/stock-logs`.",
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PaginatedEnvelope"
+                }
+              }
+            },
+            "description": "Successful response"
+          },
+          "401": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorEnvelope"
+                }
+              }
+            },
+            "description": "Unauthorized"
+          },
+          "403": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorEnvelope"
+                }
+              }
+            },
+            "description": "Forbidden"
+          }
+        },
+        "security": [
+          {
+            "ApiKeyAuth": []
+          },
+          {
+            "BearerAuth": []
+          }
+        ],
+        "summary": "GET api / inventory / stock logs",
+        "tags": [
+          "Inventory"
+        ]
+      }
+    },
     "/api/inventory/transfers/": {
       "get": {
         "description": "Read access to `/api/inventory/transfers`.",
@@ -4318,6 +4367,29 @@
           "200": {
             "content": {
               "application/json": {
+                "example": {
+                  "code": 200,
+                  "data": [
+                    {
+                      "created_at": "2026-01-01T00:00:00Z",
+                      "created_user": {
+                        "id": 1,
+                        "name": "Admin"
+                      },
+                      "id": 1,
+                      "name": "FCR Broiler Standard",
+                      "updated_at": "2026-01-01T00:00:00Z"
+                    }
+                  ],
+                  "message": "Get all fcrs successfully",
+                  "meta": {
+                    "limit": 10,
+                    "page": 1,
+                    "total_pages": 1,
+                    "total_results": 1
+                  },
+                  "status": "success"
+                },
                 "schema": {
                   "$ref": "#/components/schemas/PaginatedEnvelope"
                 }
@@ -4379,6 +4451,41 @@
           "200": {
             "content": {
               "application/json": {
+                "example": {
+                  "code": 200,
+                  "data": {
+                    "created_at": "2026-01-01T00:00:00Z",
+                    "created_user": {
+                      "id": 1,
+                      "name": "Admin"
+                    },
+                    "fcr_standards": [
+                      {
+                        "fcr_number": 1.2,
+                        "id": 1,
+                        "mortality": 0.5,
+                        "weight": 0.5
+                      },
+                      {
+                        "fcr_number": 1.35,
+                        "id": 2,
+                        "mortality": 0.3,
+                        "weight": 1
+                      },
+                      {
+                        "fcr_number": 1.5,
+                        "id": 3,
+                        "mortality": 0.25,
+                        "weight": 1.5
+                      }
+                    ],
+                    "id": 1,
+                    "name": "FCR Broiler Standard",
+                    "updated_at": "2026-01-01T00:00:00Z"
+                  },
+                  "message": "Get fcr successfully",
+                  "status": "success"
+                },
                 "schema": {
                   "$ref": "#/components/schemas/SuccessEnvelope"
                 }
@@ -6457,6 +6564,126 @@
         ]
       }
     },
+    "/api/production/chickins/": {
+      "get": {
+        "description": "Read access to `/api/production/chickins`.",
+        "parameters": [
+          {
+            "description": "Page number.",
+            "example": 1,
+            "in": "query",
+            "name": "page",
+            "required": false,
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "Page size.",
+            "example": 10,
+            "in": "query",
+            "name": "limit",
+            "required": false,
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "Project flock kandang id filter.",
+            "example": 1,
+            "in": "query",
+            "name": "project_flock_kandang_id",
+            "required": false,
+            "schema": {
+              "type": "integer"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "example": {
+                  "code": 200,
+                  "data": [
+                    {
+                      "chick_in_date": "2026-01-01T00:00:00Z",
+                      "created_at": "2026-01-01T00:00:00Z",
+                      "created_user": {
+                        "id": 1,
+                        "name": "Admin"
+                      },
+                      "id": 1,
+                      "notes": "",
+                      "pending_usage_qty": 0,
+                      "product_warehouse": {
+                        "id": 1,
+                        "product": {
+                          "id": 1,
+                          "name": "DOC Broiler"
+                        },
+                        "warehouse": {
+                          "id": 1,
+                          "name": "Gudang DOC"
+                        }
+                      },
+                      "product_warehouse_id": 1,
+                      "project_flock_kandang_id": 1,
+                      "updated_at": "2026-01-01T00:00:00Z",
+                      "usage_qty": 10000
+                    }
+                  ],
+                  "message": "Get all chickins successfully",
+                  "meta": {
+                    "limit": 10,
+                    "page": 1,
+                    "total_pages": 1,
+                    "total_results": 1
+                  },
+                  "status": "success"
+                },
+                "schema": {
+                  "$ref": "#/components/schemas/PaginatedEnvelope"
+                }
+              }
+            },
+            "description": "Successful response"
+          },
+          "401": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorEnvelope"
+                }
+              }
+            },
+            "description": "Unauthorized"
+          },
+          "403": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorEnvelope"
+                }
+              }
+            },
+            "description": "Forbidden"
+          }
+        },
+        "security": [
+          {
+            "ApiKeyAuth": []
+          },
+          {
+            "BearerAuth": []
+          }
+        ],
+        "summary": "GET api / production / chickins",
+        "tags": [
+          "Production"
+        ]
+      }
+    },
     "/api/production/chickins/{id}": {
       "get": {
         "description": "Read access to `/api/production/chickins/:id`.",
@@ -7517,6 +7744,47 @@
           "200": {
             "content": {
               "application/json": {
+                "example": {
+                  "code": 200,
+                  "data": [
+                    {
+                      "approval": {
+                        "action": null,
+                        "step_name": "Pengajuan",
+                        "step_number": 1
+                      },
+                      "created_at": "2026-01-15T00:00:00Z",
+                      "created_by": 1,
+                      "created_user": {
+                        "id": 1,
+                        "name": "Admin"
+                      },
+                      "economic_cutoff_date": "2026-01-20T00:00:00Z",
+                      "effective_move_date": "2026-01-18T00:00:00Z",
+                      "executed_at": null,
+                      "from_project_flock": {
+                        "flock_name": "Flock A Period 1",
+                        "id": 1
+                      },
+                      "id": 1,
+                      "notes": "",
+                      "to_project_flock": {
+                        "flock_name": "Flock B Period 1",
+                        "id": 2
+                      },
+                      "transfer_date": "2026-01-15T00:00:00Z",
+                      "transfer_number": "TL-00001"
+                    }
+                  ],
+                  "message": "Get all transferLayings successfully",
+                  "meta": {
+                    "limit": 10,
+                    "page": 1,
+                    "total_pages": 1,
+                    "total_results": 1
+                  },
+                  "status": "success"
+                },
                 "schema": {
                   "$ref": "#/components/schemas/PaginatedEnvelope"
                 }
@@ -7700,6 +7968,69 @@
           "200": {
             "content": {
               "application/json": {
+                "example": {
+                  "code": 200,
+                  "data": {
+                    "approval": {
+                      "action": null,
+                      "step_name": "Pengajuan",
+                      "step_number": 1
+                    },
+                    "created_at": "2026-01-15T00:00:00Z",
+                    "created_by": 1,
+                    "created_user": {
+                      "id": 1,
+                      "name": "Admin"
+                    },
+                    "economic_cutoff_date": "2026-01-20T00:00:00Z",
+                    "effective_move_date": "2026-01-18T00:00:00Z",
+                    "executed_at": null,
+                    "from_project_flock": {
+                      "flock_name": "Flock A Period 1",
+                      "id": 1
+                    },
+                    "id": 1,
+                    "notes": "",
+                    "sources": [
+                      {
+                        "note": "",
+                        "qty": 5000,
+                        "source_project_flock_kandang": {
+                          "id": 1,
+                          "kandang": {
+                            "id": 1,
+                            "name": "Kandang A"
+                          },
+                          "kandang_id": 1,
+                          "project_flock_id": 1
+                        }
+                      }
+                    ],
+                    "targets": [
+                      {
+                        "note": "",
+                        "qty": 5000,
+                        "target_project_flock_kandang": {
+                          "id": 2,
+                          "kandang": {
+                            "id": 2,
+                            "name": "Kandang B"
+                          },
+                          "kandang_id": 2,
+                          "project_flock_id": 2
+                        }
+                      }
+                    ],
+                    "to_project_flock": {
+                      "flock_name": "Flock B Period 1",
+                      "id": 2
+                    },
+                    "transfer_date": "2026-01-15T00:00:00Z",
+                    "transfer_number": "TL-00001"
+                  },
+                  "message": "Get transferLaying successfully",
+                  "status": "success"
+                },
                 "schema": {
                   "$ref": "#/components/schemas/SuccessEnvelope"
                 }
@@ -8912,6 +9243,55 @@
         ]
       }
     },
+    "/api/reports/hpp-v2-breakdown": {
+      "get": {
+        "description": "Read access to `/api/reports/hpp-v2-breakdown`.",
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PaginatedEnvelope"
+                }
+              }
+            },
+            "description": "Successful response"
+          },
+          "401": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorEnvelope"
+                }
+              }
+            },
+            "description": "Unauthorized"
+          },
+          "403": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorEnvelope"
+                }
+              }
+            },
+            "description": "Forbidden"
+          }
+        },
+        "security": [
+          {
+            "ApiKeyAuth": []
+          },
+          {
+            "BearerAuth": []
+          }
+        ],
+        "summary": "GET api / reports / hpp v2 breakdown",
+        "tags": [
+          "Reports"
+        ]
+      }
+    },
     "/api/reports/marketing": {
       "get": {
         "description": "Read access to `/api/reports/marketing`.",
@@ -9555,6 +9935,55 @@
         ]
       }
     },
+    "/api/system-settings/": {
+      "get": {
+        "description": "Read access to `/api/system-settings`.",
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PaginatedEnvelope"
+                }
+              }
+            },
+            "description": "Successful response"
+          },
+          "401": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorEnvelope"
+                }
+              }
+            },
+            "description": "Unauthorized"
+          },
+          "403": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorEnvelope"
+                }
+              }
+            },
+            "description": "Forbidden"
+          }
+        },
+        "security": [
+          {
+            "ApiKeyAuth": []
+          },
+          {
+            "BearerAuth": []
+          }
+        ],
+        "summary": "GET api / system settings",
+        "tags": [
+          "API"
+        ]
+      }
+    },
     "/api/users/": {
       "get": {
         "description": "Read access to `/api/users`.",

docs/openapi/read-api.yaml

@@ -2006,6 +2006,34 @@ paths:
             summary: GET api / inventory / product warehouses / :id
             tags:
                 - Inventory
+    /api/inventory/stock-logs/:
+        get:
+            description: Read access to `/api/inventory/stock-logs`.
+            responses:
+                "200":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/PaginatedEnvelope'
+                    description: Successful response
+                "401":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/ErrorEnvelope'
+                    description: Unauthorized
+                "403":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/ErrorEnvelope'
+                    description: Forbidden
+            security:
+                - ApiKeyAuth: []
+                - BearerAuth: []
+            summary: GET api / inventory / stock logs
+            tags:
+                - Inventory
     /api/inventory/transfers/:
         get:
             description: Read access to `/api/inventory/transfers`.
@@ -2686,6 +2714,23 @@ paths:
                 "200":
                     content:
                         application/json:
+                            example:
+                                code: 200
+                                data:
+                                    - created_at: "2026-01-01T00:00:00Z"
+                                      created_user:
+                                        id: 1
+                                        name: Admin
+                                      id: 1
+                                      name: FCR Broiler Standard
+                                      updated_at: "2026-01-01T00:00:00Z"
+                                message: Get all fcrs successfully
+                                meta:
+                                    limit: 10
+                                    page: 1
+                                    total_pages: 1
+                                    total_results: 1
+                                status: success
                             schema:
                                 $ref: '#/components/schemas/PaginatedEnvelope'
                     description: Successful response
@@ -2722,6 +2767,31 @@ paths:
                 "200":
                     content:
                         application/json:
+                            example:
+                                code: 200
+                                data:
+                                    created_at: "2026-01-01T00:00:00Z"
+                                    created_user:
+                                        id: 1
+                                        name: Admin
+                                    fcr_standards:
+                                        - fcr_number: 1.2
+                                          id: 1
+                                          mortality: 0.5
+                                          weight: 0.5
+                                        - fcr_number: 1.35
+                                          id: 2
+                                          mortality: 0.3
+                                          weight: 1
+                                        - fcr_number: 1.5
+                                          id: 3
+                                          mortality: 0.25
+                                          weight: 1.5
+                                    id: 1
+                                    name: FCR Broiler Standard
+                                    updated_at: "2026-01-01T00:00:00Z"
+                                message: Get fcr successfully
+                                status: success
                             schema:
                                 $ref: '#/components/schemas/SuccessEnvelope'
                     description: Successful response
@@ -3994,6 +4064,86 @@ paths:
             summary: GET api / master data / warehouses / :id
             tags:
                 - Master Data
+    /api/production/chickins/:
+        get:
+            description: Read access to `/api/production/chickins`.
+            parameters:
+                - description: Page number.
+                  example: 1
+                  in: query
+                  name: page
+                  required: false
+                  schema:
+                    type: integer
+                - description: Page size.
+                  example: 10
+                  in: query
+                  name: limit
+                  required: false
+                  schema:
+                    type: integer
+                - description: Project flock kandang id filter.
+                  example: 1
+                  in: query
+                  name: project_flock_kandang_id
+                  required: false
+                  schema:
+                    type: integer
+            responses:
+                "200":
+                    content:
+                        application/json:
+                            example:
+                                code: 200
+                                data:
+                                    - chick_in_date: "2026-01-01T00:00:00Z"
+                                      created_at: "2026-01-01T00:00:00Z"
+                                      created_user:
+                                        id: 1
+                                        name: Admin
+                                      id: 1
+                                      notes: ""
+                                      pending_usage_qty: 0
+                                      product_warehouse:
+                                        id: 1
+                                        product:
+                                            id: 1
+                                            name: DOC Broiler
+                                        warehouse:
+                                            id: 1
+                                            name: Gudang DOC
+                                      product_warehouse_id: 1
+                                      project_flock_kandang_id: 1
+                                      updated_at: "2026-01-01T00:00:00Z"
+                                      usage_qty: 10000
+                                message: Get all chickins successfully
+                                meta:
+                                    limit: 10
+                                    page: 1
+                                    total_pages: 1
+                                    total_results: 1
+                                status: success
+                            schema:
+                                $ref: '#/components/schemas/PaginatedEnvelope'
+                    description: Successful response
+                "401":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/ErrorEnvelope'
+                    description: Unauthorized
+                "403":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/ErrorEnvelope'
+                    description: Forbidden
+            security:
+                - ApiKeyAuth: []
+                - BearerAuth: []
+            summary: GET api / production / chickins
+            tags:
+                - Production
     /api/production/chickins/{id}:
         get:
             description: Read access to `/api/production/chickins/:id`.
@@ -4664,6 +4814,38 @@ paths:
                 "200":
                     content:
                         application/json:
+                            example:
+                                code: 200
+                                data:
+                                    - approval:
+                                        action: null
+                                        step_name: Pengajuan
+                                        step_number: 1
+                                      created_at: "2026-01-15T00:00:00Z"
+                                      created_by: 1
+                                      created_user:
+                                        id: 1
+                                        name: Admin
+                                      economic_cutoff_date: "2026-01-20T00:00:00Z"
+                                      effective_move_date: "2026-01-18T00:00:00Z"
+                                      executed_at: null
+                                      from_project_flock:
+                                        flock_name: Flock A Period 1
+                                        id: 1
+                                      id: 1
+                                      notes: ""
+                                      to_project_flock:
+                                        flock_name: Flock B Period 1
+                                        id: 2
+                                      transfer_date: "2026-01-15T00:00:00Z"
+                                      transfer_number: TL-00001
+                                message: Get all transferLayings successfully
+                                meta:
+                                    limit: 10
+                                    page: 1
+                                    total_pages: 1
+                                    total_results: 1
+                                status: success
                             schema:
                                 $ref: '#/components/schemas/PaginatedEnvelope'
                     description: Successful response
@@ -4700,6 +4882,53 @@ paths:
                 "200":
                     content:
                         application/json:
+                            example:
+                                code: 200
+                                data:
+                                    approval:
+                                        action: null
+                                        step_name: Pengajuan
+                                        step_number: 1
+                                    created_at: "2026-01-15T00:00:00Z"
+                                    created_by: 1
+                                    created_user:
+                                        id: 1
+                                        name: Admin
+                                    economic_cutoff_date: "2026-01-20T00:00:00Z"
+                                    effective_move_date: "2026-01-18T00:00:00Z"
+                                    executed_at: null
+                                    from_project_flock:
+                                        flock_name: Flock A Period 1
+                                        id: 1
+                                    id: 1
+                                    notes: ""
+                                    sources:
+                                        - note: ""
+                                          qty: 5000
+                                          source_project_flock_kandang:
+                                            id: 1
+                                            kandang:
+                                                id: 1
+                                                name: Kandang A
+                                            kandang_id: 1
+                                            project_flock_id: 1
+                                    targets:
+                                        - note: ""
+                                          qty: 5000
+                                          target_project_flock_kandang:
+                                            id: 2
+                                            kandang:
+                                                id: 2
+                                                name: Kandang B
+                                            kandang_id: 2
+                                            project_flock_id: 2
+                                    to_project_flock:
+                                        flock_name: Flock B Period 1
+                                        id: 2
+                                    transfer_date: "2026-01-15T00:00:00Z"
+                                    transfer_number: TL-00001
+                                message: Get transferLaying successfully
+                                status: success
                             schema:
                                 $ref: '#/components/schemas/SuccessEnvelope'
                     description: Successful response
@@ -5545,6 +5774,34 @@ paths:
             summary: GET api / reports / hpp per kandang
             tags:
                 - Reports
+    /api/reports/hpp-v2-breakdown:
+        get:
+            description: Read access to `/api/reports/hpp-v2-breakdown`.
+            responses:
+                "200":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/PaginatedEnvelope'
+                    description: Successful response
+                "401":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/ErrorEnvelope'
+                    description: Unauthorized
+                "403":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/ErrorEnvelope'
+                    description: Forbidden
+            security:
+                - ApiKeyAuth: []
+                - BearerAuth: []
+            summary: GET api / reports / hpp v2 breakdown
+            tags:
+                - Reports
     /api/reports/marketing:
         get:
             description: Read access to `/api/reports/marketing`.
@@ -5955,6 +6212,34 @@ paths:
             summary: GET api / sso / userinfo
             tags:
                 - SSO
+    /api/system-settings/:
+        get:
+            description: Read access to `/api/system-settings`.
+            responses:
+                "200":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/PaginatedEnvelope'
+                    description: Successful response
+                "401":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/ErrorEnvelope'
+                    description: Unauthorized
+                "403":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/ErrorEnvelope'
+                    description: Forbidden
+            security:
+                - ApiKeyAuth: []
+                - BearerAuth: []
+            summary: GET api / system settings
+            tags:
+                - API
     /api/users/:
         get:
             description: Read access to `/api/users`.

docs/postman/read-api.collection.json

@@ -109,6 +109,19 @@
                 "method": "GET",
                 "url": "{{base_url}}/api/closings/?page=1\u0026limit=10\u0026search=kandang\u0026project_status=1\u0026location_id={{location_id}}"
               }
+            },
+            {
+              "name": "GET api / system settings",
+              "request": {
+                "header": [
+                  {
+                    "key": "Accept",
+                    "value": "application/json"
+                  }
+                ],
+                "method": "GET",
+                "url": "{{base_url}}/api/system-settings/"
+              }
             }
           ],
           "name": "API"
@@ -582,6 +595,19 @@
                 "url": "{{base_url}}/api/inventory/product-warehouses/{{id}}"
               }
             },
+            {
+              "name": "GET api / inventory / stock logs",
+              "request": {
+                "header": [
+                  {
+                    "key": "Accept",
+                    "value": "application/json"
+                  }
+                ],
+                "method": "GET",
+                "url": "{{base_url}}/api/inventory/stock-logs/"
+              }
+            },
             {
               "name": "GET api / inventory / transfers",
               "request": {
@@ -1143,6 +1169,19 @@
         },
         {
           "item": [
+            {
+              "name": "GET api / production / chickins",
+              "request": {
+                "header": [
+                  {
+                    "key": "Accept",
+                    "value": "application/json"
+                  }
+                ],
+                "method": "GET",
+                "url": "{{base_url}}/api/production/chickins/?page=1\u0026limit=10\u0026project_flock_kandang_id={{project_flock_kandang_id}}"
+              }
+            },
             {
               "name": "GET api / production / chickins / :id",
               "request": {
@@ -1478,6 +1517,19 @@
                 "url": "{{base_url}}/api/reports/hpp-per-kandang?page=1\u0026limit=10\u0026period=2026-01-01\u0026show_unrecorded=false\u0026area_id=1,2\u0026location_id=1,2\u0026kandang_id=1,2\u0026weight_min=1.2\u0026weight_max=1.8"
               }
             },
+            {
+              "name": "GET api / reports / hpp v2 breakdown",
+              "request": {
+                "header": [
+                  {
+                    "key": "Accept",
+                    "value": "application/json"
+                  }
+                ],
+                "method": "GET",
+                "url": "{{base_url}}/api/reports/hpp-v2-breakdown"
+              }
+            },
             {
               "name": "GET api / reports / marketing",
               "request": {

internal/apikeys/defaults.go

@@ -89,5 +89,6 @@ func DefaultDashboardPermissions() []string {
 		"lti.users.detail",
 		"lti.users.list",
 		"lti.daily_checklist.master_data.kandang",
+		"lti.production.chickins.list",
 	}
 }

internal/common/repository/common.hppv2.repository.go

@@ -102,11 +102,17 @@ type HppV2CostRepository interface {
 	GetProjectFlockKandangContext(ctx context.Context, projectFlockKandangId uint) (*HppV2ProjectFlockKandangContext, error)
 	GetProjectFlockKandangIDs(ctx context.Context, projectFlockId uint) ([]uint, error)
 	GetLatestTransferInputByProjectFlockKandangID(ctx context.Context, projectFlockKandangId uint, period time.Time) (*HppV2LatestTransferInputRow, error)
+	// GetAllTransferInputsByProjectFlockKandangID return SEMUA approved transfer ke target kandang
+	// itu, untuk skenario multi-source di mana 1 target menerima dari multiple transfer terpisah.
+	// Setiap row = 1 transfer dengan cost basis & chick_in_date sendiri (per source). Order:
+	// effective_date ASC, id ASC (kronologis).
+	GetAllTransferInputsByProjectFlockKandangID(ctx context.Context, projectFlockKandangId uint, period time.Time) ([]HppV2LatestTransferInputRow, error)
 	GetManualDepreciationInputByProjectFlockID(ctx context.Context, projectFlockID uint) (*HppV2ManualDepreciationInputRow, error)
 	GetRecordingStockRoutingAdjustmentCostByProjectFlockID(ctx context.Context, projectFlockID uint, periodDate time.Time) (float64, error)
 	GetFarmDepreciationSnapshotByProjectFlockIDAndPeriod(ctx context.Context, projectFlockID uint, periodDate time.Time) (*HppV2FarmDepreciationSnapshotRow, error)
 	GetEarliestChickInDateByProjectFlockID(ctx context.Context, projectFlockID uint) (*time.Time, error)
-	GetDepreciationPercents(ctx context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, error)
+	GetChickinPopulationByPFKForFarm(ctx context.Context, projectFlockID uint) (map[uint]float64, error)
+	GetMultiplicationPercentages(ctx context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, error)
 	ListUsageCostRowsByProductFlags(ctx context.Context, projectFlockKandangIDs []uint, flagNames []string, date *time.Time) ([]HppV2UsageCostRow, error)
 	ListAdjustmentCostRowsByProductFlags(ctx context.Context, projectFlockKandangIDs []uint, flagNames []string, date *time.Time) ([]HppV2AdjustmentCostRow, error)
 	ListExpenseRealizationRowsByProjectFlockKandangIDs(ctx context.Context, projectFlockKandangIDs []uint, date *time.Time, ekspedisi bool) ([]HppV2ExpenseCostRow, error)
@@ -230,6 +236,62 @@ LIMIT 1
 	return &row, nil
 }
 
+func (r *HppV2RepositoryImpl) GetAllTransferInputsByProjectFlockKandangID(
+	ctx context.Context,
+	projectFlockKandangId uint,
+	period time.Time,
+) ([]HppV2LatestTransferInputRow, error) {
+	var rows []HppV2LatestTransferInputRow
+	query := `
+WITH latest_transfer_approval AS (
+	SELECT a.approvable_id, a.action
+	FROM approvals a
+	JOIN (
+		SELECT approvable_id, MAX(action_at) AS latest_action_at
+		FROM approvals
+		WHERE approvable_type = @approval_type
+		GROUP BY approvable_id
+	) la
+		ON la.approvable_id = a.approvable_id
+		AND la.latest_action_at = a.action_at
+	WHERE a.approvable_type = @approval_type
+),
+approved_transfers AS (
+	SELECT
+		lt.id,
+		lt.from_project_flock_id,
+		COALESCE(DATE(lt.effective_move_date), DATE(lt.economic_cutoff_date), DATE(lt.transfer_date)) AS effective_date
+	FROM laying_transfers lt
+	JOIN latest_transfer_approval lta ON lta.approvable_id = lt.id
+	WHERE lt.deleted_at IS NULL
+	  AND lt.executed_at IS NOT NULL
+	  AND lta.action = 'APPROVED'
+)
+SELECT
+	ltt.target_project_flock_kandang_id AS project_flock_kandang_id,
+	at.from_project_flock_id AS source_project_flock_id,
+	at.effective_date AS transfer_date,
+	ltt.total_qty AS transfer_qty,
+	at.id AS transfer_id
+FROM laying_transfer_targets ltt
+JOIN approved_transfers at ON at.id = ltt.laying_transfer_id
+WHERE ltt.deleted_at IS NULL
+  AND ltt.target_project_flock_kandang_id = @project_flock_kandang_id
+  AND at.effective_date <= DATE(@period_date)
+ORDER BY at.effective_date ASC, at.id ASC
+`
+
+	err := r.db.WithContext(ctx).Raw(query, map[string]any{
+		"approval_type":            utils.ApprovalWorkflowTransferToLaying.String(),
+		"project_flock_kandang_id": projectFlockKandangId,
+		"period_date":              period,
+	}).Scan(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+	return rows, nil
+}
+
 func (r *HppV2RepositoryImpl) GetManualDepreciationInputByProjectFlockID(
 	ctx context.Context,
 	projectFlockID uint,
@@ -373,7 +435,34 @@ func (r *HppV2RepositoryImpl) GetEarliestChickInDateByProjectFlockID(ctx context
 	return selected.ChickInDate, nil
 }
 
-func (r *HppV2RepositoryImpl) GetDepreciationPercents(
+func (r *HppV2RepositoryImpl) GetChickinPopulationByPFKForFarm(
+	ctx context.Context,
+	projectFlockID uint,
+) (map[uint]float64, error) {
+	type row struct {
+		ProjectFlockKandangID uint    `gorm:"column:project_flock_kandang_id"`
+		TotalQty              float64 `gorm:"column:total_qty"`
+	}
+	var rows []row
+	err := r.db.WithContext(ctx).
+		Table("project_chickins AS pc").
+		Select("pc.project_flock_kandang_id, SUM(pc.usage_qty) AS total_qty").
+		Joins("JOIN project_flock_kandangs AS pfk ON pfk.id = pc.project_flock_kandang_id").
+		Where("pc.deleted_at IS NULL").
+		Where("pfk.project_flock_id = ?", projectFlockID).
+		Group("pc.project_flock_kandang_id").
+		Scan(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+	result := make(map[uint]float64, len(rows))
+	for _, x := range rows {
+		result[x.ProjectFlockKandangID] = x.TotalQty
+	}
+	return result, nil
+}
+
+func (r *HppV2RepositoryImpl) GetMultiplicationPercentages(
 	ctx context.Context,
 	houseTypes []string,
 	maxDay int,
@@ -386,17 +475,17 @@ func (r *HppV2RepositoryImpl) GetDepreciationPercents(
 	type row struct {
 		HouseType                string
 		Day                      int
-		DepreciationPercent float64
+		MultiplicationPercentage float64
 	}
 
 	rows := make([]row, 0)
-	err := r.db.WithContext(ctx).
+	err := r.db.WithContext(ctx).Raw(`
-		Table("house_depreciation_standards").
+		SELECT DISTINCT ON (house_type::text, day)
-		Select("house_type::text AS house_type, day, depreciation_percent").
+			house_type::text AS house_type, day, multiplication_percentage
-		Where("house_type::text IN ?", houseTypes).
+		FROM house_depreciation_standards
-		Where("day <= ?", maxDay).
+		WHERE house_type::text IN ? AND day <= ?
-		Order("house_type ASC, day ASC").
+		ORDER BY house_type, day, effective_date DESC NULLS LAST
-		Scan(&rows).Error
+	`, houseTypes, maxDay).Scan(&rows).Error
 	if err != nil {
 		return nil, err
 	}
@@ -405,7 +494,7 @@ func (r *HppV2RepositoryImpl) GetDepreciationPercents(
 		if _, exists := result[item.HouseType]; !exists {
 			result[item.HouseType] = make(map[int]float64)
 		}
-		result[item.HouseType][item.Day] = item.DepreciationPercent
+		result[item.HouseType][item.Day] = item.MultiplicationPercentage
 	}
 
 	return result, nil

internal/common/service/common.depreciation.service.go

@@ -6,8 +6,8 @@ import (
 )
 
 const (
-	depreciationStartAgeDayCloseHouse = 155
+	depreciationStartAgeDayCloseHouse = 175
-	depreciationStartAgeDayOpenHouse  = 176
+	depreciationStartAgeDayOpenHouse  = 175
 )
 
 func NormalizeDepreciationHouseType(raw string) string {
@@ -26,8 +26,8 @@ func DepreciationStartAgeDay(houseType string) int {
 }
 
 func FlockAgeDay(originDate time.Time, periodDate time.Time) int {
-	origin := time.Date(originDate.Year(), originDate.Month(), originDate.Day(), 0, 0, 0, 0, originDate.Location())
+	origin := time.Date(originDate.Year(), originDate.Month(), originDate.Day(), 0, 0, 0, 0, time.UTC)
-	period := time.Date(periodDate.Year(), periodDate.Month(), periodDate.Day(), 0, 0, 0, 0, periodDate.Location())
+	period := time.Date(periodDate.Year(), periodDate.Month(), periodDate.Day(), 0, 0, 0, 0, time.UTC)
 	if period.Before(origin) {
 		return 0
 	}
@@ -47,9 +47,9 @@ func CalculateDepreciationAtDayN(
 	initialPulletCost float64,
 	dayN int,
 	houseType string,
-	percentByHouseType map[string]map[int]float64,
+	multiplicationByHouseType map[string]map[int]float64,
 ) (float64, float64, float64) {
-	return CalculateDepreciationFromDayRange(initialPulletCost, 1, dayN, houseType, percentByHouseType)
+	return CalculateDepreciationFromDayRange(initialPulletCost, 1, dayN, houseType, multiplicationByHouseType)
 }
 
 func CalculateDepreciationFromDayRange(
@@ -57,8 +57,8 @@ func CalculateDepreciationFromDayRange(
 	startDay int,
 	endDay int,
 	houseType string,
-	percentByHouseType map[string]map[int]float64,
+	multiplicationByHouseType map[string]map[int]float64,
-) (float64, float64, float64) {
+) (pulletCostDayN, depreciationValue, multiplicationPercentage float64) {
 	if initialPulletCost <= 0 || endDay <= 0 {
 		return 0, 0, 0
 	}
@@ -70,30 +70,30 @@ func CalculateDepreciationFromDayRange(
 	}
 
 	normalizedHouseType := NormalizeDepreciationHouseType(houseType)
-	housePercent, exists := percentByHouseType[normalizedHouseType]
+	houseMult, exists := multiplicationByHouseType[normalizedHouseType]
 	if !exists {
 		return 0, 0, 0
 	}
 
 	current := initialPulletCost
-	pulletCostDayN := 0.0
-	depreciationValue := 0.0
-	depreciationPercent := 0.0
 	for day := startDay; day <= endDay; day++ {
-		pct := housePercent[day]
+		mult, ok := houseMult[day]
-		dep := current * (pct / 100)
+		if !ok {
+			// No standard for this day → assume no depreciation (mult=1).
+			mult = 1.0
+		}
 		if day == endDay {
 			pulletCostDayN = current
-			depreciationValue = dep
+			multiplicationPercentage = mult
-			depreciationPercent = pct
+			depreciationValue = current * (1.0 - mult)
 		}
-		current -= dep
+		current = current * mult
 		if current < 0 {
 			current = 0
 		}
 	}
 
-	return pulletCostDayN, depreciationValue, depreciationPercent
+	return pulletCostDayN, depreciationValue, multiplicationPercentage
 }
 
 func CalculateEffectiveDepreciationPercent(totalDepreciationValue, totalPulletCostDayN float64) float64 {

internal/common/service/common.hppv2.service.go

@@ -1191,27 +1191,73 @@ func (s *hppV2Service) getDepreciationComponent(
 		}, nil
 	}
 
+	// Multi-source support: 1 target kandang bisa menerima dari MULTIPLE transfer terpisah
+	// (tiap transfer = 1 source kandang). Depresiasi per target = SUM dari per-transfer depresiasi.
+	// Setiap transfer dihitung dengan chick_in_date source-nya sendiri dan cost basis pro-rated
+	// berdasarkan qty share (transfer.qty / totalTransferQty).
+	transferInputs, err := s.hppRepo.GetAllTransferInputsByProjectFlockKandangID(context.Background(), projectFlockKandangId, periodDate)
+	if err != nil {
+		return nil, err
+	}
+
+	// Filter valid transfers (punya source flock id)
+	validTransfers := make([]commonRepo.HppV2LatestTransferInputRow, 0, len(transferInputs))
+	totalTransferQty := 0.0
+	for _, t := range transferInputs {
+		if t.SourceProjectFlockID == 0 {
+			continue
+		}
+		validTransfers = append(validTransfers, t)
+		totalTransferQty += t.TransferQty
+	}
+
+	if len(validTransfers) > 0 {
 		if totalPulletCost <= 0 {
 			return nil, nil
 		}
 
-	transferInput, err := s.hppRepo.GetLatestTransferInputByProjectFlockKandangID(context.Background(), projectFlockKandangId, periodDate)
+		totalDepreciation := 0.0
-	if err != nil {
+		parts := make([]HppV2ComponentPart, 0, len(validTransfers))
-		return nil, err
+		for i := range validTransfers {
+			t := validTransfers[i]
+			// Pro-rate cost basis per transfer berdasarkan qty share.
+			// CATATAN: pendekatan ini AKURAT kalau cost per ekor sama antar source flock.
+			// Kalau cost per ekor berbeda signifikan antar source, follow-up: refactor
+			// `buildGrowingUsagePart` untuk multi-source-flock cost computation.
+			transferCostBasis := totalPulletCost
+			if totalTransferQty > 0 && len(validTransfers) > 1 {
+				transferCostBasis = totalPulletCost * (t.TransferQty / totalTransferQty)
 			}
 
-	var part *HppV2ComponentPart
+			part, partErr := s.buildNormalTransferDepreciationPart(contextRow, &t, periodDate, transferCostBasis)
-	if transferInput != nil && transferInput.SourceProjectFlockID > 0 {
+			if partErr != nil {
-		part, err = s.buildNormalTransferDepreciationPart(contextRow, transferInput, periodDate, totalPulletCost)
+				return nil, partErr
+			}
+			if part == nil {
+				continue
+			}
+			totalDepreciation += part.Total
+			parts = append(parts, *part)
+		}
+
+		if len(parts) == 0 {
+			return nil, nil
+		}
+
+		return &HppV2Component{
+			Code:   hppV2ComponentDepreciation,
+			Title:  "Depreciation",
+			Scopes: []string{hppV2ScopeProductionCost},
+			Total:  totalDepreciation,
+			Parts:  parts,
+		}, nil
+	}
+
+	// Fallback: manual cut-over (kandang tanpa transfer record)
+	part, err := s.buildManualCutoverDepreciationPart(projectFlockKandangId, contextRow, periodDate, totalPulletCost)
 	if err != nil {
 		return nil, err
 	}
-	} else {
-		part, err = s.buildManualCutoverDepreciationPart(projectFlockKandangId, contextRow, periodDate, totalPulletCost)
-		if err != nil {
-			return nil, err
-		}
-	}
 	if part == nil {
 		return nil, nil
 	}
@@ -1344,20 +1390,22 @@ func (s *hppV2Service) buildNormalTransferDepreciationPart(
 	}
 
 	houseType := NormalizeDepreciationHouseType(contextRow.HouseType)
-	percentByHouseType, err := s.hppRepo.GetDepreciationPercents(context.Background(), []string{houseType}, scheduleDay)
+	multiplicationByHouseType, err := s.hppRepo.GetMultiplicationPercentages(context.Background(), []string{houseType}, scheduleDay)
 	if err != nil {
 		return nil, err
 	}
 
-	pulletCostDayN, depreciationValue, depreciationPercent := CalculateDepreciationAtDayN(
+	pulletCostDayN, depreciationValue, multiplicationPercentage := CalculateDepreciationAtDayN(
 		totalPulletCost,
 		scheduleDay,
 		contextRow.HouseType,
-		percentByHouseType,
+		multiplicationByHouseType,
 	)
-	if depreciationValue <= 0 {
+	if depreciationValue <= 0 && pulletCostDayN <= 0 {
 		return nil, nil
 	}
+	totalValueAfter := pulletCostDayN * multiplicationPercentage
+	depreciationPercent := (1.0 - multiplicationPercentage) * 100.0
 
 	return &HppV2ComponentPart{
 		Code:   hppV2PartDepreciationNormal,
@@ -1367,6 +1415,8 @@ func (s *hppV2Service) buildNormalTransferDepreciationPart(
 		Details: map[string]any{
 			"basis_total":                           totalPulletCost,
 			"pullet_cost_day_n":                     pulletCostDayN,
+			"multiplication_percentage":             multiplicationPercentage,
+			"total_value_pullet_after_depreciation": totalValueAfter,
 			"depreciation_percent":                  depreciationPercent,
 			"schedule_day":                          scheduleDay,
 			"origin_date":                           formatDateOnly(*originDate),
@@ -1392,7 +1442,7 @@ func (s *hppV2Service) buildManualCutoverDepreciationPart(
 	periodDate time.Time,
 	totalPulletCost float64,
 ) (*HppV2ComponentPart, error) {
-	if contextRow == nil || totalPulletCost <= 0 {
+	if contextRow == nil {
 		return nil, nil
 	}
 
@@ -1407,6 +1457,21 @@ func (s *hppV2Service) buildManualCutoverDepreciationPart(
 		return nil, nil
 	}
 
+	populations, err := s.hppRepo.GetChickinPopulationByPFKForFarm(context.Background(), contextRow.ProjectFlockID)
+	if err != nil {
+		return nil, err
+	}
+	var totalPopulation float64
+	for _, qty := range populations {
+		totalPopulation += qty
+	}
+	kandangPopulation := populations[projectFlockKandangId]
+	if totalPopulation <= 0 || kandangPopulation <= 0 {
+		return nil, nil
+	}
+	populationShare := kandangPopulation / totalPopulation
+	basis := manualInput.TotalCost * populationShare
+
 	originDate, err := s.hppRepo.GetEarliestChickInDateByProjectFlockID(context.Background(), contextRow.ProjectFlockID)
 	if err != nil {
 		return nil, err
@@ -1427,21 +1492,24 @@ func (s *hppV2Service) buildManualCutoverDepreciationPart(
 	}
 
 	houseType := NormalizeDepreciationHouseType(contextRow.HouseType)
-	percentByHouseType, err := s.hppRepo.GetDepreciationPercents(context.Background(), []string{houseType}, reportScheduleDay)
+	multiplicationByHouseType, err := s.hppRepo.GetMultiplicationPercentages(context.Background(), []string{houseType}, reportScheduleDay)
 	if err != nil {
 		return nil, err
 	}
 
-	pulletCostDayN, depreciationValue, depreciationPercent := CalculateDepreciationFromDayRange(
+	pulletCostDayN, depreciationValue, multiplicationPercentage := CalculateDepreciationFromDayRange(
-		totalPulletCost,
+		basis,
 		startDay,
 		reportScheduleDay,
 		contextRow.HouseType,
-		percentByHouseType,
+		multiplicationByHouseType,
 	)
-	if depreciationValue <= 0 {
+	if depreciationValue <= 0 && pulletCostDayN <= 0 {
 		return nil, nil
 	}
+	totalValueAfter := pulletCostDayN * multiplicationPercentage
+	depreciationPercent := (1.0 - multiplicationPercentage) * 100.0
+	_ = totalPulletCost
 
 	return &HppV2ComponentPart{
 		Code:   hppV2PartDepreciationCutover,
@@ -1449,8 +1517,12 @@ func (s *hppV2Service) buildManualCutoverDepreciationPart(
 		Scopes: []string{hppV2ScopeProductionCost},
 		Total:  depreciationValue,
 		Details: map[string]any{
-			"basis_total":           totalPulletCost,
+			"basis_total":                           basis,
+			"manual_input_total":                    manualInput.TotalCost,
+			"population_share":                      populationShare,
 			"pullet_cost_day_n":                     pulletCostDayN,
+			"multiplication_percentage":             multiplicationPercentage,
+			"total_value_pullet_after_depreciation": totalValueAfter,
 			"depreciation_percent":                  depreciationPercent,
 			"schedule_day":                          reportScheduleDay,
 			"start_schedule_day":                    startDay,
@@ -1465,7 +1537,7 @@ func (s *hppV2Service) buildManualCutoverDepreciationPart(
 				ID:           manualInput.ID,
 				Date:         formatDateOnly(manualInput.CutoverDate),
 				Qty:          1,
-				Total:        totalPulletCost,
+				Total:        manualInput.TotalCost,
 				AppliedTotal: depreciationValue,
 			},
 		},
@@ -1724,7 +1796,7 @@ func partHasScope(part *HppV2ComponentPart, scope string) bool {
 }
 
 func dateOnly(value time.Time) time.Time {
-	return time.Date(value.Year(), value.Month(), value.Day(), 0, 0, 0, 0, value.Location())
+	return time.Date(value.Year(), value.Month(), value.Day(), 0, 0, 0, 0, time.UTC)
 }
 
 func formatDateOnly(value time.Time) string {

internal/common/service/common.hppv2.service_test.go

@@ -57,6 +57,14 @@ func (s *hppV2RepoStub) GetLatestTransferInputByProjectFlockKandangID(_ context.
 	return s.latestTransferByPFK[projectFlockKandangId], nil
 }
 
+func (s *hppV2RepoStub) GetAllTransferInputsByProjectFlockKandangID(_ context.Context, projectFlockKandangId uint, _ time.Time) ([]commonRepo.HppV2LatestTransferInputRow, error) {
+	row := s.latestTransferByPFK[projectFlockKandangId]
+	if row == nil {
+		return []commonRepo.HppV2LatestTransferInputRow{}, nil
+	}
+	return []commonRepo.HppV2LatestTransferInputRow{*row}, nil
+}
+
 func (s *hppV2RepoStub) GetManualDepreciationInputByProjectFlockID(_ context.Context, projectFlockID uint) (*commonRepo.HppV2ManualDepreciationInputRow, error) {
 	return s.manualInputByProject[projectFlockID], nil
 }
@@ -93,6 +101,18 @@ func (s *hppV2RepoStub) GetDepreciationPercents(_ context.Context, houseTypes []
 	return result, nil
 }
 
+// GetMultiplicationPercentages — alias yang sama dengan GetDepreciationPercents untuk match
+// interface HppV2CostRepository (interface dipakai method name baru ini).
+func (s *hppV2RepoStub) GetMultiplicationPercentages(ctx context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, error) {
+	return s.GetDepreciationPercents(ctx, houseTypes, maxDay)
+}
+
+// GetChickinPopulationByPFKForFarm — return populasi per PFK dari satu project flock.
+// Stub minimal: return empty map (depreciation manual cutover tidak di-test di sini).
+func (s *hppV2RepoStub) GetChickinPopulationByPFKForFarm(_ context.Context, _ uint) (map[uint]float64, error) {
+	return map[uint]float64{}, nil
+}
+
 func (s *hppV2RepoStub) ListUsageCostRowsByProductFlags(_ context.Context, projectFlockKandangIDs []uint, flagNames []string, _ *time.Time) ([]commonRepo.HppV2UsageCostRow, error) {
 	return append([]commonRepo.HppV2UsageCostRow{}, s.usageRowsByKey[stubKey(projectFlockKandangIDs, flagNames)]...), nil
 }

internal/config/config.go

@@ -121,9 +121,12 @@ func init() {
 	// Redis
 	RedisURL = viper.GetString("REDIS_URL")
 
+	// TransferToLayingGrowingMaxWeek: batas umur (minggu dari chick_in) yang masih boleh ditransfer ke laying.
+	// Disatukan dengan depreciation_start_age_day = 175 hari = 25 minggu, agar konsisten antara batas transfer
+	// dan kapan depresiasi mulai berjalan.
 	TransferToLayingGrowingMaxWeek = viper.GetInt("TRANSFER_TO_LAYING_GROWING_MAX_WEEK")
 	if TransferToLayingGrowingMaxWeek <= 0 {
-		TransferToLayingGrowingMaxWeek = 19
+		TransferToLayingGrowingMaxWeek = 25
 	}
 
 	// Object storage

internal/database/migrations/20260508091531_fix_adjustment_stock_531_price.down.sql

@@ -0,0 +1,5 @@
+-- Rollback price adjustment_stock id=531
+UPDATE adjustment_stocks
+SET price = 9535,
+    grand_total = ROUND(9000 * 9535, 3)
+WHERE id = 531 AND adj_number = 'ADJ-00506';

internal/database/migrations/20260508091531_fix_adjustment_stock_531_price.up.sql

@@ -0,0 +1,7 @@
+-- Fix price adjustment_stock id=531 (ADJ-00506)
+-- Old: price=9535, grand_total=85,815,000
+-- New: price=12635, grand_total=113,715,000
+UPDATE adjustment_stocks
+SET price = 12635,
+    grand_total = ROUND(9000 * 12635, 3)
+WHERE id = 531 AND adj_number = 'ADJ-00506';

internal/database/migrations/20260511070035_add_is_paid_to_expenses.down.sql

@@ -0,0 +1 @@
+ALTER TABLE expenses DROP COLUMN is_paid;

internal/database/migrations/20260511070035_add_is_paid_to_expenses.up.sql

@@ -0,0 +1 @@
+ALTER TABLE expenses ADD COLUMN is_paid BOOLEAN NOT NULL DEFAULT FALSE;

internal/database/migrations/20260517112459_create_daily_checklist_empty_kandangs.down.sql

@@ -0,0 +1,5 @@
+BEGIN;
+
+DROP TABLE IF EXISTS daily_checklist_empty_kandangs;
+
+COMMIT;

internal/database/migrations/20260517112459_create_daily_checklist_empty_kandangs.up.sql

@@ -0,0 +1,60 @@
+BEGIN;
+
+CREATE TABLE daily_checklist_empty_kandangs (
+  id                  bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  daily_checklist_id  bigint NOT NULL,
+  kandang_id          bigint NOT NULL,
+  start_date          date NOT NULL,
+  end_date            date NOT NULL,
+  created_by          bigint,
+  deleted_by          bigint,
+  created_at          timestamptz NOT NULL DEFAULT now(),
+  updated_at          timestamptz NOT NULL DEFAULT now(),
+  deleted_at          timestamptz,
+
+  CONSTRAINT fk_dcek_daily_checklist
+    FOREIGN KEY (daily_checklist_id) REFERENCES daily_checklists(id) ON DELETE CASCADE,
+  CONSTRAINT fk_dcek_kandang
+    FOREIGN KEY (kandang_id) REFERENCES kandangs(id) ON DELETE CASCADE,
+  CONSTRAINT fk_dcek_created_by
+    FOREIGN KEY (created_by) REFERENCES users(id) ON DELETE SET NULL,
+  CONSTRAINT fk_dcek_deleted_by
+    FOREIGN KEY (deleted_by) REFERENCES users(id) ON DELETE SET NULL,
+  CONSTRAINT ck_dcek_range CHECK (end_date >= start_date)
+);
+
+CREATE INDEX idx_dcek_kandang_range
+  ON daily_checklist_empty_kandangs (kandang_id, start_date, end_date)
+  WHERE deleted_at IS NULL;
+
+CREATE UNIQUE INDEX idx_dcek_daily_checklist_unique
+  ON daily_checklist_empty_kandangs (daily_checklist_id)
+  WHERE deleted_at IS NULL;
+
+INSERT INTO daily_checklist_empty_kandangs (
+  daily_checklist_id, kandang_id, start_date, end_date, created_by, created_at, updated_at
+)
+SELECT
+  dc.id,
+  dc.kandang_id,
+  dc.date AS start_date,
+  COALESCE(
+    (SELECT (next_dc.date - INTERVAL '1 day')::date
+     FROM daily_checklists next_dc
+     WHERE next_dc.kandang_id = dc.kandang_id
+       AND next_dc.date > dc.date
+       AND next_dc.category <> 'empty_kandang'
+       AND (next_dc.status IS NULL OR next_dc.status <> 'REJECTED')
+       AND next_dc.deleted_at IS NULL
+     ORDER BY next_dc.date ASC
+     LIMIT 1),
+    dc.date
+  ) AS end_date,
+  dc.created_by,
+  dc.created_at,
+  dc.updated_at
+FROM daily_checklists dc
+WHERE dc.category = 'empty_kandang'
+  AND dc.deleted_at IS NULL;
+
+COMMIT;

internal/database/migrations/20260517132922_add_bank_name_to_customers_suppliers.down.sql

@@ -0,0 +1,2 @@
+ALTER TABLE customers DROP COLUMN bank_name;
+ALTER TABLE suppliers DROP COLUMN bank_name;

internal/database/migrations/20260517132922_add_bank_name_to_customers_suppliers.up.sql

@@ -0,0 +1,2 @@
+ALTER TABLE customers ADD COLUMN bank_name VARCHAR(100) NOT NULL DEFAULT '';
+ALTER TABLE suppliers ADD COLUMN bank_name VARCHAR(100);

internal/database/migrations/20260520000001_unify_close_house_depreciation_standard.down.sql

@@ -0,0 +1,17 @@
+-- Hapus open_house dan close_house rows dengan effective_date baru
+DELETE FROM house_depreciation_standards
+WHERE house_type IN ('open_house', 'close_house') AND effective_date = '2026-05-20';
+
+-- Hapus kolom multiplication_percentage
+ALTER TABLE house_depreciation_standards DROP COLUMN multiplication_percentage;
+
+-- Invalidate snapshot cache
+DELETE FROM farm_depreciation_snapshots;
+
+-- Kembalikan unique constraint lama
+ALTER TABLE house_depreciation_standards
+    DROP CONSTRAINT house_depreciation_standards_house_type_day_eff_unique;
+
+ALTER TABLE house_depreciation_standards
+    ADD CONSTRAINT house_depreciation_standards_house_type_day_unique
+    UNIQUE (house_type, day);

internal/database/migrations/20260520000001_unify_close_house_depreciation_standard.up.sql

@@ -0,0 +1,279 @@
+-- Drop unique constraint lama (house_type, day) agar bisa support multi effective_date
+ALTER TABLE house_depreciation_standards
+    DROP CONSTRAINT house_depreciation_standards_house_type_day_unique;
+
+-- Unique baru: (house_type, day, effective_date)
+-- NULL dianggap distinct di PostgreSQL → row lama (effective_date NULL) tidak konflik dengan row baru
+ALTER TABLE house_depreciation_standards
+    ADD CONSTRAINT house_depreciation_standards_house_type_day_eff_unique
+    UNIQUE (house_type, day, effective_date);
+
+-- Tambah kolom multiplication_percentage (nilai dari baris ke-3 Excel "Depresiasi 25 week.xlsx")
+ALTER TABLE house_depreciation_standards
+    ADD COLUMN multiplication_percentage numeric(20,15) NOT NULL DEFAULT 0;
+
+-- Isi multiplication_percentage untuk semua row existing (effective_date IS NULL)
+-- Value diambil dari row 3 Excel: kolom A=day1 s/d TL=day532
+UPDATE house_depreciation_standards AS hds
+SET multiplication_percentage = v.val
+FROM (VALUES
+    (1,0.997742664),(2,0.997737557),(3,0.997732426),(4,0.997727273),(5,0.997722096),
+    (6,0.997716895),(7,0.99771167),(8,0.997706422),(9,0.997701149),(10,0.997695853),
+    (11,0.997690531),(12,0.9977),(13,0.997679814),(14,0.997674419),(15,0.998),
+    (16,0.997997998),(17,0.997993982),(18,0.99798995),(19,0.997985901),(20,0.997981837),
+    (21,0.997977755),(22,0.997635934),(23,0.997630332),(24,0.997624703),(25,0.997619048),
+    (26,0.997613365),(27,0.997607656),(28,0.997601918),(29,0.997596154),(30,0.997590361),
+    (31,0.997584541),(32,0.997578692),(33,0.997572816),(34,0.99756691),(35,0.997560976),
+    (36,0.997555012),(37,0.99754902),(38,0.997542998),(39,0.997536946),(40,0.997530864),
+    (41,0.997524752),(42,0.99751861),(43,0.997867804),(44,0.997863248),(45,0.997858672),
+    (46,0.997854077),(47,0.997849462),(48,0.997844828),(49,0.997840173),(50,0.997474747),
+    (51,0.997468354),(52,0.997461929),(53,0.997455471),(54,0.99744898),(55,0.997442455),
+    (56,0.997435897),(57,0.997429306),(58,0.99742268),(59,0.997416021),(60,0.997409326),
+    (61,0.997402597),(62,0.997395833),(63,0.997389034),(64,0.997756171),(65,0.997751124),
+    (66,0.997746056),(67,0.997740964),(68,0.997735849),(69,0.997730711),(70,0.99772555),
+    (71,0.997340426),(72,0.997333333),(73,0.997326203),(74,0.997319035),(75,0.997311828),
+    (76,0.997304582),(77,0.9972973),(78,0.99767712),(79,0.99767171),(80,0.99766628),
+    (81,0.99766082),(82,0.99765533),(83,0.99764982),(84,0.997644287),(85,0.997245179),
+    (86,0.997237569),(87,0.997229917),(88,0.997222222),(89,0.997214485),(90,0.997206704),
+    (91,0.99719888),(92,0.997191011),(93,0.997183099),(94,0.997175141),(95,0.997167139),
+    (96,0.997159091),(97,0.997150997),(98,0.997142857),(99,0.997544003),(100,0.997537957),
+    (101,0.99753188),(102,0.997525773),(103,0.997519636),(104,0.997513469),(105,0.99750727),
+    (106,0.997084548),(107,0.997076023),(108,0.997067449),(109,0.997058824),(110,0.997050147),
+    (111,0.99704142),(112,0.997032641),(113,0.99744898),(114,0.997442455),(115,0.997435897),
+    (116,0.997429306),(117,0.99742268),(118,0.997416021),(119,0.997409326),(120,0.996969697),
+    (121,0.996960486),(122,0.99695122),(123,0.996941896),(124,0.996932515),(125,0.996923077),
+    (126,0.99691358),(127,0.997346307),(128,0.997339246),(129,0.997332148),(130,0.997325011),
+    (131,0.997317836),(132,0.997310623),(133,0.997303371),(134,0.996845426),(135,0.996835443),
+    (136,0.996825397),(137,0.996815287),(138,0.996805112),(139,0.996794872),(140,0.996784566),
+    (141,0.997235023),(142,0.997227357),(143,0.997219648),(144,0.997211896),(145,0.997204101),
+    (146,0.997196262),(147,0.997188379),(148,0.996710526),(149,0.99669967),(150,0.996688742),
+    (151,0.996677741),(152,0.996666667),(153,0.996655518),(154,0.996644295),(155,0.997113997),
+    (156,0.997105644),(157,0.997097242),(158,0.997088792),(159,0.997080292),(160,0.997071742),
+    (161,0.997063142),(162,0.997054492),(163,0.99704579),(164,0.997037037),(165,0.997028232),
+    (166,0.997019374),(167,0.997010463),(168,0.997001499),(169,0.996491228),(170,0.996478873),
+    (171,0.996466431),(172,0.996453901),(173,0.996441281),(174,0.996428571),(175,0.996415771),
+    (176,0.996916752),(177,0.996907216),(178,0.996897622),(179,0.996887967),(180,0.996878252),
+    (181,0.996868476),(182,0.996858639),(183,0.996848739),(184,0.996838778),(185,0.996828753),
+    (186,0.996818664),(187,0.996808511),(188,0.996798292),(189,0.996788009),(190,0.996240602),
+    (191,0.996226415),(192,0.996212121),(193,0.996197719),(194,0.996183206),(195,0.996168582),
+    (196,0.996153846),(197,0.996690568),(198,0.996679579),(199,0.996668517),(200,0.996657382),
+    (201,0.996646171),(202,0.996634885),(203,0.996623523),(204,0.996612084),(205,0.996600567),
+    (206,0.996588971),(207,0.996577296),(208,0.996565541),(209,0.996553705),(210,0.996541787),
+    (211,0.996529786),(212,0.996517702),(213,0.996505533),(214,0.996493279),(215,0.996480938),
+    (216,0.996468511),(217,0.996455995),(218,0.996443391),(219,0.996430696),(220,0.99641791),
+    (221,0.996405033),(222,0.996392063),(223,0.996378998),(224,0.996365839),(225,0.995744681),
+    (226,0.995726496),(227,0.995708155),(228,0.995689655),(229,0.995670996),(230,0.995652174),
+    (231,0.995633188),(232,0.996240602),(233,0.996226415),(234,0.996212121),(235,0.996197719),
+    (236,0.996183206),(237,0.996168582),(238,0.996153846),(239,0.9961389960),(240,0.996124031),
+    (241,0.996108949),(242,0.99609375),(243,0.996078431),(244,0.996062992),(245,0.996047431),
+    (246,0.996031746),(247,0.996015936),(248,0.996),(249,0.995983936),(250,0.995967742),
+    (251,0.995951417),(252,0.995934959),(253,0.995918367),(254,0.995901639),(255,0.995884774),
+    (256,0.995867769),(257,0.995850622),(258,0.995833333),(259,0.9958158999),(260,0.995798319),
+    (261,0.995780591),(262,0.995762712),(263,0.995744681),(264,0.995726496),(265,0.995708155),
+    (266,0.995689655),(267,0.995670996),(268,0.995652174),(269,0.995633188),(270,0.995614035),
+    (271,0.995594714),(272,0.995575221),(273,0.995555556),(274,0.995535714),(275,0.995515695),
+    (276,0.995495495),(277,0.995475113),(278,0.995454545),(279,0.99543379),(280,0.995412844),
+    (281,0.995391705),(282,0.99537037),(283,0.995348837),(284,0.995327103),(285,0.995305164),
+    (286,0.995282919),(287,0.995260664),(288,0.996031746),(289,0.996015936),(290,0.996),
+    (291,0.995983936),(292,0.995967742),(293,0.995951417),(294,0.995934959),(295,0.995102041),
+    (296,0.995077933),(297,0.995053586),(298,0.995028998),(299,0.995004163),(300,0.994979079),
+    (301,0.994953743),(302,0.994928149),(303,0.994902294),(304,0.994876174),(305,0.994849785),
+    (306,0.994823123),(307,0.994796184),(308,0.994768963),(309,0.994741455),(310,0.994713656),
+    (311,0.994685562),(312,0.994657168),(313,0.994628469),(314,0.99459946),(315,0.994570136),
+    (316,0.994540491),(317,0.994510522),(318,0.994480221),(319,0.994449584),(320,0.994418605),
+    (321,0.994387278),(322,0.994355597),(323,0.995269631),(324,0.995247148),(325,0.995224451),
+    (326,0.995201536),(327,0.995178399),(328,0.995155039),(329,0.995131451),(330,0.994129159),
+    (331,0.994094488),(332,0.994059406),(333,0.994023904),(334,0.993987976),(335,0.993951613),
+    (336,0.993914807),(337,0.994897959),(338,0.994871795),(339,0.994845361),(340,0.994818653),
+    (341,0.994791667),(342,0.994764398),(343,0.994736842),(344,0.993650794),(345,0.993610224),
+    (346,0.993569132),(347,0.993527508),(348,0.993484342),(349,0.993442623),(350,0.99339934),
+    (351,0.993355482),(352,0.993311037),(353,0.993265993),(354,0.993220339),(355,0.993174061),
+    (356,0.993127148),(357,0.993079585),(358,0.994192799),(359,0.994158879),(360,0.994124559),
+    (361,0.994089835),(362,0.994054697),(363,0.994019139),(364,0.993983153),(365,0.992736077),
+    (366,0.992682927),(367,0.992628993),(368,0.992574257),(369,0.992518703),(370,0.992462312),
+    (371,0.992405063),(372,0.993622449),(373,0.993581515),(374,0.993540052),(375,0.993498049),
+    (376,0.993455497),(377,0.993412385),(378,0.9933687),(379,0.993324433),(380,0.99327957),
+    (381,0.9932341),(382,0.993188011),(383,0.993141289),(384,0.993093923),(385,0.993045897),
+    (386,0.991596639),(387,0.991525424),(388,0.991452991),(389,0.99137931),(390,0.991304348),
+    (391,0.99122807),(392,0.991150442),(393,0.992559524),(394,0.992503748),(395,0.99244713),
+    (396,0.99238965),(397,0.992331288),(398,0.992272025),(399,0.992211838),(400,0.992150706),
+    (401,0.992088608),(402,0.992025518),(403,0.991961415),(404,0.991896272),(405,0.991830065),
+    (406,0.991762768),(407,0.991694352),(408,0.991624791),(409,0.991554054),(410,0.991482112),
+    (411,0.991408935),(412,0.991334489),(413,0.991258741),(414,0.989417989),(415,0.989304813),
+    (416,0.989189189),(417,0.989071038),(418,0.988950276),(419,0.988826816),(420,0.988700565),
+    (421,0.99047619),(422,0.990384615),(423,0.990291262),(424,0.990196078),(425,0.99009901),
+    (426,0.99),(427,0.98989899),(428,0.989795918),(429,0.989690722),(430,0.989583333),
+    (431,0.989473684),(432,0.989361702),(433,0.989247312),(434,0.989130435),(435,0.989010989),
+    (436,0.988888889),(437,0.988764045),(438,0.988636364),(439,0.988505747),(440,0.988372093),
+    (441,0.988235294),(442,0.988095238),(443,0.987951807),(444,0.987804878),(445,0.987654321),
+    (446,0.9875),(447,0.987341772),(448,0.987179487),(449,0.987012987),(450,0.986842105),
+    (451,0.986666667),(452,0.986486486),(453,0.98630137),(454,0.986111111),(455,0.985915493),
+    (456,0.985714286),(457,0.985507246),(458,0.985294118),(459,0.985074627),(460,0.984848485),
+    (461,0.984615385),(462,0.984375),(463,0.987301587),(464,0.987138264),(465,0.986970684),
+    (466,0.98679868),(467,0.986622074),(468,0.986440678),(469,0.986254296),(470,0.982578397),
+    (471,0.982269504),(472,0.981949458),(473,0.981617647),(474,0.981273408),(475,0.980916031),
+    (476,0.980544747),(477,0.98015873),(478,0.979757085),(479,0.979338843),(480,0.978902954),
+    (481,0.978448276),(482,0.977973568),(483,0.977477477),(484,0.976958525),(485,0.976415094),
+    (486,0.975845411),(487,0.975247525),(488,0.974619289),(489,0.973958333),(490,0.973262032),
+    (491,0.978021978),(492,0.97752809),(493,0.977011494),(494,0.976470588),(495,0.975903614),
+    (496,0.975308642),(497,0.974683544),(498,0.967532468),(499,0.966442953),(500,0.965277778),
+    (501,0.964028777),(502,0.962686567),(503,0.96124031),(504,0.959677419),(505,0.966386555),
+    (506,0.965217391),(507,0.963963964),(508,0.962616822),(509,0.961165049),(510,0.95959596),
+    (511,0.957894737),(512,0.945054945),(513,0.941860465),(514,0.938271605),(515,0.934210526),
+    (516,0.929577465),(517,0.924242424),(518,0.918032787),(519,0.928571429),(520,0.923076923),
+    (521,0.916666667),(522,0.909090909),(523,0.9),(524,0.888888889),(525,0.875),
+    (526,0.857142857),(527,0.833333333),(528,0.8),(529,0.75),(530,0.666666667),
+    (531,0.5),(532,9.11e-12)
+) AS v(day_num, val)
+WHERE hds.day = v.day_num;
+
+-- Insert open_house baru dengan effective_date 2026-05-20
+-- multiplication_percentage diambil dari row existing (sudah di-UPDATE di step sebelumnya)
+INSERT INTO house_depreciation_standards
+    (house_type, day, effective_date, depreciation_percent, standard_week, name, multiplication_percentage)
+SELECT
+    'open_house'::house_type_enum,
+    day,
+    '2026-05-20'::date,
+    depreciation_percent,
+    25,
+    'Standard Open House Week 25',
+    multiplication_percentage
+FROM (
+    SELECT DISTINCT ON (day)
+        day, depreciation_percent, multiplication_percentage
+    FROM house_depreciation_standards
+    WHERE house_type = 'open_house'
+    ORDER BY day, effective_date DESC NULLS LAST
+) effective_open_house;
+
+-- Insert close_house baru: depreciation_percent dari open_house, multiplication_percentage dari Excel row 8 (close_house)
+INSERT INTO house_depreciation_standards
+    (house_type, day, effective_date, depreciation_percent, standard_week, name, multiplication_percentage)
+SELECT
+    'close_house'::house_type_enum,
+    oh.day,
+    '2026-05-20'::date,
+    oh.depreciation_percent,
+    25,
+    'Standard Close House Week 25',
+    ch.val
+FROM (
+    SELECT DISTINCT ON (day)
+        day, depreciation_percent
+    FROM house_depreciation_standards
+    WHERE house_type = 'open_house'
+    ORDER BY day, effective_date DESC NULLS LAST
+) oh
+JOIN (VALUES
+    (1,0.9981),(2,0.9981),(3,0.9981),(4,0.9981),(5,0.9981),
+    (6,0.9981),(7,0.9981),(8,0.9978),(9,0.9978),(10,0.9978),
+    (11,0.9978),(12,0.9978),(13,0.9978),(14,0.9978),(15,0.9978),
+    (16,0.9978),(17,0.9978),(18,0.9978),(19,0.9978),(20,0.9978),
+    (21,0.9978),(22,0.9981),(23,0.9981),(24,0.9981),(25,0.9981),
+    (26,0.9981),(27,0.9981),(28,0.9981),(29,0.9978),(30,0.9978),
+    (31,0.9978),(32,0.9978),(33,0.9978),(34,0.9978),(35,0.9978),
+    (36,0.9978),(37,0.9978),(38,0.9978),(39,0.9978),(40,0.9978),
+    (41,0.9978),(42,0.9978),(43,0.9978),(44,0.9978),(45,0.9978),
+    (46,0.9978),(47,0.9978),(48,0.9978),(49,0.9978),(50,0.9981),
+    (51,0.9981),(52,0.9981),(53,0.9981),(54,0.9981),(55,0.9981),
+    (56,0.9981),(57,0.9978),(58,0.9978),(59,0.9978),(60,0.9978),
+    (61,0.9978),(62,0.9978),(63,0.9978),(64,0.9978),(65,0.9978),
+    (66,0.9977),(67,0.9977),(68,0.9977),(69,0.9977),(70,0.9977),
+    (71,0.9973),(72,0.9973),(73,0.9973),(74,0.9973),(75,0.9973),
+    (76,0.9973),(77,0.9973),(78,0.9977),(79,0.9977),(80,0.9977),
+    (81,0.9977),(82,0.9977),(83,0.9976),(84,0.9976),(85,0.9972),
+    (86,0.9972),(87,0.9972),(88,0.9972),(89,0.9972),(90,0.9972),
+    (91,0.9972),(92,0.9972),(93,0.9972),(94,0.9972),(95,0.9972),
+    (96,0.9972),(97,0.9972),(98,0.9971),(99,0.9975),(100,0.9975),
+    (101,0.9975),(102,0.9975),(103,0.9975),(104,0.9975),(105,0.9975),
+    (106,0.9971),(107,0.9971),(108,0.9971),(109,0.9971),(110,0.9971),
+    (111,0.997),(112,0.997),(113,0.9974),(114,0.9974),(115,0.9974),
+    (116,0.9974),(117,0.9974),(118,0.9974),(119,0.9974),(120,0.997),
+    (121,0.997),(122,0.997),(123,0.9969),(124,0.9969),(125,0.9969),
+    (126,0.9969),(127,0.9973),(128,0.9973),(129,0.9973),(130,0.9973),
+    (131,0.9973),(132,0.9973),(133,0.9973),(134,0.9968),(135,0.9968),
+    (136,0.9968),(137,0.9968),(138,0.9968),(139,0.9968),(140,0.9968),
+    (141,0.9972),(142,0.9972),(143,0.9972),(144,0.9972),(145,0.9972),
+    (146,0.9972),(147,0.9972),(148,0.9967),(149,0.9967),(150,0.9967),
+    (151,0.9967),(152,0.9967),(153,0.9967),(154,0.9966),(155,0.9971),
+    (156,0.9971),(157,0.9971),(158,0.9971),(159,0.9971),(160,0.9971),
+    (161,0.9971),(162,0.9971),(163,0.997),(164,0.997),(165,0.997),
+    (166,0.997),(167,0.997),(168,0.997),(169,0.9965),(170,0.9965),
+    (171,0.9965),(172,0.9965),(173,0.9964),(174,0.9964),(175,0.9964),
+    (176,0.9969),(177,0.9969),(178,0.9969),(179,0.9969),(180,0.9969),
+    (181,0.9969),(182,0.9969),(183,0.9968),(184,0.9968),(185,0.9968),
+    (186,0.9968),(187,0.9968),(188,0.9968),(189,0.9968),(190,0.9962),
+    (191,0.9962),(192,0.9962),(193,0.9962),(194,0.9962),(195,0.9962),
+    (196,0.9962),(197,0.9967),(198,0.9967),(199,0.9967),(200,0.9967),
+    (201,0.9966),(202,0.9966),(203,0.9966),(204,0.9966),(205,0.9966),
+    (206,0.9966),(207,0.9966),(208,0.9966),(209,0.9966),(210,0.9965),
+    (211,0.9965),(212,0.9965),(213,0.9965),(214,0.9965),(215,0.9965),
+    (216,0.9965),(217,0.9965),(218,0.9964),(219,0.9964),(220,0.9964),
+    (221,0.9964),(222,0.9964),(223,0.9964),(224,0.9964),(225,0.9957),
+    (226,0.9957),(227,0.9957),(228,0.9957),(229,0.9957),(230,0.9957),
+    (231,0.9956),(232,0.9962),(233,0.9962),(234,0.9962),(235,0.9962),
+    (236,0.9962),(237,0.9962),(238,0.9962),(239,0.9961),(240,0.9961),
+    (241,0.9961),(242,0.9961),(243,0.9961),(244,0.9961),(245,0.996),
+    (246,0.996),(247,0.996),(248,0.996),(249,0.996),(250,0.996),
+    (251,0.996),(252,0.9959),(253,0.9959),(254,0.9959),(255,0.9959),
+    (256,0.9959),(257,0.9959),(258,0.9958),(259,0.9958),(260,0.9958),
+    (261,0.9958),(262,0.9958),(263,0.9957),(264,0.9957),(265,0.9957),
+    (266,0.9957),(267,0.9957),(268,0.9957),(269,0.9956),(270,0.9956),
+    (271,0.9956),(272,0.9956),(273,0.9956),(274,0.9955),(275,0.9955),
+    (276,0.9955),(277,0.9955),(278,0.9955),(279,0.9954),(280,0.9954),
+    (281,0.9954),(282,0.9954),(283,0.9953),(284,0.9953),(285,0.9953),
+    (286,0.9953),(287,0.9953),(288,0.996),(289,0.996),(290,0.996),
+    (291,0.996),(292,0.996),(293,0.996),(294,0.9959),(295,0.9951),
+    (296,0.9951),(297,0.9951),(298,0.995),(299,0.995),(300,0.995),
+    (301,0.995),(302,0.9949),(303,0.9949),(304,0.9949),(305,0.9948),
+    (306,0.9948),(307,0.9948),(308,0.9948),(309,0.9947),(310,0.9947),
+    (311,0.9947),(312,0.9947),(313,0.9946),(314,0.9946),(315,0.9946),
+    (316,0.9945),(317,0.9945),(318,0.9945),(319,0.9944),(320,0.9944),
+    (321,0.9944),(322,0.9944),(323,0.9953),(324,0.9952),(325,0.9952),
+    (326,0.9952),(327,0.9952),(328,0.9952),(329,0.9951),(330,0.9941),
+    (331,0.9941),(332,0.9941),(333,0.994),(334,0.994),(335,0.994),
+    (336,0.9939),(337,0.9949),(338,0.9949),(339,0.9948),(340,0.9948),
+    (341,0.9948),(342,0.9948),(343,0.9947),(344,0.9937),(345,0.9936),
+    (346,0.9936),(347,0.9935),(348,0.9935),(349,0.9934),(350,0.9934),
+    (351,0.9934),(352,0.9933),(353,0.9933),(354,0.9932),(355,0.9932),
+    (356,0.9931),(357,0.9931),(358,0.9942),(359,0.9942),(360,0.9941),
+    (361,0.9941),(362,0.9941),(363,0.994),(364,0.994),(365,0.9927),
+    (366,0.9927),(367,0.9926),(368,0.9926),(369,0.9925),(370,0.9925),
+    (371,0.9924),(372,0.9936),(373,0.9936),(374,0.9935),(375,0.9935),
+    (376,0.9935),(377,0.9934),(378,0.9934),(379,0.9933),(380,0.9933),
+    (381,0.9932),(382,0.9932),(383,0.9931),(384,0.9931),(385,0.993),
+    (386,0.9916),(387,0.9915),(388,0.9915),(389,0.9914),(390,0.9913),
+    (391,0.9912),(392,0.9912),(393,0.9926),(394,0.9925),(395,0.9924),
+    (396,0.9924),(397,0.9923),(398,0.9923),(399,0.9922),(400,0.9922),
+    (401,0.9921),(402,0.992),(403,0.992),(404,0.9919),(405,0.9918),
+    (406,0.9918),(407,0.9917),(408,0.9916),(409,0.9916),(410,0.9915),
+    (411,0.9914),(412,0.9913),(413,0.9913),(414,0.9894),(415,0.9893),
+    (416,0.9892),(417,0.9891),(418,0.989),(419,0.9888),(420,0.9887),
+    (421,0.9905),(422,0.9904),(423,0.9903),(424,0.9902),(425,0.9901),
+    (426,0.99),(427,0.9899),(428,0.9898),(429,0.9897),(430,0.9896),
+    (431,0.9895),(432,0.9894),(433,0.9892),(434,0.9891),(435,0.989),
+    (436,0.9889),(437,0.9888),(438,0.9886),(439,0.9885),(440,0.9884),
+    (441,0.9882),(442,0.9881),(443,0.988),(444,0.9878),(445,0.9877),
+    (446,0.9875),(447,0.9873),(448,0.9872),(449,0.987),(450,0.9868),
+    (451,0.9867),(452,0.9865),(453,0.9863),(454,0.9861),(455,0.9859),
+    (456,0.9857),(457,0.9855),(458,0.9853),(459,0.9851),(460,0.9848),
+    (461,0.9846),(462,0.9844),(463,0.9873),(464,0.9871),(465,0.987),
+    (466,0.9868),(467,0.9866),(468,0.9864),(469,0.9863),(470,0.9826),
+    (471,0.9823),(472,0.9819),(473,0.9816),(474,0.9813),(475,0.9809),
+    (476,0.9805),(477,0.9802),(478,0.9798),(479,0.9793),(480,0.9789),
+    (481,0.9784),(482,0.978),(483,0.9775),(484,0.977),(485,0.9764),
+    (486,0.9758),(487,0.9752),(488,0.9746),(489,0.974),(490,0.9733),
+    (491,0.978),(492,0.9775),(493,0.977),(494,0.9765),(495,0.9759),
+    (496,0.9753),(497,0.9747),(498,0.9675),(499,0.9664),(500,0.9653),
+    (501,0.964),(502,0.9627),(503,0.9612),(504,0.9597),(505,0.9664),
+    (506,0.9652),(507,0.964),(508,0.9626),(509,0.9612),(510,0.9596),
+    (511,0.9579),(512,0.9451),(513,0.9419),(514,0.9383),(515,0.9342),
+    (516,0.9296),(517,0.9242),(518,0.918),(519,0.9286),(520,0.9231),
+    (521,0.9167),(522,0.9091),(523,0.9),(524,0.8889),(525,0.875),
+    (526,0.8571),(527,0.8333),(528,0.8),(529,0.75),(530,0.6667),
+    (531,0.5),(532,0)
+) AS ch(day, val) ON oh.day = ch.day;
+
+-- Invalidate snapshot cache depreciation agar recompute dengan standard baru
+DELETE FROM farm_depreciation_snapshots;

internal/database/migrations/20260522113148_fix_adjustment_stock_532_price.down.sql

@@ -0,0 +1,4 @@
+UPDATE adjustment_stocks
+SET price = 9535,
+    grand_total = ROUND(8700 * 9535, 3)
+WHERE id = 532 AND adj_number = 'ADJ-00507';

internal/database/migrations/20260522113148_fix_adjustment_stock_532_price.up.sql

@@ -0,0 +1,5 @@
+
+UPDATE adjustment_stocks
+SET price = 12635,
+    grand_total = ROUND(8700 * 12635, 3)
+WHERE id = 532 AND adj_number = 'ADJ-00507';

internal/database/migrations/20260523035647_consolidate_pullet_cikaum_locations.down.sql

@@ -0,0 +1,31 @@
+BEGIN;
+
+-- Rollback konsolidasi: kembalikan data ke loc 18 / 25 sesuai snapshot pre-migration.
+-- Order: un-soft-delete locations dulu agar FK tidak gagal saat UPDATE child.
+
+-- 1. Un-soft-delete locations
+UPDATE locations SET deleted_at = NULL WHERE id IN (18, 25);
+
+-- 2. project_flocks: PF 30 -> 18, PF 25 & 31 -> 25
+UPDATE project_flocks SET location_id = 18, updated_at = NOW() WHERE id = 30;
+UPDATE project_flocks SET location_id = 25, updated_at = NOW() WHERE id IN (25, 31);
+
+-- 3. kandangs: K9, K72, K117 -> 18; K10, K73, K116 -> 25
+UPDATE kandangs SET location_id = 18, updated_at = NOW() WHERE id IN (9, 72, 117);
+UPDATE kandangs SET location_id = 25, updated_at = NOW() WHERE id IN (10, 73, 116);
+
+-- 4. kandang_groups: KG 26, 68 -> 18; KG 27, 67 -> 25
+UPDATE kandang_groups SET location_id = 18, updated_at = NOW() WHERE id IN (26, 68);
+UPDATE kandang_groups SET location_id = 25, updated_at = NOW() WHERE id IN (27, 67);
+
+-- 5. warehouses: W27, W145, W152 -> 18; W3, W146, W153 -> 25
+UPDATE warehouses SET location_id = 18, updated_at = NOW() WHERE id IN (27, 145, 152);
+UPDATE warehouses SET location_id = 25, updated_at = NOW() WHERE id IN (3, 146, 153);
+
+-- 6. expenses: list eksplisit per location
+UPDATE expenses SET location_id = 18, updated_at = NOW()
+WHERE id IN (36, 345, 500, 501, 502, 503, 504, 505, 506, 507, 508);
+UPDATE expenses SET location_id = 25, updated_at = NOW()
+WHERE id IN (9, 37, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518);
+
+COMMIT;

internal/database/migrations/20260523035647_consolidate_pullet_cikaum_locations.up.sql

@@ -0,0 +1,34 @@
+BEGIN;
+
+-- Konsolidasi 3 lokasi "Pullet Cikaum" jadi 1.
+-- Pindahkan semua data di loc 18 (Pullet Cikaum 1) & 25 (Pullet Cikaum 2) ke loc 2 (Pullet Cikaum).
+-- Urutan wajib: semua UPDATE child harus selesai SEBELUM soft-delete locations,
+-- karena trigger trg_soft_delete_fk_locations akan RAISE EXCEPTION untuk FK
+-- RESTRICT (project_flocks, kandangs, kandang_groups, expenses) atau SET NULL
+-- untuk warehouses kalau masih ada child yang reference.
+
+-- 1. project_flocks (PF 25, 30, 31)
+UPDATE project_flocks SET location_id = 2, updated_at = NOW()
+WHERE location_id IN (18, 25);
+
+-- 2. kandangs (K9, K72, K117, K10, K73, K116)
+UPDATE kandangs SET location_id = 2, updated_at = NOW()
+WHERE location_id IN (18, 25);
+
+-- 3. kandang_groups (KG 26, 68, 27, 67)
+UPDATE kandang_groups SET location_id = 2, updated_at = NOW()
+WHERE location_id IN (18, 25);
+
+-- 4. warehouses (W3, W27, W145, W146, W152, W153)
+UPDATE warehouses SET location_id = 2, updated_at = NOW()
+WHERE location_id IN (18, 25);
+
+-- 5. expenses (23 row BOP)
+UPDATE expenses SET location_id = 2, updated_at = NOW()
+WHERE location_id IN (18, 25);
+
+-- 6. Soft-delete locations 18 & 25 (kosong, aman karena semua child sudah pindah)
+UPDATE locations SET deleted_at = NOW()
+WHERE id IN (18, 25) AND deleted_at IS NULL;
+
+COMMIT;

internal/database/migrations/20260527074540_recalculate_economic_cutoff_25_weeks.down.sql

@@ -0,0 +1,22 @@
+-- Rollback: balik ke rule lama (19 minggu = 133 hari)
+
+BEGIN;
+
+UPDATE laying_transfers lt
+SET economic_cutoff_date = sub.cutoff_date,
+    updated_at = NOW()
+FROM (
+    SELECT
+        lt2.id AS transfer_id,
+        (MIN(pc.chick_in_date)::date + INTERVAL '133 days')::date AS cutoff_date
+    FROM laying_transfers lt2
+    JOIN project_chickins pc ON pc.project_flock_kandang_id = lt2.source_project_flock_kandang_id
+    WHERE lt2.deleted_at IS NULL
+      AND lt2.source_project_flock_kandang_id IS NOT NULL
+      AND pc.deleted_at IS NULL
+    GROUP BY lt2.id
+) sub
+WHERE lt.id = sub.transfer_id
+  AND lt.deleted_at IS NULL;
+
+COMMIT;

internal/database/migrations/20260527074540_recalculate_economic_cutoff_25_weeks.up.sql

@@ -0,0 +1,24 @@
+-- Recalculate laying_transfers.economic_cutoff_date dari rule 19 minggu (lama) ke 25 minggu (baru,
+-- sejalan dengan depreciation_start_age_day = 175). Semua transfer historis yang punya
+-- source_project_flock_kandang_id akan di-update agar economic_cutoff_date = source.chick_in_date + 175 hari.
+
+BEGIN;
+
+UPDATE laying_transfers lt
+SET economic_cutoff_date = sub.cutoff_date,
+    updated_at = NOW()
+FROM (
+    SELECT
+        lt2.id AS transfer_id,
+        (MIN(pc.chick_in_date)::date + INTERVAL '175 days')::date AS cutoff_date
+    FROM laying_transfers lt2
+    JOIN project_chickins pc ON pc.project_flock_kandang_id = lt2.source_project_flock_kandang_id
+    WHERE lt2.deleted_at IS NULL
+      AND lt2.source_project_flock_kandang_id IS NOT NULL
+      AND pc.deleted_at IS NULL
+    GROUP BY lt2.id
+) sub
+WHERE lt.id = sub.transfer_id
+  AND lt.deleted_at IS NULL;
+
+COMMIT;

internal/database/migrations/20260527074620_truncate_farm_depreciation_snapshots.down.sql

@@ -0,0 +1,3 @@
+-- Down migration: tidak ada cara restore TRUNCATE. Snapshot akan auto-regenerate on demand.
+-- File kosong sengaja: rollback safe karena snapshot dianggap cache yang bisa di-regenerate.
+SELECT 1;

internal/database/migrations/20260527074620_truncate_farm_depreciation_snapshots.up.sql

@@ -0,0 +1,10 @@
+-- Truncate semua farm_depreciation_snapshots agar di-recompute dengan logic baru:
+-- 1. Multi-transfer per target kandang sekarang menghasilkan multiple parts (1 per transfer)
+-- 2. Economic cutoff date sudah diupdate dari 19 minggu ke 25 minggu
+-- 3. Format `components` JSON tetap kompatibel — yang berubah adalah jumlah entries (lebih banyak
+--    untuk kandang multi-transfer)
+--
+-- Snapshot akan otomatis di-regenerate saat user request `/api/reports/expense/depreciation`
+-- untuk period yang relevan.
+
+TRUNCATE TABLE farm_depreciation_snapshots;

internal/entities/customer.go

@@ -15,6 +15,7 @@ type Customer struct {
 	Phone         string         `gorm:"not null;size:20"`
 	Email         string         `gorm:"type:varchar(50);not null"`
 	AccountNumber string         `gorm:"not null;size:50"`
+	BankName      string         `gorm:"not null;size:100;default:''"`
 	Balance       float64        `gorm:"default:0"`
 	CreatedBy     uint           `gorm:"not null"`
 	CreatedAt     time.Time      `gorm:"autoCreateTime"`

internal/entities/daily-checklist-empty-kandang.go

@@ -0,0 +1,27 @@
+package entities
+
+import (
+	"time"
+
+	"gorm.io/gorm"
+)
+
+type DailyChecklistEmptyKandang struct {
+	Id               uint      `gorm:"primaryKey"`
+	DailyChecklistId uint      `gorm:"not null"`
+	KandangId        uint      `gorm:"not null"`
+	StartDate        time.Time `gorm:"type:date;not null"`
+	EndDate          time.Time `gorm:"type:date;not null"`
+	CreatedBy        *uint
+	DeletedBy        *uint
+	CreatedAt        time.Time      `gorm:"autoCreateTime"`
+	UpdatedAt        time.Time      `gorm:"autoUpdateTime"`
+	DeletedAt        gorm.DeletedAt `gorm:"index" json:"-"`
+
+	DailyChecklist *DailyChecklist `gorm:"foreignKey:DailyChecklistId;references:Id"`
+	Kandang        *KandangGroup   `gorm:"foreignKey:KandangId;references:Id"`
+}
+
+func (DailyChecklistEmptyKandang) TableName() string {
+	return "daily_checklist_empty_kandangs"
+}

internal/entities/daily-checklist.go

@@ -28,6 +28,7 @@ type DailyChecklist struct {
 	Creator      *User                       `gorm:"foreignKey:CreatedBy;references:Id"`
 	Deleter      *User                       `gorm:"foreignKey:DeletedBy;references:Id"`
 	Tasks        []DailyChecklistTask        `gorm:"foreignKey:DailyChecklistId;references:Id"`
+	EmptyKandang *DailyChecklistEmptyKandang `gorm:"foreignKey:DailyChecklistId;references:Id"`
 }
 
 type DailyChecklistPhase struct {

internal/entities/expense.go

@@ -17,6 +17,7 @@ type Expense struct {
 	RealizationDate         time.Time      `gorm:"type:date;column:realization_date"`
 	TransactionDate         time.Time      `gorm:"type:date;not null"`
 	Notes                   string         `gorm:"type:text;column:notes"`
+	IsPaid                  bool           `gorm:"column:is_paid;not null;default:false"`
 	CreatedBy               uint64         `gorm:""`
 	CreatedAt               time.Time      `gorm:"autoCreateTime"`
 	UpdatedAt               time.Time      `gorm:"autoUpdateTime"`

internal/entities/recording.go

@@ -43,6 +43,7 @@ type Recording struct {
 	StandardEggMass      *float64 `gorm:"-"`
 	StandardEggWeight    *float64 `gorm:"-"`
 	StandardFcr          *float64 `gorm:"-"`
+	StandardWeek         *int     `gorm:"-"`
 	PopulationCanChange  *bool    `gorm:"-"`
 	TransferExecuted     *bool    `gorm:"-"`
 	IsTransition         *bool    `gorm:"-"`

internal/entities/supplier.go

@@ -19,6 +19,7 @@ type Supplier struct {
 	Address       string         `gorm:"not null"`
 	Npwp          *string        `gorm:"size:50"`
 	AccountNumber *string        `gorm:"size:50"`
+	BankName      *string        `gorm:"size:100"`
 	Balance       float64        `gorm:"type:numeric(15,3);default:0"`
 	DueDate       int            `gorm:"not null"`
 	CreatedBy     uint           `gorm:"not null"`

internal/middleware/permissions.go

@@ -66,6 +66,7 @@ const (
 	P_ProductStockGetOne      = "lti.inventory.product_stock.detail"
 	P_ProductWarehousekGetAll = "lti.inventory.product_warehouses.list"
 	P_ProductWarehouseGetOne  = "lti.inventory.product_warehouses.detail"
+	P_StockLogGetAll          = "lti.inventory.stock_log.list"
 )
 const (
 	P_ClosingGetAll = "lti.closing.list"

internal/modules/daily-checklists/controllers/daily-checklist.controller.go

@@ -412,6 +412,33 @@ func (u *DailyChecklistController) UpdateOne(c *fiber.Ctx) error {
 		})
 }
 
+func (u *DailyChecklistController) UpdateByPut(c *fiber.Ctx) error {
+	req := new(validation.Create)
+	param := c.Params("idDailyChecklist")
+
+	id, err := strconv.Atoi(param)
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "Invalid Id")
+	}
+
+	if err := c.BodyParser(req); err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "Invalid request body")
+	}
+
+	result, err := u.DailyChecklistService.UpdateByPut(c, req, uint(id))
+	if err != nil {
+		return err
+	}
+
+	return c.Status(fiber.StatusOK).
+		JSON(response.Success{
+			Code:    fiber.StatusOK,
+			Status:  "success",
+			Message: "Update dailyChecklist successfully",
+			Data:    dto.ToDailyChecklistListDTO(*result),
+		})
+}
+
 func validateDailyChecklistDocumentSizes(files []*multipart.FileHeader) error {
 	const maxDailyChecklistDocumentBytes = 5 * 1024 * 1024 // 5MB
 	for _, file := range files {

internal/modules/daily-checklists/dto/daily-checklist.dto.go

@@ -42,6 +42,13 @@ type DailyChecklistDetailDTO struct {
 	TotalActivity     int                                `json:"total_activity"`
 	Progress          float64                            `json:"progress"`
 	DocumentURLs      []DailyChecklistDocumentDTO        `json:"document_urls"`
+	EmptyKandang      *DailyChecklistEmptyKandangDTO     `json:"empty_kandang,omitempty"`
+}
+
+type DailyChecklistEmptyKandangDTO struct {
+	Id        uint      `json:"id"`
+	StartDate time.Time `json:"start_date"`
+	EndDate   time.Time `json:"end_date"`
 }
 
 type DailyChecklistDocumentDTO struct {
@@ -180,6 +187,17 @@ func ToDailyChecklistListDTO(e entity.DailyChecklist) DailyChecklistListDTO {
 	}
 }
 
+func ToDailyChecklistEmptyKandangDTO(e *entity.DailyChecklistEmptyKandang) *DailyChecklistEmptyKandangDTO {
+	if e == nil || e.Id == 0 {
+		return nil
+	}
+	return &DailyChecklistEmptyKandangDTO{
+		Id:        e.Id,
+		StartDate: e.StartDate,
+		EndDate:   e.EndDate,
+	}
+}
+
 func ToDailyChecklistDetailDTO(checklist entity.DailyChecklist, phases []entity.DailyChecklistPhase, tasks []entity.DailyChecklistActivityTask, assignedEmployees []entity.Employee, totalActivities int, progress float64, documentURLs []DailyChecklistDocumentDTO) DailyChecklistDetailDTO {
 	phaseDTOs := make([]DailyChecklistPhaseDTO, 0, len(phases))
 	for _, phase := range phases {
@@ -241,5 +259,6 @@ func ToDailyChecklistDetailDTO(checklist entity.DailyChecklist, phases []entity.
 		TotalActivity:         totalActivities,
 		Progress:              progress,
 		DocumentURLs:          documentURLs,
+		EmptyKandang:          ToDailyChecklistEmptyKandangDTO(checklist.EmptyKandang),
 	}
 }

internal/modules/daily-checklists/module.go

@@ -22,6 +22,7 @@ type DailyChecklistModule struct{}
 
 func (DailyChecklistModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *validator.Validate) {
 	dailyChecklistRepo := rDailyChecklist.NewDailyChecklistRepository(db)
+	emptyKandangRepo := rDailyChecklist.NewDailyChecklistEmptyKandangRepository(db)
 	phasesRepo := rPhases.NewPhasesRepository(db)
 	userRepo := rUser.NewUserRepository(db)
 	documentRepo := commonRepo.NewDocumentRepository(db)
@@ -30,7 +31,7 @@ func (DailyChecklistModule) RegisterRoutes(router fiber.Router, db *gorm.DB, val
 		panic(fmt.Sprintf("failed to create document service: %v", err))
 	}
 
-	dailyChecklistService := sDailyChecklist.NewDailyChecklistService(dailyChecklistRepo, phasesRepo, validate, documentSvc)
+	dailyChecklistService := sDailyChecklist.NewDailyChecklistService(dailyChecklistRepo, emptyKandangRepo, phasesRepo, validate, documentSvc)
 	userService := sUser.NewUserService(userRepo, validate)
 
 	DailyChecklistRoutes(router, userService, dailyChecklistService)

internal/modules/daily-checklists/repositories/daily-checklist-empty-kandang.repository.go

@@ -0,0 +1,98 @@
+package repository
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"gitlab.com/mbugroup/lti-api.git/internal/common/repository"
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	"gorm.io/gorm"
+)
+
+type DailyChecklistEmptyKandangRepository interface {
+	repository.BaseRepository[entity.DailyChecklistEmptyKandang]
+	FindByDailyChecklistID(ctx context.Context, dailyChecklistID uint) (*entity.DailyChecklistEmptyKandang, error)
+	FindOverlapping(ctx context.Context, kandangID uint, startDate, endDate time.Time, excludeDailyChecklistID uint) (*entity.DailyChecklistEmptyKandang, error)
+	FindActiveCoveringDate(ctx context.Context, kandangID uint, date time.Time) (*entity.DailyChecklistEmptyKandang, error)
+	FindOverlappingInRange(ctx context.Context, kandangIDs []uint, rangeStart, rangeEnd time.Time) ([]entity.DailyChecklistEmptyKandang, error)
+	SoftDeleteByDailyChecklistID(ctx context.Context, dailyChecklistID uint, actorID *uint) error
+}
+
+type DailyChecklistEmptyKandangRepositoryImpl struct {
+	*repository.BaseRepositoryImpl[entity.DailyChecklistEmptyKandang]
+}
+
+func NewDailyChecklistEmptyKandangRepository(db *gorm.DB) DailyChecklistEmptyKandangRepository {
+	return &DailyChecklistEmptyKandangRepositoryImpl{
+		BaseRepositoryImpl: repository.NewBaseRepository[entity.DailyChecklistEmptyKandang](db),
+	}
+}
+
+func (r *DailyChecklistEmptyKandangRepositoryImpl) FindByDailyChecklistID(ctx context.Context, dailyChecklistID uint) (*entity.DailyChecklistEmptyKandang, error) {
+	var rec entity.DailyChecklistEmptyKandang
+	if err := r.DB().WithContext(ctx).
+		Where("daily_checklist_id = ?", dailyChecklistID).
+		First(&rec).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return &rec, nil
+}
+
+func (r *DailyChecklistEmptyKandangRepositoryImpl) FindOverlapping(ctx context.Context, kandangID uint, startDate, endDate time.Time, excludeDailyChecklistID uint) (*entity.DailyChecklistEmptyKandang, error) {
+	var rec entity.DailyChecklistEmptyKandang
+	query := r.DB().WithContext(ctx).
+		Where("kandang_id = ? AND start_date <= ? AND end_date >= ?", kandangID, endDate, startDate)
+	if excludeDailyChecklistID > 0 {
+		query = query.Where("daily_checklist_id <> ?", excludeDailyChecklistID)
+	}
+	if err := query.First(&rec).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return &rec, nil
+}
+
+func (r *DailyChecklistEmptyKandangRepositoryImpl) FindActiveCoveringDate(ctx context.Context, kandangID uint, date time.Time) (*entity.DailyChecklistEmptyKandang, error) {
+	var rec entity.DailyChecklistEmptyKandang
+	if err := r.DB().WithContext(ctx).
+		Where("kandang_id = ? AND start_date <= ? AND end_date >= ?", kandangID, date, date).
+		First(&rec).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return &rec, nil
+}
+
+func (r *DailyChecklistEmptyKandangRepositoryImpl) FindOverlappingInRange(ctx context.Context, kandangIDs []uint, rangeStart, rangeEnd time.Time) ([]entity.DailyChecklistEmptyKandang, error) {
+	if len(kandangIDs) == 0 {
+		return []entity.DailyChecklistEmptyKandang{}, nil
+	}
+	var recs []entity.DailyChecklistEmptyKandang
+	if err := r.DB().WithContext(ctx).
+		Where("kandang_id IN ? AND start_date <= ? AND end_date >= ?", kandangIDs, rangeEnd, rangeStart).
+		Find(&recs).Error; err != nil {
+		return nil, err
+	}
+	return recs, nil
+}
+
+func (r *DailyChecklistEmptyKandangRepositoryImpl) SoftDeleteByDailyChecklistID(ctx context.Context, dailyChecklistID uint, actorID *uint) error {
+	updates := map[string]any{
+		"deleted_at": time.Now(),
+	}
+	if actorID != nil {
+		updates["deleted_by"] = *actorID
+	}
+	return r.DB().WithContext(ctx).
+		Model(&entity.DailyChecklistEmptyKandang{}).
+		Where("daily_checklist_id = ? AND deleted_at IS NULL", dailyChecklistID).
+		Updates(updates).Error
+}

internal/modules/daily-checklists/route.go

@@ -59,6 +59,7 @@ func DailyChecklistRoutes(v1 fiber.Router, u user.UserService, s dailyChecklist.
 	route.Post("/assignment", m.RequirePermissions(m.P_DailyChecklistCreateOne), ctrl.UpdateAssignment)
 
 	route.Patch("/bulk-update", m.RequirePermissions(m.P_DailyChecklistCreateOne), ctrl.BulkUpdate)
+	route.Put("/:idDailyChecklist", m.RequirePermissions(m.P_DailyChecklistCreateOne), ctrl.UpdateByPut)
 	route.Patch("/:idDailyChecklist", m.RequirePermissions(m.P_DailyChecklistCreateOne), ctrl.UpdateOne)
 	route.Delete("/:idDailyChecklist", m.RequirePermissions(m.P_DailyChecklistCreateOne), ctrl.DeleteOne)
 }

internal/modules/daily-checklists/services/daily-checklist.service.go

@@ -29,6 +29,7 @@ type DailyChecklistService interface {
 	GetOne(ctx *fiber.Ctx, id uint) (*entity.DailyChecklist, error)
 	CreateOne(ctx *fiber.Ctx, req *validation.Create) (*entity.DailyChecklist, error)
 	UpdateOne(ctx *fiber.Ctx, req *validation.Update, id uint) (*entity.DailyChecklist, error)
+	UpdateByPut(ctx *fiber.Ctx, req *validation.Create, id uint) (*entity.DailyChecklist, error)
 	BulkUpdate(ctx *fiber.Ctx, req *validation.BulkStatusUpdate) ([]entity.DailyChecklist, error)
 	DeleteOne(ctx *fiber.Ctx, id uint) error
 	AssignPhases(ctx *fiber.Ctx, id uint, req *validation.AssignPhases) error
@@ -46,6 +47,7 @@ type dailyChecklistService struct {
 	Log              *logrus.Logger
 	Validate         *validator.Validate
 	Repository       repository.DailyChecklistRepository
+	EmptyKandangRepo repository.DailyChecklistEmptyKandangRepository
 	PhaseRepo        phaseRepo.PhasesRepository
 	DocumentSvc      commonSvc.DocumentService
 }
@@ -127,23 +129,26 @@ const (
 	dailyChecklistCategoryEmptyKandang            = "empty_kandang"
 	dailyChecklistStatusRejected                  = "REJECTED"
 	dailyChecklistStatusDraft                     = "DRAFT"
-	dailyChecklistErrEmptyKandangExist            = "DailyChecklist cannot be created because empty_kandang already exists for at least one date in range"
 	dailyChecklistErrDateOverlapExist             = "DailyChecklist cannot be created because at least one date in range already has a checklist"
 	dailyChecklistErrDeletedNonEmptyKandangExists = "DailyChecklist cannot be created as empty_kandang because a deleted non-empty_kandang checklist exists for this date"
+	dailyChecklistErrEmptyKandangRangeOverlap     = "Empty kandang range overlaps with an existing empty kandang period for this kandang"
+	dailyChecklistErrDateInsideEmptyKandang       = "Tanggal berada dalam periode kandang kosong untuk kandang ini"
+	dailyChecklistErrEmptyKandangEndDateInvalid   = "empty_kandang_end_date harus >= date"
 )
 
-func NewDailyChecklistService(repo repository.DailyChecklistRepository, phaseRepo phaseRepo.PhasesRepository, validate *validator.Validate, documentSvc commonSvc.DocumentService) DailyChecklistService {
+func NewDailyChecklistService(repo repository.DailyChecklistRepository, emptyKandangRepo repository.DailyChecklistEmptyKandangRepository, phaseRepo phaseRepo.PhasesRepository, validate *validator.Validate, documentSvc commonSvc.DocumentService) DailyChecklistService {
 	return &dailyChecklistService{
 		Log:              utils.Log,
 		Validate:         validate,
 		Repository:       repo,
+		EmptyKandangRepo: emptyKandangRepo,
 		PhaseRepo:        phaseRepo,
 		DocumentSvc:      documentSvc,
 	}
 }
 
 func (s dailyChecklistService) withRelations(db *gorm.DB) *gorm.DB {
-	return db.Preload("Kandang")
+	return db.Preload("Kandang").Preload("EmptyKandang")
 }
 
 func (s dailyChecklistService) ensureChecklistAccess(c *fiber.Ctx, checklistID uint) error {
@@ -529,6 +534,23 @@ func (s *dailyChecklistService) CreateOne(c *fiber.Ctx, req *validation.Create)
 		category = dailyChecklistCategoryEmptyKandang
 	}
 
+	var emptyEndDate time.Time
+	if category == dailyChecklistCategoryEmptyKandang {
+		trimmedEnd := strings.TrimSpace(req.EmptyKandangEndDate)
+		if trimmedEnd == "" {
+			emptyEndDate = date
+		} else {
+			parsedEnd, parseErr := time.Parse(dailyChecklistDateLayout, trimmedEnd)
+			if parseErr != nil {
+				return nil, fiber.NewError(fiber.StatusBadRequest, "invalid empty_kandang_end_date format, use YYYY-MM-DD")
+			}
+			if parsedEnd.Before(date) {
+				return nil, fiber.NewError(fiber.StatusBadRequest, dailyChecklistErrEmptyKandangEndDateInvalid)
+			}
+			emptyEndDate = parsedEnd
+		}
+	}
+
 	targetID := uint(0)
 
 	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(tx *gorm.DB) error {
@@ -537,19 +559,39 @@ func (s *dailyChecklistService) CreateOne(c *fiber.Ctx, req *validation.Create)
 		}
 
 		if category == dailyChecklistCategoryEmptyKandang {
-			if err := s.validateNoChecklistOverlapForEmptyKandang(tx, req.KandangId, date, date); err != nil {
+			if err := s.validateNoNormalChecklistInRange(tx, req.KandangId, date, emptyEndDate, 0); err != nil {
+				return err
+			}
+			if err := s.validateNoEmptyKandangRangeOverlap(tx, req.KandangId, date, emptyEndDate, 0); err != nil {
+				return err
+			}
+			if err := s.validateNoExistingEmptyKandangInRange(tx, req.KandangId, date, emptyEndDate, 0); err != nil {
 				return err
 			}
 			if err := s.validateNoDeletedNonEmptyKandangForDate(tx, req.KandangId, date); err != nil {
 				return err
 			}
 		} else {
-			if err := s.validateNoEmptyKandangConflict(tx, req.KandangId, date, date); err != nil {
+			if err := s.validateDateNotInEmptyKandangRange(tx, req.KandangId, date, 0); err != nil {
+				return err
+			}
+			if err := s.validateDateNotInExistingEmptyKandangChecklist(tx, req.KandangId, date, 0); err != nil {
 				return err
 			}
 		}
 
-		return s.createOrReuseSingleDailyChecklist(tx, req.KandangId, date, category, status, &targetID)
+		if err := s.createOrReuseSingleDailyChecklist(tx, req.KandangId, date, category, status, &targetID); err != nil {
+			return err
+		}
+
+		if category == dailyChecklistCategoryEmptyKandang {
+			actorID, _ := m.ActorIDFromContext(c)
+			if err := s.upsertEmptyKandangRange(tx, targetID, req.KandangId, date, emptyEndDate, actorID); err != nil {
+				return err
+			}
+		}
+
+		return nil
 	})
 	if err != nil {
 		s.Log.Errorf("Failed to create/upsert dailyChecklist: %+v", err)
@@ -579,34 +621,118 @@ func (s *dailyChecklistService) lockKandangForChecklistCreation(tx *gorm.DB, kan
 	return nil
 }
 
-func (s *dailyChecklistService) validateNoChecklistOverlapForEmptyKandang(tx *gorm.DB, kandangID uint, startDate, endDate time.Time) error {
+func (s *dailyChecklistService) validateNoNormalChecklistInRange(tx *gorm.DB, kandangID uint, startDate, endDate time.Time, excludeDCID uint) error {
+	q := tx.Model(&entity.DailyChecklist{}).
+		Where("kandang_id = ? AND date BETWEEN ? AND ? AND category <> ? AND deleted_at IS NULL",
+			kandangID, startDate, endDate, dailyChecklistCategoryEmptyKandang)
+	if excludeDCID > 0 {
+		q = q.Where("id <> ?", excludeDCID)
+	}
 	var conflictCount int64
-	if err := tx.Model(&entity.DailyChecklist{}).
+	if err := q.Count(&conflictCount).Error; err != nil {
-		Where("kandang_id = ? AND date BETWEEN ? AND ? AND deleted_at IS NULL", kandangID, startDate, endDate).
-		Count(&conflictCount).Error; err != nil {
 		return err
 	}
-
 	if conflictCount > 0 {
 		return fiber.NewError(fiber.StatusConflict, dailyChecklistErrDateOverlapExist)
 	}
-
 	return nil
 }
 
-func (s *dailyChecklistService) validateNoEmptyKandangConflict(tx *gorm.DB, kandangID uint, startDate, endDate time.Time) error {
+func (s *dailyChecklistService) validateNoEmptyKandangRangeOverlap(tx *gorm.DB, kandangID uint, startDate, endDate time.Time, excludeDCID uint) error {
+	q := tx.Model(&entity.DailyChecklistEmptyKandang{}).
+		Where("kandang_id = ? AND start_date <= ? AND end_date >= ?", kandangID, endDate, startDate)
+	if excludeDCID > 0 {
+		q = q.Where("daily_checklist_id <> ?", excludeDCID)
+	}
+	var overlapCount int64
+	if err := q.Count(&overlapCount).Error; err != nil {
+		return err
+	}
+	if overlapCount > 0 {
+		return fiber.NewError(fiber.StatusConflict, dailyChecklistErrEmptyKandangRangeOverlap)
+	}
+	return nil
+}
+
+func (s *dailyChecklistService) validateDateNotInEmptyKandangRange(tx *gorm.DB, kandangID uint, date time.Time, excludeDCID uint) error {
+	q := tx.Model(&entity.DailyChecklistEmptyKandang{}).
+		Where("kandang_id = ? AND start_date <= ? AND end_date >= ?", kandangID, date, date)
+	if excludeDCID > 0 {
+		q = q.Where("daily_checklist_id <> ?", excludeDCID)
+	}
+	var rec entity.DailyChecklistEmptyKandang
+	if err := q.First(&rec).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil
+		}
+		return err
+	}
+	return fiber.NewError(fiber.StatusConflict, dailyChecklistErrDateInsideEmptyKandang)
+}
+
+func (s *dailyChecklistService) validateNoExistingEmptyKandangInRange(tx *gorm.DB, kandangID uint, startDate, endDate time.Time, excludeDCID uint) error {
+	q := tx.Model(&entity.DailyChecklist{}).
+		Where("kandang_id = ? AND date BETWEEN ? AND ? AND category = ? AND deleted_at IS NULL",
+			kandangID, startDate, endDate, dailyChecklistCategoryEmptyKandang)
+	if excludeDCID > 0 {
+		q = q.Where("id <> ?", excludeDCID)
+	}
 	var conflictCount int64
-	if err := tx.Model(&entity.DailyChecklist{}).
+	if err := q.Count(&conflictCount).Error; err != nil {
-		Where("kandang_id = ? AND date BETWEEN ? AND ? AND category = ? AND deleted_at IS NULL", kandangID, startDate, endDate, dailyChecklistCategoryEmptyKandang).
+		return err
-		Count(&conflictCount).Error; err != nil {
+	}
+	if conflictCount > 0 {
+		return fiber.NewError(fiber.StatusConflict, dailyChecklistErrEmptyKandangRangeOverlap)
+	}
+	return nil
+}
+
+func (s *dailyChecklistService) validateDateNotInExistingEmptyKandangChecklist(tx *gorm.DB, kandangID uint, date time.Time, excludeDCID uint) error {
+	q := tx.Model(&entity.DailyChecklist{}).
+		Where("kandang_id = ? AND date = ? AND category = ? AND deleted_at IS NULL",
+			kandangID, date, dailyChecklistCategoryEmptyKandang)
+	if excludeDCID > 0 {
+		q = q.Where("id <> ?", excludeDCID)
+	}
+	var conflictCount int64
+	if err := q.Count(&conflictCount).Error; err != nil {
+		return err
+	}
+	if conflictCount > 0 {
+		return fiber.NewError(fiber.StatusConflict, dailyChecklistErrDateInsideEmptyKandang)
+	}
+	return nil
+}
+
+func (s *dailyChecklistService) upsertEmptyKandangRange(tx *gorm.DB, dailyChecklistID, kandangID uint, startDate, endDate time.Time, actorID uint) error {
+	var existing entity.DailyChecklistEmptyKandang
+	err := tx.Where("daily_checklist_id = ?", dailyChecklistID).First(&existing).Error
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 		return err
 	}
 
-	if conflictCount > 0 {
+	if err == nil {
-		return fiber.NewError(fiber.StatusConflict, dailyChecklistErrEmptyKandangExist)
+		return tx.Model(&entity.DailyChecklistEmptyKandang{}).
+			Where("id = ?", existing.Id).
+			Updates(map[string]any{
+				"kandang_id": kandangID,
+				"start_date": startDate,
+				"end_date":   endDate,
+				"updated_at": time.Now(),
+			}).Error
 	}
 
-	return nil
+	record := &entity.DailyChecklistEmptyKandang{
+		DailyChecklistId: dailyChecklistID,
+		KandangId:        kandangID,
+		StartDate:        startDate,
+		EndDate:          endDate,
+	}
+	if actorID > 0 {
+		actor := actorID
+		record.CreatedBy = &actor
+	}
+	return tx.Create(record).Error
 }
 
 func (s *dailyChecklistService) validateNoDeletedNonEmptyKandangForDate(tx *gorm.DB, kandangID uint, date time.Time) error {
@@ -866,6 +992,157 @@ func (s dailyChecklistService) BulkUpdate(c *fiber.Ctx, req *validation.BulkStat
 	return updated, nil
 }
 
+func (s *dailyChecklistService) UpdateByPut(c *fiber.Ctx, req *validation.Create, id uint) (*entity.DailyChecklist, error) {
+	if err := s.Validate.Struct(req); err != nil {
+		return nil, err
+	}
+
+	if err := s.ensureChecklistAccess(c, id); err != nil {
+		return nil, err
+	}
+
+	date, err := time.Parse(dailyChecklistDateLayout, strings.TrimSpace(req.Date))
+	if err != nil {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "invalid date format, use YYYY-MM-DD")
+	}
+
+	category := req.Category
+	if req.EmptyKandang {
+		category = dailyChecklistCategoryEmptyKandang
+	}
+
+	status := req.Status
+
+	var emptyEndDate time.Time
+	if category == dailyChecklistCategoryEmptyKandang {
+		trimmedEnd := strings.TrimSpace(req.EmptyKandangEndDate)
+		if trimmedEnd == "" {
+			emptyEndDate = date
+		} else {
+			parsedEnd, parseErr := time.Parse(dailyChecklistDateLayout, trimmedEnd)
+			if parseErr != nil {
+				return nil, fiber.NewError(fiber.StatusBadRequest, "invalid empty_kandang_end_date format, use YYYY-MM-DD")
+			}
+			if parsedEnd.Before(date) {
+				return nil, fiber.NewError(fiber.StatusBadRequest, dailyChecklistErrEmptyKandangEndDateInvalid)
+			}
+			emptyEndDate = parsedEnd
+		}
+	}
+
+	var wasBranchC bool // non-empty_kandang → empty_kandang transition
+	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(tx *gorm.DB) error {
+		if err := s.lockKandangForChecklistCreation(tx, req.KandangId); err != nil {
+			return err
+		}
+
+		var existing entity.DailyChecklist
+		if err := tx.Where("id = ? AND deleted_at IS NULL", id).First(&existing).Error; err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return fiber.NewError(fiber.StatusNotFound, "DailyChecklist not found")
+			}
+			return err
+		}
+
+		existingIsEmpty := existing.Category == dailyChecklistCategoryEmptyKandang
+		newIsEmpty := category == dailyChecklistCategoryEmptyKandang
+
+		if newIsEmpty {
+			if err := s.validateNoNormalChecklistInRange(tx, req.KandangId, date, emptyEndDate, id); err != nil {
+				return err
+			}
+			if err := s.validateNoEmptyKandangRangeOverlap(tx, req.KandangId, date, emptyEndDate, id); err != nil {
+				return err
+			}
+		} else {
+			if err := s.validateDateNotInEmptyKandangRange(tx, req.KandangId, date, id); err != nil {
+				return err
+			}
+		}
+
+		var conflictCount int64
+		if err := tx.Model(&entity.DailyChecklist{}).
+			Where("id <> ? AND date = ? AND kandang_id = ? AND category = ? AND deleted_at IS NULL",
+				id, date, req.KandangId, category).
+			Count(&conflictCount).Error; err != nil {
+			return err
+		}
+		if conflictCount > 0 {
+			return fiber.NewError(fiber.StatusConflict, "DailyChecklist already exists with same date, kandang, and category")
+		}
+
+		result := tx.Model(&entity.DailyChecklist{}).Where("id = ?", id).Updates(map[string]any{
+			"date":       date,
+			"kandang_id": req.KandangId,
+			"category":   category,
+			"status":     status,
+		})
+		if result.Error != nil {
+			return result.Error
+		}
+		if result.RowsAffected == 0 {
+			return gorm.ErrRecordNotFound
+		}
+
+		actorID, _ := m.ActorIDFromContext(c)
+		if newIsEmpty {
+			if err := s.upsertEmptyKandangRange(tx, id, req.KandangId, date, emptyEndDate, actorID); err != nil {
+				return err
+			}
+			// Branch C: non-empty → empty_kandang, hard-delete task/progress data
+			if !existingIsEmpty {
+				wasBranchC = true
+				if err := tx.Exec(`
+					DELETE FROM daily_checklist_activity_task_assignments
+					WHERE task_id IN (
+						SELECT id FROM daily_checklist_activity_tasks WHERE checklist_id = ?
+					)`, id).Error; err != nil {
+					return err
+				}
+				if err := tx.Where("checklist_id = ?", id).Delete(&entity.DailyChecklistActivityTask{}).Error; err != nil {
+					return err
+				}
+				if err := tx.Where("daily_checklist_id = ?", id).Delete(&entity.DailyChecklistTask{}).Error; err != nil {
+					return err
+				}
+			}
+		} else if existingIsEmpty {
+			updates := map[string]any{
+				"deleted_at": time.Now(),
+			}
+			if actorID > 0 {
+				updates["deleted_by"] = actorID
+			}
+			if err := tx.Model(&entity.DailyChecklistEmptyKandang{}).
+				Where("daily_checklist_id = ? AND deleted_at IS NULL", id).
+				Updates(updates).Error; err != nil {
+				return err
+			}
+		}
+
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Branch C: delete DC documents outside transaction (storage is external)
+	if wasBranchC && s.DocumentSvc != nil {
+		docs, docErr := s.DocumentSvc.ListByTarget(c.Context(), string(utils.DocumentTypeDailyChecklist), uint64(id))
+		if docErr == nil && len(docs) > 0 {
+			docIDs := make([]uint, 0, len(docs))
+			for _, doc := range docs {
+				docIDs = append(docIDs, doc.Id)
+			}
+			if delErr := s.DocumentSvc.DeleteDocuments(c.Context(), docIDs, true); delErr != nil {
+				s.Log.Errorf("Failed to delete documents for DC %d during empty_kandang conversion: %+v", id, delErr)
+			}
+		}
+	}
+
+	return s.GetOne(c, id)
+}
+
 func (s dailyChecklistService) DeleteOne(c *fiber.Ctx, id uint) error {
 	if err := s.ensureChecklistAccess(c, id); err != nil {
 		return err
@@ -897,6 +1174,15 @@ func (s dailyChecklistService) DeleteOne(c *fiber.Ctx, id uint) error {
 			return gorm.ErrRecordNotFound
 		}
 
+		if err := tx.Model(&entity.DailyChecklistEmptyKandang{}).
+			Where("daily_checklist_id = ? AND deleted_at IS NULL", id).
+			Updates(map[string]any{
+				"deleted_at": time.Now(),
+				"deleted_by": actorID,
+			}).Error; err != nil {
+			return err
+		}
+
 		return nil
 	}); err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
@@ -1624,82 +1910,34 @@ func (s dailyChecklistService) GetReport(c *fiber.Ctx, params *validation.Report
 		}
 		firstDay := time.Date(params.Year, time.Month(params.Month), 1, 0, 0, 0, 0, time.UTC)
 		lastDay := firstDay.AddDate(0, 1, 0).AddDate(0, 0, -1)
-		today := time.Now().UTC().Truncate(24 * time.Hour)
 
-		type emptyKandangRec struct {
+		type emptyRangeRec struct {
 			KandangID uint
-			Date      time.Time
+			StartDate time.Time
+			EndDate   time.Time
 		}
-		var emptyRecs []emptyKandangRec
+		var rangeRecs []emptyRangeRec
 		if err := s.Repository.DB().WithContext(c.Context()).
-			Model(&entity.DailyChecklist{}).
+			Model(&entity.DailyChecklistEmptyKandang{}).
-			Where("kandang_id IN ? AND category = ? AND date <= ? AND deleted_at IS NULL",
+			Where("kandang_id IN ? AND start_date <= ? AND end_date >= ?",
-				kandangIDs, dailyChecklistCategoryEmptyKandang, lastDay).
+				kandangIDs, lastDay, firstDay).
-			Select("kandang_id, date").
+			Select("kandang_id, start_date, end_date").
-			Scan(&emptyRecs).Error; err != nil {
+			Scan(&rangeRecs).Error; err != nil {
-			s.Log.Errorf("Failed to get empty kandang records for report: %+v", err)
+			s.Log.Errorf("Failed to get empty kandang ranges for report: %+v", err)
 			return err
 		}
 
 		emptyDaysByKandang := make(map[uint]map[int]struct{})
 
-		if len(emptyRecs) > 0 {
+		for _, rec := range rangeRecs {
-			minEmptyDate := emptyRecs[0].Date
+			effectiveStart := rec.StartDate
-			for _, rec := range emptyRecs[1:] {
-				if rec.Date.Before(minEmptyDate) {
-					minEmptyDate = rec.Date
-				}
-			}
-
-			type checklistDateRec struct {
-				KandangID uint
-				Date      time.Time
-			}
-			var nextDates []checklistDateRec
-			if err := s.Repository.DB().WithContext(c.Context()).
-				Model(&entity.DailyChecklist{}).
-				Where("kandang_id IN ? AND category != ? AND date > ? AND (status IS NULL OR status != ?) AND deleted_at IS NULL",
-					kandangIDs, dailyChecklistCategoryEmptyKandang, minEmptyDate, dailyChecklistStatusRejected).
-				Select("kandang_id, date").
-				Order("kandang_id ASC, date ASC").
-				Scan(&nextDates).Error; err != nil {
-				s.Log.Errorf("Failed to get next checklist dates for empty kandang: %+v", err)
-				return err
-			}
-
-			nextDatesByKandang := make(map[uint][]time.Time)
-			for _, row := range nextDates {
-				nextDatesByKandang[row.KandangID] = append(nextDatesByKandang[row.KandangID], row.Date)
-			}
-
-			for _, rec := range emptyRecs {
-				var nextDate time.Time
-				for _, d := range nextDatesByKandang[rec.KandangID] {
-					if d.After(rec.Date) {
-						nextDate = d
-						break
-					}
-				}
-
-				// If no next checklist, cap empty period at today (not end of month)
-				ceiling := lastDay
-				if today.Before(lastDay) {
-					ceiling = today
-				}
-				periodEnd := ceiling
-				if !nextDate.IsZero() {
-					periodEnd = nextDate.AddDate(0, 0, -1)
-				}
-
-				effectiveStart := rec.Date
 			if effectiveStart.Before(firstDay) {
 				effectiveStart = firstDay
 			}
-				effectiveEnd := periodEnd
+			effectiveEnd := rec.EndDate
 			if effectiveEnd.After(lastDay) {
 				effectiveEnd = lastDay
 			}
-
 			if effectiveStart.After(effectiveEnd) {
 				continue
 			}
@@ -1711,7 +1949,6 @@ func (s dailyChecklistService) GetReport(c *fiber.Ctx, params *validation.Report
 				emptyDaysByKandang[rec.KandangID][d.Day()] = struct{}{}
 			}
 		}
-		}
 
 		for i, item := range items {
 			daySet := emptyDaysByKandang[item.KandangID]

internal/modules/daily-checklists/services/daily-checklist.service_test.go

@@ -208,8 +208,18 @@ func TestCreateOneAllowsBulkEmptyKandangWhenRangeHasOnlySoftDeletedChecklist(t *
 		Count(&activeInRange).Error; err != nil {
 		t.Fatalf("failed counting checklists in range: %v", err)
 	}
-	if activeInRange != 5 {
+	if activeInRange != 1 {
-		t.Fatalf("expected 5 active checklists created for range, got %d", activeInRange)
+		t.Fatalf("expected 1 active empty_kandang checklist created for range, got %d", activeInRange)
+	}
+
+	var emptyRangeCount int64
+	if err := db.Model(&entity.DailyChecklistEmptyKandang{}).
+		Where("kandang_id = ? AND start_date = ? AND end_date = ? AND deleted_at IS NULL", 1, mustDate(t, "2026-01-01"), mustDate(t, "2026-01-05")).
+		Count(&emptyRangeCount).Error; err != nil {
+		t.Fatalf("failed counting empty kandang ranges: %v", err)
+	}
+	if emptyRangeCount != 1 {
+		t.Fatalf("expected 1 empty kandang range record for [2026-01-01, 2026-01-05], got %d", emptyRangeCount)
 	}
 }
 
@@ -304,6 +314,18 @@ func setupDailyChecklistServiceTest(t *testing.T) (DailyChecklistService, *gorm.
 			updated_at DATETIME NULL,
 			deleted_at DATETIME NULL
 		)`,
+		`CREATE TABLE daily_checklist_empty_kandangs (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			daily_checklist_id INTEGER NOT NULL,
+			kandang_id INTEGER NOT NULL,
+			start_date DATE NOT NULL,
+			end_date DATE NOT NULL,
+			created_by INTEGER NULL,
+			deleted_by INTEGER NULL,
+			created_at DATETIME NULL,
+			updated_at DATETIME NULL,
+			deleted_at DATETIME NULL
+		)`,
 		`INSERT INTO areas (id, name, created_by, created_at, updated_at, deleted_at) VALUES (1, 'Area A', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, NULL)`,
 		`INSERT INTO locations (id, name, address, area_id, created_by, created_at, updated_at, deleted_at) VALUES (1, 'Farm A', 'Address', 1, 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, NULL)`,
 		`INSERT INTO kandang_groups (id, name, status, location_id, pic_id, created_by, created_at, updated_at, deleted_at) VALUES (1, 'Kandang A', 'ACTIVE', 1, 1, 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, NULL)`,
@@ -316,7 +338,8 @@ func setupDailyChecklistServiceTest(t *testing.T) (DailyChecklistService, *gorm.
 	}
 
 	repo := repository.NewDailyChecklistRepository(db)
-	svc := NewDailyChecklistService(repo, nil, validator.New(), nil)
+	emptyRepo := repository.NewDailyChecklistEmptyKandangRepository(db)
+	svc := NewDailyChecklistService(repo, emptyRepo, nil, validator.New(), nil)
 	return svc, db
 }
 

internal/modules/daily-checklists/validations/daily-checklist.validation.go

@@ -10,6 +10,7 @@ type Create struct {
 	Category            string `json:"category" validate:"required"`
 	Status              string `json:"status" validate:"required"`
 	EmptyKandang        bool   `json:"empty_kandang"`
+	EmptyKandangEndDate string `json:"empty_kandang_end_date" validate:"omitempty"`
 }
 
 type Update struct {

internal/modules/expenses/controllers/expense.controller.go

@@ -65,6 +65,8 @@ func (u *ExpenseController) GetAll(c *fiber.Ctx) error {
 		RealizationStatus:     strings.TrimSpace(c.Query("realization_status", "")),
 		ProjectFlockID:        uint64(c.QueryInt("project_flock_id", 0)),
 		ProjectFlockKandangID: uint64(c.QueryInt("project_flock_kandang_id", 0)),
+		SortBy:                strings.TrimSpace(c.Query("sort_by", "")),
+		SortOrder:             strings.TrimSpace(c.Query("sort_order", "")),
 	}
 
 	if isAllExpenseExcelExportRequest(c) {
@@ -481,6 +483,27 @@ func (u *ExpenseController) CompleteExpense(c *fiber.Ctx) error {
 		})
 }
 
+func (u *ExpenseController) Pay(c *fiber.Ctx) error {
+	expenseID := c.Params("id")
+	id, err := strconv.Atoi(expenseID)
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "Invalid expense ID")
+	}
+
+	expense, err := u.ExpenseService.Pay(c, uint(id))
+	if err != nil {
+		return err
+	}
+
+	return c.Status(fiber.StatusOK).
+		JSON(response.Success{
+			Code:    fiber.StatusOK,
+			Status:  "success",
+			Message: "Pay expense successfully",
+			Data:    expense,
+		})
+}
+
 func ensureExpenseBulkApprovalPermission(c *fiber.Ctx, targetStep approvalutils.ApprovalStep) error {
 	requiredPerms := []string{}
 

internal/modules/expenses/dto/expense.dto.go

@@ -29,6 +29,7 @@ type ExpenseBaseDTO struct {
 	RealizationDate *time.Time                       `json:"realization_date,omitempty"`
 	TransactionDate time.Time                        `json:"transaction_date"`
 	Location        *locationDTO.LocationRelationDTO `json:"location,omitempty"`
+		IsPaid          bool                             `json:"is_paid"`
 }
 
 type ExpenseListDTO struct {
@@ -127,6 +128,7 @@ func ToExpenseBaseDTO(e *entity.Expense) ExpenseBaseDTO {
 		RealizationDate: realizationDate,
 		TransactionDate: e.TransactionDate,
 		Location:        location,
+		IsPaid:          e.IsPaid,
 	}
 }
 

internal/modules/expenses/repositories/expense_realization.repository.go

@@ -98,6 +98,7 @@ func (r *ExpenseRealizationRepositoryImpl) GetAllWithFilters(ctx context.Context
 			return db.
 				Preload("Expense").
 				Preload("Expense.Supplier").
+				Preload("Expense.Location").
 				Preload("Kandang").
 				Preload("Kandang.Location").
 				Preload("Nonstock").
@@ -177,10 +178,48 @@ func (r *ExpenseRealizationRepositoryImpl) GetAllWithFilters(ctx context.Context
 		return nil, 0, err
 	}
 
+	sortExpr := "expense_realizations.created_at"
+	order := "DESC"
+	if filters.SortOrder == "asc" {
+		order = "ASC"
+	}
+	switch filters.SortBy {
+	case "po_number":
+		sortExpr = "expenses.po_number"
+	case "reference_number":
+		sortExpr = "expenses.reference_number"
+	case "realization_date":
+		sortExpr = "expenses.realization_date"
+	case "transaction_date":
+		sortExpr = "expenses.transaction_date"
+	case "category":
+		sortExpr = "expenses.category"
+	case "product":
+		sortExpr = "(SELECT name FROM nonstocks WHERE id = expense_nonstocks.nonstock_id)"
+	case "supplier":
+		sortExpr = "suppliers.name"
+	case "location":
+		sortExpr = "(SELECT l.name FROM kandangs k JOIN locations l ON l.id = k.location_id WHERE k.id = expense_nonstocks.kandang_id)"
+	case "kandang":
+		sortExpr = "(SELECT name FROM kandangs WHERE id = expense_nonstocks.kandang_id)"
+	case "qty_pengajuan":
+		sortExpr = "expense_nonstocks.qty"
+	case "price_pengajuan":
+		sortExpr = "expense_nonstocks.price"
+	case "total_pengajuan":
+		sortExpr = "expense_nonstocks.qty * expense_nonstocks.price"
+	case "qty_realisasi":
+		sortExpr = "expense_realizations.qty"
+	case "price_realisasi":
+		sortExpr = "expense_realizations.price"
+	case "total_realisasi":
+		sortExpr = "expense_realizations.qty * expense_realizations.price"
+	}
+
 	if err := db.
 		Offset(offset).
 		Limit(limit).
-		Order("expense_realizations.created_at DESC").
+		Order(sortExpr + " " + order).
 		Find(&realizations).Error; err != nil {
 		return nil, 0, err
 	}

internal/modules/expenses/route.go

@@ -36,6 +36,7 @@ func ExpenseRoutes(v1 fiber.Router, u user.UserService, s expense.ExpenseService
 	route.Post("/:id/realizations", m.RequirePermissions(m.P_ExpenseCreateRealizations), ctrl.CreateRealization)
 	route.Patch("/:id/realizations", m.RequirePermissions(m.P_ExpenseUpdateRealizations), ctrl.UpdateRealization)
 	route.Post("/:id/complete", m.RequirePermissions(m.P_ExpenseCompleteExpense), ctrl.CompleteExpense)
+	route.Patch("/:id/pay", m.RequirePermissions(m.P_ExpenseCreateRealizations), ctrl.Pay)
 	route.Delete("/:id/documents/:documentId", m.RequirePermissions(m.P_ExpenseDocument), ctrl.DeleteDocument)
 	route.Delete("/:id/realization-documents/:documentId", m.RequirePermissions(m.P_ExpenseDocumentRealizations), ctrl.DeleteRealizationDocument)
 }

internal/modules/expenses/services/expense.service.go

@@ -36,6 +36,7 @@ type ExpenseService interface {
 	DeleteOne(ctx *fiber.Ctx, id uint64) error
 	CreateRealization(ctx *fiber.Ctx, expenseID uint, req *validation.CreateRealization) (*expenseDto.ExpenseDetailDTO, error)
 	CompleteExpense(ctx *fiber.Ctx, id uint, notes *string) (*expenseDto.ExpenseDetailDTO, error)
+	Pay(ctx *fiber.Ctx, id uint) (*expenseDto.ExpenseDetailDTO, error)
 	UpdateRealization(ctx *fiber.Ctx, expenseID uint, req *validation.UpdateRealization) (*expenseDto.ExpenseDetailDTO, error)
 	DeleteDocument(ctx *fiber.Ctx, expenseID uint, documentID uint64, isRealization bool) error
 	Approval(ctx *fiber.Ctx, req *validation.ApprovalRequest, approvalType string) ([]expenseDto.ExpenseDetailDTO, error)
@@ -288,7 +289,40 @@ func (s expenseService) GetAll(c *fiber.Ctx, params *validation.Query) ([]expens
 				like,
 			)
 		}
+		sortBy := strings.TrimSpace(params.SortBy)
+		sortOrder := strings.ToUpper(strings.TrimSpace(params.SortOrder))
+		if sortOrder == "" {
+			sortOrder = "DESC"
+		}
+
+		switch sortBy {
+		case "reference_number":
+			return db.Order("expenses.reference_number " + sortOrder)
+		case "transaction_date":
+			return db.Order("expenses.transaction_date " + sortOrder)
+		case "realization_date":
+			return db.Order("expenses.realization_date " + sortOrder)
+		case "location":
+			return db.Order("(SELECT COALESCE(name,'') FROM locations WHERE id = expenses.location_id) " + sortOrder)
+		case "created_user":
+			return db.Order("(SELECT COALESCE(name,'') FROM users WHERE id = expenses.created_by) " + sortOrder)
+		case "supplier":
+			return db.Order("(SELECT COALESCE(name,'') FROM suppliers WHERE id = expenses.supplier_id) " + sortOrder)
+		case "grand_total":
+			return db.Order(`(SELECT COALESCE(
+				(SELECT SUM(er.qty * er.price) FROM expense_realizations er
+				 JOIN expense_nonstocks en ON en.id = er.expense_nonstock_id
+				 WHERE en.expense_id = expenses.id),
+				(SELECT SUM(en2.qty * en2.price) FROM expense_nonstocks en2
+				 WHERE en2.expense_id = expenses.id),
+			0)) ` + sortOrder)
+		case "is_paid":
+			return db.Order("expenses.is_paid " + sortOrder)
+		case "created_at":
+			return db.Order("expenses.created_at " + sortOrder)
+		default:
 			return db.Order("expenses.created_at DESC").Order("expenses.updated_at DESC")
+		}
 	})
 
 	if scopeErr != nil {
@@ -1310,6 +1344,41 @@ func (s *expenseService) CompleteExpense(c *fiber.Ctx, id uint, notes *string) (
 	return responseDTO, nil
 }
 
+func (s *expenseService) Pay(c *fiber.Ctx, id uint) (*expenseDto.ExpenseDetailDTO, error) {
+	if err := commonSvc.EnsureRelations(c.Context(),
+		commonSvc.RelationCheck{Name: "Expense", ID: &id, Exists: s.Repository.IdExists},
+	); err != nil {
+		return nil, err
+	}
+
+	expense, err := s.Repository.GetByID(c.Context(), id, nil)
+	if err != nil {
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to get expense")
+	}
+	if expense.IsPaid {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "Expense is already paid")
+	}
+
+	latestApproval, err := s.ApprovalSvc.LatestByTarget(c.Context(), utils.ApprovalWorkflowExpense, id, func(db *gorm.DB) *gorm.DB {
+		return db.Where("action = ?", entity.ApprovalActionApproved)
+	})
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to validate workflow")
+	}
+	if latestApproval == nil {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "Expense must be approved by Finance (step 4) before payment")
+	}
+	if latestApproval.StepNumber < uint16(utils.ExpenseStepFinance) {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "Expense must be approved by Finance (step 4) before payment")
+	}
+
+	if err := s.Repository.PatchOne(c.Context(), id, map[string]any{"is_paid": true}, nil); err != nil {
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to update payment status")
+	}
+
+	return s.GetOne(c, id)
+}
+
 func (s *expenseService) UpdateRealization(c *fiber.Ctx, expenseID uint, req *validation.UpdateRealization) (*expenseDto.ExpenseDetailDTO, error) {
 	if err := s.Validate.Struct(req); err != nil {
 

internal/modules/expenses/validations/expense.validation.go

@@ -54,6 +54,8 @@ type Query struct {
 	RealizationStatus     string `query:"realization_status" validate:"omitempty,max=100"`
 	ProjectFlockID        uint64 `query:"project_flock_id" validate:"omitempty,gt=0"`
 	ProjectFlockKandangID uint64 `query:"project_flock_kandang_id" validate:"omitempty,gt=0"`
+	SortBy                string `query:"sort_by" validate:"omitempty,oneof=reference_number transaction_date realization_date location created_user supplier grand_total is_paid created_at"`
+	SortOrder             string `query:"sort_order" validate:"omitempty,oneof=asc desc ASC DESC"`
 }
 
 type CreateRealization struct {

internal/modules/finance/transactions/controllers/transaction.controller.go

@@ -5,6 +5,7 @@ import (
 	"strconv"
 	"strings"
 
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	"gitlab.com/mbugroup/lti-api.git/internal/modules/finance/transactions/dto"
 	service "gitlab.com/mbugroup/lti-api.git/internal/modules/finance/transactions/services"
 	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/finance/transactions/validations"
@@ -13,6 +14,8 @@ import (
 	"github.com/gofiber/fiber/v2"
 )
 
+const transactionExcelExportFetchLimit = 99999999
+
 type TransactionController struct {
 	TransactionService service.TransactionService
 }
@@ -97,6 +100,8 @@ func (u *TransactionController) GetAll(c *fiber.Ctx) error {
 		CustomerIDs:      customerIDs,
 		SupplierIDs:      supplierIDs,
 		SortDate:         c.Query("sort_date", ""),
+		SortBy:           c.Query("sort_by", ""),
+		SortOrder:        c.Query("sort_order", ""),
 		StartDate:        c.Query("start_date", ""),
 		EndDate:          c.Query("end_date", ""),
 	}
@@ -105,6 +110,14 @@ func (u *TransactionController) GetAll(c *fiber.Ctx) error {
 		return fiber.NewError(fiber.StatusBadRequest, "page and limit must be greater than 0")
 	}
 
+	if isTransactionExcelExportRequest(c) {
+		results, err := u.getAllTransactionsForExcel(c, query)
+		if err != nil {
+			return err
+		}
+		return exportTransactionListExcel(c, results)
+	}
+
 	result, totalResults, err := u.TransactionService.GetAll(c, query)
 	if err != nil {
 		return err
@@ -147,6 +160,32 @@ func (u *TransactionController) GetOne(c *fiber.Ctx) error {
 		})
 }
 
+func isTransactionExcelExportRequest(c *fiber.Ctx) bool {
+	return strings.EqualFold(strings.TrimSpace(c.Query("export")), "excel")
+}
+
+func (u *TransactionController) getAllTransactionsForExcel(c *fiber.Ctx, baseQuery *validation.Query) ([]entity.Payment, error) {
+	query := *baseQuery
+	query.Page = 1
+	query.Limit = transactionExcelExportFetchLimit
+	results := make([]entity.Payment, 0)
+	for {
+		pageResults, total, err := u.TransactionService.GetAll(c, &query)
+		if err != nil {
+			return nil, err
+		}
+		if len(pageResults) == 0 || total == 0 {
+			break
+		}
+		results = append(results, pageResults...)
+		if int64(len(results)) >= total {
+			break
+		}
+		query.Page++
+	}
+	return results, nil
+}
+
 func (u *TransactionController) DeleteOne(c *fiber.Ctx) error {
 	param := c.Params("id")
 

internal/modules/finance/transactions/controllers/transaction.export.go

@@ -0,0 +1,307 @@
+package controller
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/xuri/excelize/v2"
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+)
+
+const transactionExportSheetName = "Transaksi"
+
+func exportTransactionListExcel(c *fiber.Ctx, payments []entity.Payment) error {
+	content, err := buildTransactionExportWorkbook(payments)
+	if err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "failed to generate excel file")
+	}
+
+	filename := fmt.Sprintf("transaksi_%s.xlsx", time.Now().Format("20060102_150405"))
+	c.Set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+	c.Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, filename))
+	return c.Status(fiber.StatusOK).Send(content)
+}
+
+func buildTransactionExportWorkbook(payments []entity.Payment) ([]byte, error) {
+	file := excelize.NewFile()
+	defer file.Close()
+
+	defaultSheet := file.GetSheetName(file.GetActiveSheetIndex())
+	if defaultSheet != transactionExportSheetName {
+		if err := file.SetSheetName(defaultSheet, transactionExportSheetName); err != nil {
+			return nil, err
+		}
+	}
+
+	if err := setTransactionExportColumns(file); err != nil {
+		return nil, err
+	}
+	if err := setTransactionExportHeaders(file); err != nil {
+		return nil, err
+	}
+	if err := setTransactionExportRows(file, payments); err != nil {
+		return nil, err
+	}
+	if err := file.SetPanes(transactionExportSheetName, &excelize.Panes{
+		Freeze:      true,
+		YSplit:      1,
+		TopLeftCell: "A2",
+		ActivePane:  "bottomLeft",
+	}); err != nil {
+		return nil, err
+	}
+
+	buffer, err := file.WriteToBuffer()
+	if err != nil {
+		return nil, err
+	}
+
+	return buffer.Bytes(), nil
+}
+
+func setTransactionExportColumns(file *excelize.File) error {
+	columnWidths := map[string]float64{
+		"A": 20,
+		"B": 22,
+		"C": 18,
+		"D": 25,
+		"E": 14,
+		"F": 16,
+		"G": 16,
+		"H": 22,
+		"I": 22,
+		"J": 18,
+		"K": 18,
+		"L": 18,
+		"M": 30,
+		"N": 22,
+		"O": 20,
+	}
+
+	sheet := transactionExportSheetName
+	for col, width := range columnWidths {
+		if err := file.SetColWidth(sheet, col, col, width); err != nil {
+			return err
+		}
+	}
+
+	return file.SetRowHeight(sheet, 1, 24)
+}
+
+func setTransactionExportHeaders(file *excelize.File) error {
+	sheet := transactionExportSheetName
+	headers := []string{
+		"Kode Pembayaran",
+		"No. Referensi",
+		"Tipe Transaksi",
+		"Pihak",
+		"Tipe Pihak",
+		"Tanggal Bayar",
+		"Metode Bayar",
+		"Bank",
+		"No. Rekening Bank",
+		"Pemasukan",
+		"Pengeluaran",
+		"Nominal",
+		"Catatan",
+		"Dibuat Oleh",
+		"Status",
+	}
+
+	for i, header := range headers {
+		colName, err := excelize.ColumnNumberToName(i + 1)
+		if err != nil {
+			return err
+		}
+		if err := file.SetCellValue(sheet, colName+"1", header); err != nil {
+			return err
+		}
+	}
+
+	headerStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Bold: true, Color: "1F2937"},
+		Fill:      excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"DCEBFA"}},
+		Alignment: &excelize.Alignment{Horizontal: "center", Vertical: "center"},
+		Border: []excelize.Border{
+			{Type: "left", Color: "D1D5DB", Style: 1},
+			{Type: "top", Color: "D1D5DB", Style: 1},
+			{Type: "bottom", Color: "D1D5DB", Style: 1},
+			{Type: "right", Color: "D1D5DB", Style: 1},
+		},
+	})
+	if err != nil {
+		return err
+	}
+
+	return file.SetCellStyle(sheet, "A1", "O1", headerStyle)
+}
+
+func setTransactionExportRows(file *excelize.File, payments []entity.Payment) error {
+	if len(payments) == 0 {
+		return nil
+	}
+
+	sheet := transactionExportSheetName
+	for i, p := range payments {
+		row := strconv.Itoa(i + 2)
+		if err := writeTransactionExportRow(file, sheet, row, p); err != nil {
+			return err
+		}
+	}
+
+	lastRow := strconv.Itoa(len(payments) + 1)
+
+	dataStyle, err := file.NewStyle(&excelize.Style{
+		Alignment: &excelize.Alignment{Horizontal: "left", Vertical: "center", WrapText: true},
+		Border: []excelize.Border{
+			{Type: "left", Color: "D1D5DB", Style: 1},
+			{Type: "top", Color: "D1D5DB", Style: 1},
+			{Type: "bottom", Color: "D1D5DB", Style: 1},
+			{Type: "right", Color: "D1D5DB", Style: 1},
+		},
+	})
+	if err != nil {
+		return err
+	}
+	if err := file.SetCellStyle(sheet, "A2", "O"+lastRow, dataStyle); err != nil {
+		return err
+	}
+
+	numericStyle, err := file.NewStyle(&excelize.Style{
+		Alignment: &excelize.Alignment{Horizontal: "right", Vertical: "center"},
+		Border: []excelize.Border{
+			{Type: "left", Color: "D1D5DB", Style: 1},
+			{Type: "top", Color: "D1D5DB", Style: 1},
+			{Type: "bottom", Color: "D1D5DB", Style: 1},
+			{Type: "right", Color: "D1D5DB", Style: 1},
+		},
+	})
+	if err != nil {
+		return err
+	}
+
+	return file.SetCellStyle(sheet, "J2", "L"+lastRow, numericStyle)
+}
+
+func writeTransactionExportRow(file *excelize.File, sheet, row string, p entity.Payment) error {
+	incomeAmount, expenseAmount := txAmounts(p.Direction, p.Nominal)
+
+	values := []interface{}{
+		safeTxText(p.PaymentCode),
+		safeTxRefNumber(p.ReferenceNumber),
+		safeTxText(txTransactionType(p)),
+		safeTxText(txPartyName(p)),
+		safeTxText(p.PartyType),
+		formatTxDate(p.PaymentDate),
+		safeTxText(p.PaymentMethod),
+		safeTxBank(p),
+		safeTxBankAccount(p),
+		incomeAmount,
+		expenseAmount,
+		p.Nominal,
+		safeTxText(p.Notes),
+		safeTxText(txCreatedBy(p)),
+		formatTxStatus(p),
+	}
+
+	for colIdx, val := range values {
+		colName, err := excelize.ColumnNumberToName(colIdx + 1)
+		if err != nil {
+			return err
+		}
+		if err := file.SetCellValue(sheet, colName+row, val); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func safeTxText(s string) string {
+	trimmed := strings.TrimSpace(s)
+	if trimmed == "" {
+		return "-"
+	}
+	return trimmed
+}
+
+func safeTxRefNumber(s *string) string {
+	if s == nil {
+		return "-"
+	}
+	return safeTxText(*s)
+}
+
+func safeTxBank(p entity.Payment) string {
+	if p.BankWarehouse.Id == 0 {
+		return "-"
+	}
+	return safeTxText(p.BankWarehouse.Name)
+}
+
+func safeTxBankAccount(p entity.Payment) string {
+	if p.BankWarehouse.Id == 0 {
+		return "-"
+	}
+	return safeTxText(p.BankWarehouse.AccountNumber)
+}
+
+func formatTxDate(t time.Time) string {
+	if t.IsZero() {
+		return "-"
+	}
+	loc, err := time.LoadLocation("Asia/Jakarta")
+	if err == nil {
+		t = t.In(loc)
+	}
+	return t.Format("02-01-2006")
+}
+
+func formatTxStatus(p entity.Payment) string {
+	if p.LatestApproval == nil {
+		return "-"
+	}
+	return safeTxText(p.LatestApproval.StepName)
+}
+
+func txTransactionType(p entity.Payment) string {
+	if p.TransactionType != "" {
+		return p.TransactionType
+	}
+	return p.Direction
+}
+
+func txPartyName(p entity.Payment) string {
+	switch p.PartyType {
+	case "CUSTOMER":
+		if p.Customer != nil && p.Customer.Id != 0 {
+			return p.Customer.Name
+		}
+	case "SUPPLIER":
+		if p.Supplier != nil && p.Supplier.Id != 0 {
+			return p.Supplier.Name
+		}
+	}
+	return ""
+}
+
+func txCreatedBy(p entity.Payment) string {
+	if p.CreatedUser.Id == 0 {
+		return ""
+	}
+	return p.CreatedUser.Name
+}
+
+func txAmounts(direction string, nominal float64) (income, expense float64) {
+	switch strings.ToUpper(direction) {
+	case "IN":
+		return nominal, 0
+	case "OUT":
+		return 0, nominal
+	default:
+		return 0, 0
+	}
+}

internal/modules/finance/transactions/services/transaction.service.go

@@ -72,19 +72,26 @@ func (s transactionService) GetAll(c *fiber.Ctx, params *validation.Query) ([]en
 	transactions, total, err := s.Repository.GetAll(c.Context(), offset, params.Limit, func(db *gorm.DB) *gorm.DB {
 		db = s.withRelations(db)
 
-		if params.Search != "" {
+		needsPartyJoin := params.Search != "" || params.SortBy == "customer_name"
-			like := "%" + strings.ToLower(strings.TrimSpace(params.Search)) + "%"
+		needsBankJoin := params.Search != "" || params.SortBy == "bank"
+
+		if needsPartyJoin {
 			db = db.Joins(
 				"LEFT JOIN customers ON customers.id = payments.party_id AND payments.party_type = ? AND customers.deleted_at IS NULL",
 				string(utils.PaymentPartyCustomer),
 			).Joins(
 				"LEFT JOIN suppliers ON suppliers.id = payments.party_id AND payments.party_type = ? AND suppliers.deleted_at IS NULL",
 				string(utils.PaymentPartySupplier),
-			).Joins(
-				"LEFT JOIN banks ON banks.id = payments.bank_id AND banks.deleted_at IS NULL",
 			)
+		}
+		if needsBankJoin {
+			db = db.Joins("LEFT JOIN banks ON banks.id = payments.bank_id AND banks.deleted_at IS NULL")
+		}
+
+		if params.Search != "" {
+			like := "%" + strings.ToLower(strings.TrimSpace(params.Search)) + "%"
 			db = db.Where(
-				`LOWER(payment_code) LIKE ? OR
+				`(LOWER(payment_code) LIKE ? OR
 				LOWER(COALESCE(reference_number, '')) LIKE ? OR
 				LOWER(COALESCE(payment_method, '')) LIKE ? OR
 				LOWER(COALESCE(transaction_type, '')) LIKE ? OR
@@ -93,7 +100,7 @@ func (s transactionService) GetAll(c *fiber.Ctx, params *validation.Query) ([]en
 				LOWER(COALESCE(suppliers.name, '')) LIKE ? OR
 				LOWER(COALESCE(banks.name, '')) LIKE ? OR
 				CAST(payments.nominal AS TEXT) LIKE ? OR
-				TO_CHAR(payments.payment_date, 'YYYY-MM-DD') LIKE ?`,
+				TO_CHAR(payments.payment_date, 'YYYY-MM-DD') LIKE ?)`,
 				like, like, like, like, like, like, like, like, like, like,
 			)
 		}
@@ -138,7 +145,7 @@ func (s transactionService) GetAll(c *fiber.Ctx, params *validation.Query) ([]en
 			db = db.Where("payment_date < ?", *endDate)
 		}
 
-		return applyTransactionSort(db, params.SortDate)
+		return applyTransactionSort(db, params.SortBy, params.SortOrder, params.SortDate)
 	})
 
 	if err != nil {
@@ -270,13 +277,39 @@ func parseTransactionDateRange(startDate, endDate string) (*time.Time, *time.Tim
 	return startPtr, endPtr, nil
 }
 
-func applyTransactionSort(db *gorm.DB, sortDate string) *gorm.DB {
+func applyTransactionSort(db *gorm.DB, sortBy, sortOrder, sortDate string) *gorm.DB {
+	order := "DESC"
+	if strings.ToUpper(strings.TrimSpace(sortOrder)) == "ASC" {
+		order = "ASC"
+	}
+
+	switch strings.ToLower(strings.TrimSpace(sortBy)) {
+	case "payment_code":
+		return db.Order("payments.payment_code " + order)
+	case "reference_number":
+		return db.Order("payments.reference_number " + order)
+	case "transaction_type":
+		return db.Order("payments.transaction_type " + order)
+	case "customer_name":
+		return db.Order("COALESCE(customers.name, suppliers.name) " + order)
+	case "payment_date":
+		return db.Order("payments.payment_date " + order)
+	case "created_at":
+		return db.Order("payments.created_at " + order)
+	case "payment_method":
+		return db.Order("payments.payment_method " + order)
+	case "bank":
+		return db.Order("banks.account_number " + order)
+	case "expense_amount":
+		return db.Order("CASE WHEN payments.direction = 'OUT' THEN payments.nominal ELSE 0 END " + order)
+	case "income_amount":
+		return db.Order("CASE WHEN payments.direction = 'IN' THEN payments.nominal ELSE 0 END " + order)
+	}
+
 	switch strings.ToLower(strings.TrimSpace(sortDate)) {
 	case "created_at":
-		return db.Order("created_at DESC").Order("payment_date DESC")
+		return db.Order("payments.created_at DESC").Order("payments.payment_date DESC")
-	case "payment_date":
-		return db.Order("payment_date DESC").Order("created_at DESC")
 	default:
-		return db.Order("payment_date DESC").Order("created_at DESC")
+		return db.Order("payments.payment_date DESC").Order("payments.created_at DESC")
 	}
 }

internal/modules/finance/transactions/validations/transaction.validation.go

@@ -10,13 +10,15 @@ type Update struct {
 
 type Query struct {
 	Page             int      `query:"page" validate:"omitempty,number,min=1,gt=0"`
-	Limit            int      `query:"limit" validate:"omitempty,number,min=1,max=100,gt=0"`
+	Limit            int      `query:"limit" validate:"omitempty,number,min=1,gt=0"`
 	Search           string   `query:"search" validate:"omitempty,max=50"`
 	TransactionTypes []string `query:"transaction_types" validate:"omitempty,dive,max=50"`
 	BankIDs          []uint   `query:"bank_ids" validate:"omitempty,dive,gt=0"`
 	CustomerIDs      []uint   `query:"customer_ids" validate:"omitempty,dive,gt=0"`
 	SupplierIDs      []uint   `query:"supplier_ids" validate:"omitempty,dive,gt=0"`
 	SortDate         string   `query:"sort_date" validate:"omitempty,oneof=created_at payment_date"`
+	SortBy           string   `query:"sort_by" validate:"omitempty,oneof=payment_code reference_number transaction_type customer_name payment_date created_at payment_method bank expense_amount income_amount"`
+	SortOrder        string   `query:"sort_order" validate:"omitempty,oneof=asc desc"`
 	StartDate        string   `query:"start_date" validate:"omitempty,datetime=2006-01-02"`
 	EndDate          string   `query:"end_date" validate:"omitempty,datetime=2006-01-02"`
 }

internal/modules/inventory/route.go

@@ -10,6 +10,7 @@ import (
 	adjustments "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/adjustments"
 	productStocks "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-stocks"
 	productWarehouses "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses"
+	stockLogs "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/stock-logs"
 	transfers "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/transfers"
 	// MODULE IMPORTS
 )
@@ -23,6 +24,7 @@ func RegisterRoutes(router fiber.Router, db *gorm.DB, validate *validator.Valida
 		adjustments.AdjustmentModule{},
 		transfers.TransferModule{},
 		productStocks.ProductStockModule{},
+		stockLogs.StockLogModule{},
 		// MODULE REGISTRY
 	}
 

internal/modules/inventory/stock-logs/controllers/stock-log.controller.go

@@ -0,0 +1,66 @@
+package controller
+
+import (
+	"math"
+	"strings"
+
+	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/stock-logs/validations"
+	stockLogDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/stock-logs/dto"
+	stockLogService "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/stock-logs/services"
+	"gitlab.com/mbugroup/lti-api.git/internal/response"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+type StockLogController struct {
+	StockLogService stockLogService.StockLogService
+}
+
+func NewStockLogController(s stockLogService.StockLogService) *StockLogController {
+	return &StockLogController{
+		StockLogService: s,
+	}
+}
+
+func (u *StockLogController) GetAll(c *fiber.Ctx) error {
+	query := &validation.Query{
+		Page:               c.QueryInt("page", 1),
+		Limit:              c.QueryInt("limit", 10),
+		ProductWarehouseID: uint(c.QueryInt("product_warehouse_id", 0)),
+	}
+
+	if query.Page < 1 || query.Limit < 1 {
+		return fiber.NewError(fiber.StatusBadRequest, "page and limit must be greater than 0")
+	}
+
+	// Export to Excel
+	if strings.EqualFold(strings.TrimSpace(c.Query("export")), "excel") {
+		if query.ProductWarehouseID == 0 {
+			return fiber.NewError(fiber.StatusBadRequest, "product_warehouse_id is required for export")
+		}
+		results, err := u.StockLogService.GetAllForExport(c, query.ProductWarehouseID)
+		if err != nil {
+			return err
+		}
+		return exportStockLogListExcel(c, results)
+	}
+
+	result, totalResults, err := u.StockLogService.GetAll(c, query)
+	if err != nil {
+		return err
+	}
+
+	return c.Status(fiber.StatusOK).
+		JSON(response.SuccessWithPaginate[stockLogDTO.StockLogListDTO]{
+			Code:    fiber.StatusOK,
+			Status:  "success",
+			Message: "Get all stock logs successfully",
+			Meta: response.Meta{
+				Page:         query.Page,
+				Limit:        query.Limit,
+				TotalPages:   int64(math.Ceil(float64(totalResults) / float64(query.Limit))),
+				TotalResults: totalResults,
+			},
+			Data: stockLogDTO.ToStockLogListDTOs(result),
+		})
+}

internal/modules/inventory/stock-logs/controllers/stock-log.export.go

@@ -0,0 +1,118 @@
+package controller
+
+import (
+	"fmt"
+	"time"
+
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/xuri/excelize/v2"
+)
+
+func exportStockLogListExcel(c *fiber.Ctx, stockLogs []entity.StockLog) error {
+	file := excelize.NewFile()
+	defer file.Close()
+
+	sheet := "Stock Logs"
+	file.SetSheetName("Sheet1", sheet)
+
+	headers := []string{
+		"ID",
+		"Tanggal",
+		"Gudang",
+		"Stok Akhir",
+		"Peningkatan",
+		"Penurunan",
+		"Jenis Transaksi",
+		"Catatan",
+		"Oleh",
+	}
+
+	// Column widths
+	colWidths := map[string]float64{
+		"A": 8,
+		"B": 20,
+		"C": 25,
+		"D": 14,
+		"E": 14,
+		"F": 14,
+		"G": 20,
+		"H": 30,
+		"I": 20,
+	}
+	for col, width := range colWidths {
+		file.SetColWidth(sheet, col, col, width)
+	}
+
+	// Header style
+	headerStyle, _ := file.NewStyle(&excelize.Style{
+		Font: &excelize.Font{
+			Bold: true,
+			Size: 11,
+		},
+		Fill: excelize.Fill{
+			Type:    "pattern",
+			Pattern: 1,
+			Color:   []string{"D9E1F2"},
+		},
+		Border: []excelize.Border{
+			{Type: "bottom", Style: 1, Color: "000000"},
+		},
+	})
+
+	// Write header row
+	for i, h := range headers {
+		cell, _ := excelize.CoordinatesToCellName(i+1, 1)
+		file.SetCellValue(sheet, cell, h)
+		file.SetCellStyle(sheet, cell, cell, headerStyle)
+	}
+
+	// Freeze header row
+	file.SetPanes(sheet, &excelize.Panes{
+		Freeze:      true,
+		YSplit:      1,
+		TopLeftCell: "A2",
+		ActivePane:  "bottomLeft",
+	})
+
+	// Write data rows
+	for i, log := range stockLogs {
+		row := i + 2
+
+		warehouseName := ""
+		if log.ProductWarehouse != nil {
+			warehouseName = log.ProductWarehouse.Warehouse.Name
+		}
+
+		userName := ""
+		if log.CreatedUser != nil {
+			userName = log.CreatedUser.Name
+		}
+
+		notes := ""
+		if log.Notes != "" {
+			notes = log.Notes
+		}
+
+		file.SetCellInt(sheet, fmt.Sprintf("A%d", row), int(log.Id))
+		file.SetCellValue(sheet, fmt.Sprintf("B%d", row), log.CreatedAt.Format("2006-01-02 15:04:05"))
+		file.SetCellValue(sheet, fmt.Sprintf("C%d", row), warehouseName)
+		file.SetCellFloat(sheet, fmt.Sprintf("D%d", row), log.Stock, 3, 64)
+		file.SetCellFloat(sheet, fmt.Sprintf("E%d", row), log.Increase, 3, 64)
+		file.SetCellFloat(sheet, fmt.Sprintf("F%d", row), log.Decrease, 3, 64)
+		file.SetCellValue(sheet, fmt.Sprintf("G%d", row), log.LoggableType)
+		file.SetCellValue(sheet, fmt.Sprintf("H%d", row), notes)
+		file.SetCellValue(sheet, fmt.Sprintf("I%d", row), userName)
+	}
+
+	buffer, err := file.WriteToBuffer()
+	if err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "failed to generate excel file")
+	}
+
+	filename := fmt.Sprintf("stock_logs_%s.xlsx", time.Now().Format("20060102_150405"))
+	c.Set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+	c.Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, filename))
+	return c.Status(fiber.StatusOK).Send(buffer.Bytes())
+}

internal/modules/inventory/stock-logs/dto/stock-log.dto.go

@@ -0,0 +1,61 @@
+package dto
+
+import (
+	"time"
+
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	userDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/users/dto"
+)
+
+type StockLogListDTO struct {
+	Id                 uint                     `json:"id"`
+	ProductWarehouseId uint                     `json:"product_warehouse_id"`
+	Increase           float64                  `json:"increase"`
+	Decrease           float64                  `json:"decrease"`
+	Stock              float64                  `json:"stock"`
+	LoggableType       string                   `json:"loggable_type"`
+	LoggableId         uint                     `json:"loggable_id"`
+	Notes              *string                  `json:"notes"`
+	CreatedBy          uint                     `json:"created_by"`
+	CreatedUser        *userDTO.UserRelationDTO `json:"created_user,omitempty"`
+	CreatedAt          time.Time                `json:"created_at"`
+}
+
+func ToStockLogListDTO(e entity.StockLog) StockLogListDTO {
+	var notes *string
+	if e.Notes != "" {
+		n := e.Notes
+		notes = &n
+	}
+
+	var createdUser *userDTO.UserRelationDTO
+	if e.CreatedUser != nil && e.CreatedUser.Id != 0 {
+		mapped := userDTO.ToUserRelationDTO(*e.CreatedUser)
+		createdUser = &mapped
+	}
+
+	return StockLogListDTO{
+		Id:                 e.Id,
+		ProductWarehouseId: e.ProductWarehouseId,
+		Increase:           e.Increase,
+		Decrease:           e.Decrease,
+		Stock:              e.Stock,
+		LoggableType:       e.LoggableType,
+		LoggableId:         e.LoggableId,
+		Notes:              notes,
+		CreatedBy:          e.CreatedBy,
+		CreatedUser:        createdUser,
+		CreatedAt:          e.CreatedAt,
+	}
+}
+
+func ToStockLogListDTOs(e []entity.StockLog) []StockLogListDTO {
+	if len(e) == 0 {
+		return []StockLogListDTO{}
+	}
+	result := make([]StockLogListDTO, len(e))
+	for i, log := range e {
+		result[i] = ToStockLogListDTO(log)
+	}
+	return result
+}

internal/modules/inventory/stock-logs/module.go

@@ -0,0 +1,24 @@
+package stockLogs
+
+import (
+	"github.com/go-playground/validator/v10"
+	"github.com/gofiber/fiber/v2"
+	"gorm.io/gorm"
+
+	stockLogService "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/stock-logs/services"
+	stockLogRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
+	rUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
+	sUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
+)
+
+type StockLogModule struct{}
+
+func (StockLogModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *validator.Validate) {
+	userRepo := rUser.NewUserRepository(db)
+	userService := sUser.NewUserService(userRepo, validate)
+
+	stockLogRepo := stockLogRepo.NewStockLogRepository(db)
+	service := stockLogService.NewStockLogService(stockLogRepo, validate)
+
+	StockLogRoutes(router, userService, service)
+}

internal/modules/inventory/stock-logs/route.go

@@ -0,0 +1,19 @@
+package stockLogs
+
+import (
+	m "gitlab.com/mbugroup/lti-api.git/internal/middleware"
+	controller "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/stock-logs/controllers"
+	stockLog "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/stock-logs/services"
+	user "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+func StockLogRoutes(v1 fiber.Router, u user.UserService, s stockLog.StockLogService) {
+	ctrl := controller.NewStockLogController(s)
+
+	route := v1.Group("/stock-logs")
+	route.Use(m.Auth(u))
+
+	route.Get("/", m.RequirePermissions(m.P_StockLogGetAll), ctrl.GetAll)
+}

internal/modules/inventory/stock-logs/services/stock-log.service.go

@@ -0,0 +1,125 @@
+package service
+
+import (
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	m "gitlab.com/mbugroup/lti-api.git/internal/middleware"
+	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/stock-logs/validations"
+	stockLogRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+
+	"github.com/go-playground/validator/v10"
+	"github.com/gofiber/fiber/v2"
+	"github.com/sirupsen/logrus"
+	"gorm.io/gorm"
+)
+
+type StockLogService interface {
+	GetAll(ctx *fiber.Ctx, params *validation.Query) ([]entity.StockLog, int64, error)
+	GetAllForExport(ctx *fiber.Ctx, productWarehouseID uint) ([]entity.StockLog, error)
+}
+
+type stockLogService struct {
+	Log              *logrus.Logger
+	Validate         *validator.Validate
+	StockLogRepo     stockLogRepo.StockLogRepository
+}
+
+func NewStockLogService(
+	stockLogRepo stockLogRepo.StockLogRepository,
+	validate *validator.Validate,
+) StockLogService {
+	return &stockLogService{
+		Log:          utils.Log,
+		Validate:     validate,
+		StockLogRepo: stockLogRepo,
+	}
+}
+
+func (s *stockLogService) GetAll(c *fiber.Ctx, params *validation.Query) ([]entity.StockLog, int64, error) {
+	if err := s.Validate.Struct(params); err != nil {
+		return nil, 0, err
+	}
+
+	locationScope, areaScope, err := m.ResolveLocationAreaScopes(c, s.StockLogRepo.DB())
+	if err != nil {
+		return nil, 0, err
+	}
+
+	offset := (params.Page - 1) * params.Limit
+
+	stockLogs, total, err := s.StockLogRepo.GetAll(c.Context(), offset, params.Limit, func(db *gorm.DB) *gorm.DB {
+		db = db.Where("product_warehouse_id = ?", params.ProductWarehouseID)
+
+		if locationScope.Restrict || areaScope.Restrict {
+			if (locationScope.Restrict && len(locationScope.IDs) == 0) || (areaScope.Restrict && len(areaScope.IDs) == 0) {
+				return db.Where("1 = 0")
+			}
+			db = db.
+				Joins("JOIN product_warehouses pw ON pw.id = stock_logs.product_warehouse_id").
+				Joins("JOIN warehouses w ON w.id = pw.warehouse_id")
+			if locationScope.Restrict {
+				db = db.Where("w.location_id IN ?", locationScope.IDs)
+			}
+			if areaScope.Restrict {
+				db = db.Where("w.area_id IN ?", areaScope.IDs)
+			}
+		}
+
+		db = db.
+			Preload("CreatedUser").
+			Order("stock_logs.created_at DESC")
+
+		return db
+	})
+	if err != nil {
+		s.Log.Errorf("Failed to get stock logs: %+v", err)
+		return nil, 0, err
+	}
+
+	if total == 0 {
+		return []entity.StockLog{}, 0, nil
+	}
+
+	return stockLogs, total, nil
+}
+
+func (s *stockLogService) GetAllForExport(c *fiber.Ctx, productWarehouseID uint) ([]entity.StockLog, error) {
+	locationScope, areaScope, err := m.ResolveLocationAreaScopes(c, s.StockLogRepo.DB())
+	if err != nil {
+		return nil, err
+	}
+
+	stockLogs, _, err := s.StockLogRepo.GetAll(c.Context(), 0, -1, func(db *gorm.DB) *gorm.DB {
+		db = db.Where("product_warehouse_id = ?", productWarehouseID)
+
+		if locationScope.Restrict || areaScope.Restrict {
+			if (locationScope.Restrict && len(locationScope.IDs) == 0) || (areaScope.Restrict && len(areaScope.IDs) == 0) {
+				return db.Where("1 = 0")
+			}
+			db = db.
+				Joins("JOIN product_warehouses pw ON pw.id = stock_logs.product_warehouse_id").
+				Joins("JOIN warehouses w ON w.id = pw.warehouse_id")
+			if locationScope.Restrict {
+				db = db.Where("w.location_id IN ?", locationScope.IDs)
+			}
+			if areaScope.Restrict {
+				db = db.Where("w.area_id IN ?", areaScope.IDs)
+			}
+		}
+
+		db = db.
+			Preload("CreatedUser").
+			Preload("ProductWarehouse").
+			Preload("ProductWarehouse.Warehouse").
+			Order("stock_logs.created_at ASC")
+
+		return db
+	})
+	if err != nil {
+		s.Log.Errorf("Failed to get stock logs for export: %+v", err)
+		return nil, err
+	}
+
+	return stockLogs, nil
+}
+

internal/modules/inventory/stock-logs/validations/stock-log.validation.go

@@ -0,0 +1,7 @@
+package validation
+
+type Query struct {
+	Page                int    `query:"page" validate:"omitempty,number,min=1,gt=0"`
+	Limit               int    `query:"limit" validate:"omitempty,number,min=1,gt=0"`
+	ProductWarehouseID  uint   `query:"product_warehouse_id" validate:"required,gt=0"`
+}

internal/modules/marketing/controllers/deliveryorder.export.go

@@ -2,7 +2,6 @@ package controller
 
 import (
 	"fmt"
-	"math"
 	"strconv"
 	"strings"
 	"time"
@@ -76,9 +75,18 @@ func setMarketingExportColumns(file *excelize.File, sheet string) error {
 		"B": 14,
 		"C": 18,
 		"D": 20,
-		"E": 18,
+		"E": 14,
-		"F": 60,
+		"F": 40,
-		"G": 24,
+		"G": 10,
+		"H": 12,
+		"I": 12,
+		"J": 12,
+		"K": 16,
+		"L": 16,
+		"M": 18,
+		"N": 18,
+		"O": 18,
+		"P": 24,
 	}
 
 	for col, width := range columnWidths {
@@ -96,13 +104,22 @@ func setMarketingExportColumns(file *excelize.File, sheet string) error {
 
 func setMarketingExportHeaders(file *excelize.File, sheet string) error {
 	headers := []string{
-		"No. Order",
+		"No. Order",    // A
-		"Tanggal",
+		"Tanggal",      // B
-		"Status",
+		"Status",       // C
-		"Customer",
+		"Customer",     // D
-		"Grand Total",
+		"Tipe",         // E
-		"Products",
+		"Nama Produk",  // F
-		"Notes",
+		"Week",         // G
+		"Jumlah",       // H
+		"Satuan",       // I
+		"Qty Peti",     // J
+		"Berat Rata-rata (kg)", // K
+		"Total Berat (kg)",     // L
+		"Harga Satuan", // M
+		"Total Harga",  // N
+		"Grand Total",  // O
+		"Catatan",      // P
 	}
 
 	for i, header := range headers {
@@ -131,7 +148,7 @@ func setMarketingExportHeaders(file *excelize.File, sheet string) error {
 		return err
 	}
 
-	return file.SetCellStyle(sheet, "A1", "G1", headerStyle)
+	return file.SetCellStyle(sheet, "A1", "P1", headerStyle)
 }
 
 func setMarketingExportRows(file *excelize.File, sheet string, items []dto.MarketingListDTO) error {
@@ -139,70 +156,154 @@ func setMarketingExportRows(file *excelize.File, sheet string, items []dto.Marke
 		return nil
 	}
 
-	for i, item := range items {
+	row := 1
-		rowNumber := i + 2
+	for _, item := range items {
-		if err := file.SetCellValue(sheet, "A"+strconv.Itoa(rowNumber), safeMarketingExportText(item.SoNumber)); err != nil {
+		soNumber := safeMarketingExportText(item.SoNumber)
+		soDate := formatMarketingExportDate(item.SoDate)
+		status := formatMarketingExportStatus(item)
+		customer := safeMarketingExportText(item.Customer.Name)
+		grandTotal := sumMarketingGrandTotal(item.SalesOrder)
+		notes := safeMarketingExportText(item.Notes)
+
+		if len(item.SalesOrder) == 0 {
+			row++
+			r := strconv.Itoa(row)
+			vals := map[string]interface{}{
+				"A": soNumber, "B": soDate, "C": status, "D": customer,
+				"E": "-", "F": "-", "G": "-", "H": "-", "I": "-", "J": "-",
+				"K": "-", "L": "-", "M": "-", "N": "-",
+				"O": grandTotal, "P": notes,
+			}
+			for col, val := range vals {
+				if err := file.SetCellValue(sheet, col+r, val); err != nil {
 					return err
 				}
-		if err := file.SetCellValue(sheet, "B"+strconv.Itoa(rowNumber), formatMarketingExportDate(item.SoDate)); err != nil {
-			return err
 			}
-		if err := file.SetCellValue(sheet, "C"+strconv.Itoa(rowNumber), formatMarketingExportStatus(item)); err != nil {
+			continue
-			return err
 		}
-		if err := file.SetCellValue(sheet, "D"+strconv.Itoa(rowNumber), safeMarketingExportText(item.Customer.Name)); err != nil {
+
-			return err
+		for _, prod := range item.SalesOrder {
-		}
+			row++
-		if err := file.SetCellValue(sheet, "E"+strconv.Itoa(rowNumber), formatMarketingRupiah(sumMarketingGrandTotal(item.SalesOrder))); err != nil {
+			r := strconv.Itoa(row)
-			return err
+
-		}
+			productName := "-"
-		if err := file.SetCellValue(sheet, "F"+strconv.Itoa(rowNumber), formatMarketingProducts(item.SalesOrder)); err != nil {
+			if prod.ProductWarehouse != nil && prod.ProductWarehouse.Product != nil {
-			return err
+				if n := strings.TrimSpace(prod.ProductWarehouse.Product.Name); n != "" {
-		}
+					productName = n
-		if err := file.SetCellValue(sheet, "G"+strconv.Itoa(rowNumber), safeMarketingExportText(item.Notes)); err != nil {
-			return err
 				}
 			}
 
-	lastRow := len(items) + 1
+			week := "-"
+			if prod.Week != nil {
+				week = strconv.Itoa(*prod.Week)
+			}
+
+			satuan := "-"
+			if prod.ConvertionUnit != nil && strings.TrimSpace(*prod.ConvertionUnit) != "" {
+				satuan = *prod.ConvertionUnit
+			}
+
+			if err := file.SetCellValue(sheet, "A"+r, soNumber); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "B"+r, soDate); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "C"+r, status); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "D"+r, customer); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "E"+r, safeMarketingExportText(prod.MarketingType)); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "F"+r, productName); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "G"+r, week); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "H"+r, prod.Qty); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "I"+r, satuan); err != nil {
+				return err
+			}
+			if prod.TotalPeti != nil {
+				if err := file.SetCellValue(sheet, "J"+r, *prod.TotalPeti); err != nil {
+					return err
+				}
+			} else {
+				if err := file.SetCellValue(sheet, "J"+r, "-"); err != nil {
+					return err
+				}
+			}
+			if err := file.SetCellValue(sheet, "K"+r, prod.AvgWeight); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "L"+r, prod.TotalWeight); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "M"+r, prod.UnitPrice); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "N"+r, prod.TotalPrice); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "O"+r, grandTotal); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "P"+r, notes); err != nil {
+				return err
+			}
+		}
+	}
+
+	lastRow := row
+	lastRowStr := strconv.Itoa(lastRow)
+	border := []excelize.Border{
+		{Type: "left", Color: "D1D5DB", Style: 1},
+		{Type: "top", Color: "D1D5DB", Style: 1},
+		{Type: "bottom", Color: "D1D5DB", Style: 1},
+		{Type: "right", Color: "D1D5DB", Style: 1},
+	}
+
 	dataStyle, err := file.NewStyle(&excelize.Style{
-		Alignment: &excelize.Alignment{
+		Alignment: &excelize.Alignment{Horizontal: "left", Vertical: "center", WrapText: true},
-			Horizontal: "left",
+		Border:    border,
-			Vertical:   "center",
-			WrapText:   true,
-		},
-		Border: []excelize.Border{
-			{Type: "left", Color: "D1D5DB", Style: 1},
-			{Type: "top", Color: "D1D5DB", Style: 1},
-			{Type: "bottom", Color: "D1D5DB", Style: 1},
-			{Type: "right", Color: "D1D5DB", Style: 1},
-		},
 	})
 	if err != nil {
 		return err
 	}
-
+	if err := file.SetCellStyle(sheet, "A2", "P"+lastRowStr, dataStyle); err != nil {
-	if err := file.SetCellStyle(sheet, "A2", "G"+strconv.Itoa(lastRow), dataStyle); err != nil {
 		return err
 	}
 
-	moneyStyle, err := file.NewStyle(&excelize.Style{
+	numberStyle, err := file.NewStyle(&excelize.Style{
-		Alignment: &excelize.Alignment{
+		Alignment: &excelize.Alignment{Horizontal: "right", Vertical: "center"},
-			Horizontal: "right",
+		Border:    border,
-			Vertical:   "center",
-		},
-		Border: []excelize.Border{
-			{Type: "left", Color: "D1D5DB", Style: 1},
-			{Type: "top", Color: "D1D5DB", Style: 1},
-			{Type: "bottom", Color: "D1D5DB", Style: 1},
-			{Type: "right", Color: "D1D5DB", Style: 1},
-		},
 	})
 	if err != nil {
 		return err
 	}
+	if err := file.SetCellStyle(sheet, "K2", "O"+lastRowStr, numberStyle); err != nil {
+		return err
+	}
 
-	return file.SetCellStyle(sheet, "E2", "E"+strconv.Itoa(lastRow), moneyStyle)
+	centerStyle, err := file.NewStyle(&excelize.Style{
+		Alignment: &excelize.Alignment{Horizontal: "center", Vertical: "center"},
+		Border:    border,
+	})
+	if err != nil {
+		return err
+	}
+	for _, col := range []string{"G", "H", "J"} {
+		if err := file.SetCellStyle(sheet, col+"2", col+lastRowStr, centerStyle); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
 func formatMarketingExportDate(value time.Time) string {
@@ -226,36 +327,6 @@ func formatMarketingExportStatus(item dto.MarketingListDTO) string {
 	return safeMarketingExportText(item.LatestApproval.StepName)
 }
 
-func formatMarketingProducts(items []dto.DeliveryMarketingProductDTO) string {
-	if len(items) == 0 {
-		return "-"
-	}
-
-	seen := make(map[string]struct{})
-	names := make([]string, 0, len(items))
-	for _, item := range items {
-		if item.ProductWarehouse == nil || item.ProductWarehouse.Product == nil {
-			continue
-		}
-
-		name := strings.TrimSpace(item.ProductWarehouse.Product.Name)
-		if name == "" {
-			continue
-		}
-
-		if _, exists := seen[name]; exists {
-			continue
-		}
-		seen[name] = struct{}{}
-		names = append(names, name)
-	}
-
-	if len(names) == 0 {
-		return "-"
-	}
-
-	return strings.Join(names, ", ")
-}
 
 func sumMarketingGrandTotal(items []dto.DeliveryMarketingProductDTO) float64 {
 	total := 0.0
@@ -266,40 +337,6 @@ func sumMarketingGrandTotal(items []dto.DeliveryMarketingProductDTO) float64 {
 	return total
 }
 
-func formatMarketingRupiah(value float64) string {
-	if math.IsNaN(value) || math.IsInf(value, 0) {
-		return "Rp 0"
-	}
-
-	rounded := int64(math.Round(value))
-	sign := ""
-	if rounded < 0 {
-		sign = "-"
-		rounded = -rounded
-	}
-
-	raw := strconv.FormatInt(rounded, 10)
-	if raw == "" {
-		raw = "0"
-	}
-
-	var grouped strings.Builder
-	rem := len(raw) % 3
-	if rem > 0 {
-		grouped.WriteString(raw[:rem])
-		if len(raw) > rem {
-			grouped.WriteString(".")
-		}
-	}
-	for i := rem; i < len(raw); i += 3 {
-		grouped.WriteString(raw[i : i+3])
-		if i+3 < len(raw) {
-			grouped.WriteString(".")
-		}
-	}
-
-	return "Rp " + sign + grouped.String()
-}
 
 func safeMarketingExportText(value string) string {
 	trimmed := strings.TrimSpace(value)

internal/modules/marketing/dto/deliveryorder.dto.go

@@ -29,6 +29,7 @@ type MarketingListDTO struct {
 	SalesPerson    userDTO.UserRelationDTO         `json:"sales_person"`
 	SoDocs         string                          `json:"so_docs"`
 	SalesOrder     []DeliveryMarketingProductDTO   `json:"sales_order"`
+	DeliveryOrder  []DeliveryGroupDTO              `json:"delivery_order"`
 	CreatedUser    userDTO.UserRelationDTO         `json:"created_user"`
 	CreatedAt      time.Time                       `json:"created_at"`
 	UpdatedAt      time.Time                       `json:"updated_at"`
@@ -203,6 +204,7 @@ func ToMarketingListDTO(marketing *entity.Marketing, deliveryProducts []entity.M
 		SalesPerson:          salesPerson,
 		SoDocs:               marketing.SoDocs,
 		SalesOrder:           salesOrderProducts,
+		DeliveryOrder:        extractDeliveryGroupsFromProducts(marketing),
 		CreatedUser:          createdUser,
 		CreatedAt:            marketing.CreatedAt,
 		UpdatedAt:            marketing.UpdatedAt,
@@ -376,6 +378,23 @@ func GenerateDeliveryOrderNumber(soNumber string, deliveryDate *time.Time, wareh
 	return numberPrefix
 }
 
+func extractDeliveryGroupsFromProducts(marketing *entity.Marketing) []DeliveryGroupDTO {
+	var dps []MarketingDeliveryProductDTO
+	for _, product := range marketing.Products {
+		if product.DeliveryProduct == nil || product.DeliveryProduct.DeliveryDate == nil {
+			continue
+		}
+		dp := ToMarketingDeliveryProductDTO(*product.DeliveryProduct)
+		if product.ProductWarehouse.Id != 0 {
+			mapped := productwarehouseDTO.ToProductWarehouseNestedDTO(product.ProductWarehouse)
+			dp.ProductWarehouse = &mapped
+		}
+		dp.ConvertionUnit = product.ConvertionUnit
+		dps = append(dps, dp)
+	}
+	return groupDeliveryProducts(dps, marketing.SoNumber)
+}
+
 func collectDoNumbers(marketing *entity.Marketing) []string {
 	if marketing == nil || len(marketing.Products) == 0 {
 		return nil

internal/modules/marketing/services/deliveryorder.service.go

@@ -310,6 +310,8 @@ func (s deliveryOrdersService) GetAll(c *fiber.Ctx, params *validation.DeliveryO
 			return db.Joins("LEFT JOIN customers ON customers.id = marketings.customer_id").Order("COALESCE(customers.name, '') " + orderDir)
 		case "grand_total":
 			return db.Order("(SELECT COALESCE(SUM(mp.total_price), 0) FROM marketing_products mp WHERE mp.marketing_id = marketings.id) " + orderDir)
+		case "created_at":
+			return db.Order("marketings.created_at " + orderDir)
 		default:
 			return db.Order("created_at DESC").Order("updated_at DESC")
 		}
@@ -540,9 +542,15 @@ func (s deliveryOrdersService) UpdateOne(c *fiber.Ctx, req *validation.DeliveryO
 		return nil, err
 	}
 
+	latestApproval, err := s.ApprovalSvc.LatestByTarget(c.Context(), utils.ApprovalWorkflowMarketing, id, nil)
+	if err != nil {
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to check approval status")
+	}
+
 	err = s.MarketingRepo.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
 		marketingProductRepositoryTx := marketingRepo.NewMarketingProductRepository(dbTransaction)
 		marketingDeliveryProductRepositoryTx := marketingRepo.NewMarketingDeliveryProductRepository(dbTransaction)
+		approvalSvcTx := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(dbTransaction))
 		marketingRepoTx := marketingRepo.NewMarketingRepository(dbTransaction)
 
 		marketing, err := marketingRepoTx.GetByID(c.Context(), id, nil)
@@ -628,6 +636,23 @@ func (s deliveryOrdersService) UpdateOne(c *fiber.Ctx, req *validation.DeliveryO
 			}
 		}
 
+		if latestApproval != nil && latestApproval.StepNumber == uint16(utils.MarketingDeliveryOrder) {
+			action := entity.ApprovalActionUpdated
+			_, err := approvalSvcTx.CreateApproval(
+				c.Context(),
+				utils.ApprovalWorkflowMarketing,
+				id,
+				utils.MarketingStepSalesOrder,
+				&action,
+				actorID,
+				nil)
+			if err != nil {
+				if !errors.Is(err, gorm.ErrDuplicatedKey) {
+					return fiber.NewError(fiber.StatusInternalServerError, "Failed to reset approval to Sales Order")
+				}
+			}
+		}
+
 		return nil
 	})
 	if err != nil {

internal/modules/marketing/services/salesorder.service.go

@@ -516,7 +516,7 @@ func (s salesOrdersService) UpdateOne(c *fiber.Ctx, req *validation.Update, id u
 				c.Context(),
 				utils.ApprovalWorkflowMarketing,
 				id,
-				approvalutils.ApprovalStep(latestApproval.StepNumber),
+				utils.MarketingStepPengajuan,
 				&action,
 				actorID,
 				nil)
@@ -770,7 +770,12 @@ func (s salesOrdersService) Approval(c *fiber.Ctx, req *validation.Approve) ([]e
 
 func (s *salesOrdersService) createMarketingProductWithDelivery(ctx context.Context, marketingId uint, marketingType string, rp validation.CreateMarketingProduct, marketingProductRepo repository.MarketingProductRepository, invDeliveryRepo repository.MarketingDeliveryProductRepository) error {
 
-	totalWeight, totalPrice := s.calculatePriceByMarketingType(
+	var totalWeight, totalPrice float64
+	if rp.TotalPrice != nil {
+		totalWeight = math.Round(rp.Qty*rp.AvgWeight*100) / 100
+		totalPrice = *rp.TotalPrice
+	} else {
+		totalWeight, totalPrice = s.calculatePriceByMarketingType(
 			marketingType,
 			rp.Qty,
 			rp.AvgWeight,
@@ -779,6 +784,7 @@ func (s *salesOrdersService) createMarketingProductWithDelivery(ctx context.Cont
 			rp.ConvertionUnit,
 			rp.WeightPerConvertion,
 		)
+	}
 
 	marketingProduct := &entity.MarketingProduct{
 		MarketingId:         marketingId,
@@ -821,7 +827,7 @@ func (s *salesOrdersService) calculatePriceByMarketingType(marketingType string,
 		totalPrice = math.Round(qty*unitPrice*100) / 100
 	} else if marketingType == string(utils.MarketingTypeAyamPullet) && week != nil && *week > 0 {
 		totalWeight = math.Round(qty*avgWeight*100) / 100
-		totalPrice = math.Round(unitPrice*float64(*week)*qty*100) / 100
+		totalPrice = math.Round(totalWeight*unitPrice*100) / 100
 	} else {
 		totalWeight = math.Round(qty*avgWeight*100) / 100
 

internal/modules/marketing/validations/deliveryorder.validation.go

@@ -31,7 +31,7 @@ type DeliveryOrderQuery struct {
 	MarketingId           uint   `query:"marketing_id" validate:"omitempty,gt=0"`
 	ProjectFlockID        uint   `query:"project_flock_id" validate:"omitempty,gt=0"`
 	ProjectFlockKandangID uint   `query:"project_flock_kandang_id" validate:"omitempty,gt=0"`
-	SortBy                string `query:"sort_by" validate:"omitempty,oneof=so_number so_date status customer grand_total"`
+	SortBy                string `query:"sort_by" validate:"omitempty,oneof=so_number so_date status customer grand_total created_at"`
 	SortOrder             string `query:"sort_order" validate:"omitempty,oneof=asc desc"`
 }
 

internal/modules/marketing/validations/salesorder.validation.go

@@ -26,6 +26,7 @@ type CreateMarketingProduct struct {
 	UnitPrice           float64  `json:"unit_price" validate:"required,gt=0"`
 	Qty                 float64  `json:"qty" validate:"required,gt=0"`
 	AvgWeight           float64  `json:"avg_weight" validate:"omitempty,gt=0"`
+	TotalPrice          *float64 `json:"total_price" validate:"omitempty,gt=0"`
 }
 
 type Update struct {

internal/modules/master/customers/dto/customer.dto.go

@@ -14,6 +14,7 @@ type CustomerRelationDTO struct {
 	Name          string                   `json:"name"`
 	Type          string                   `json:"type"`
 	AccountNumber string                   `json:"account_number"`
+	BankName      string                   `json:"bank_name"`
 	Address       string                   `json:"address,omitempty"`
 	Balance       float64                  `json:"balance"`
 	Pic           *userDTO.UserRelationDTO `json:"pic,omitempty"`
@@ -28,6 +29,7 @@ type CustomerListDTO struct {
 	Phone         string                  `json:"phone"`
 	Email         string                  `json:"email"`
 	AccountNumber string                  `json:"account_number"`
+	BankName      string                  `json:"bank_name"`
 	Balance       float64                 `json:"balance"`
 	Pic           userDTO.UserRelationDTO `json:"pic"`
 	CreatedUser   userDTO.UserRelationDTO `json:"created_user"`
@@ -53,6 +55,7 @@ func ToCustomerRelationDTO(e entity.Customer) CustomerRelationDTO {
 		Name:          e.Name,
 		Type:          e.Type,
 		AccountNumber: e.AccountNumber,
+		BankName:      e.BankName,
 		Address:       e.Address,
 		Balance:       e.Balance,
 		Pic:           pic,
@@ -81,6 +84,7 @@ func ToCustomerListDTO(e entity.Customer) CustomerListDTO {
 		Phone:         e.Phone,
 		Email:         e.Email,
 		AccountNumber: e.AccountNumber,
+		BankName:      e.BankName,
 		Pic:           pic,
 		CreatedAt:     e.CreatedAt,
 		UpdatedAt:     e.UpdatedAt,

internal/modules/master/customers/services/customer.service.go

@@ -133,6 +133,7 @@ func (s *customerService) CreateOne(c *fiber.Ctx, req *validation.Create) (*enti
 		Phone:         req.Phone,
 		Email:         req.Email,
 		AccountNumber: req.AccountNumber,
+		BankName:      req.BankName,
 		CreatedBy:     actorID,
 	}
 
@@ -193,6 +194,10 @@ func (s customerService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint
 		updateBody["account_number"] = *req.AccountNumber
 	}
 
+	if req.BankName != nil {
+		updateBody["bank_name"] = *req.BankName
+	}
+
 	if len(updateBody) == 0 {
 		return s.GetOne(c, id)
 	}

internal/modules/master/customers/validations/customer.validation.go

@@ -8,6 +8,7 @@ type Create struct {
 	Phone         string `json:"phone" validate:"required_strict,max=20"`
 	Email         string `json:"email" validate:"required_strict,email,max=50"`
 	AccountNumber string `json:"account_number" validate:"required_strict,max=50"`
+	BankName      string `json:"bank_name" validate:"required_strict,max=100"`
 }
 
 type Update struct {
@@ -18,6 +19,7 @@ type Update struct {
 	Phone         *string `json:"phone,omitempty" validate:"omitempty,max=20"`
 	Email         *string `json:"email,omitempty" validate:"omitempty,max=50"`
 	AccountNumber *string `json:"account_number,omitempty" validate:"omitempty,max=50"`
+	BankName      *string `json:"bank_name,omitempty" validate:"omitempty,max=100"`
 }
 
 type Query struct {

internal/modules/master/suppliers/dto/supplier.dto.go

@@ -26,6 +26,7 @@ type SupplierListDTO struct {
 	Address       string                   `json:"address"`
 	Npwp          *string                  `json:"npwp,omitempty"`
 	AccountNumber *string                  `json:"account_number,omitempty"`
+	BankName      *string                  `json:"bank_name,omitempty"`
 	Balance       float64                  `json:"balance"`
 	DueDate       int                      `json:"due_date"`
 	CreatedUser   *userDTO.UserRelationDTO `json:"created_user"`
@@ -66,6 +67,7 @@ func ToSupplierListDTO(e entity.Supplier) SupplierListDTO {
 		Address:             e.Address,
 		Npwp:                e.Npwp,
 		AccountNumber:       e.AccountNumber,
+		BankName:            e.BankName,
 		Balance:             e.Balance,
 		DueDate:             e.DueDate,
 		SupplierRelationDTO: ToSupplierRelationDTO(e),

internal/modules/master/suppliers/services/supplier.service.go

@@ -160,6 +160,7 @@ func (s *supplierService) CreateOne(c *fiber.Ctx, req *validation.Create) (*enti
 		Address:       req.Address,
 		Npwp:          req.Npwp,
 		AccountNumber: req.AccountNumber,
+		BankName:      req.BankName,
 		DueDate:       req.DueDate,
 		CreatedBy:     actorID,
 	}
@@ -243,6 +244,10 @@ func (s supplierService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint
 		updateBody["account_number"] = *req.AccountNumber
 	}
 
+	if req.BankName != nil {
+		updateBody["bank_name"] = *req.BankName
+	}
+
 	if req.DueDate != nil {
 		updateBody["due_date"] = *req.DueDate
 	}

internal/modules/master/suppliers/validations/supplier.validation.go

@@ -12,6 +12,7 @@ type Create struct {
 	Address       string  `json:"address" validate:"required_strict"`
 	Npwp          *string `json:"npwp,omitempty" validate:"omitempty,max=50"`
 	AccountNumber *string `json:"account_number,omitempty" validate:"omitempty,max=50"`
+	BankName      *string `json:"bank_name,omitempty" validate:"omitempty,max=100"`
 	DueDate       int     `json:"due_date" validate:"required_strict,number,gt=0"`
 }
 
@@ -27,6 +28,7 @@ type Update struct {
 	Address       *string `json:"address,omitempty" validate:"omitempty"`
 	Npwp          *string `json:"npwp,omitempty" validate:"omitempty,max=50"`
 	AccountNumber *string `json:"account_number,omitempty" validate:"omitempty,max=50"`
+	BankName      *string `json:"bank_name,omitempty" validate:"omitempty,max=100"`
 	DueDate       *int    `json:"due_date,omitempty" validate:"omitempty,number,gt=0"`
 }
 

internal/modules/production/project_flocks/controllers/projectflock.controller.go

@@ -312,10 +312,10 @@ func (u *ProjectflockController) LookupProjectFlockKandang(c *fiber.Ctx) error {
 		mapped := warehouseDTO.ToWarehouseRelationDTO(*warehouse)
 		dtoResult.Warehouse = &mapped
 	}
-	if _, isLaying, serr := u.ProjectflockService.GetProjectFlockKandangTransferStateAtDate(c, result.Id, recordDate); serr != nil {
+	if isTransition, isLaying, serr := u.ProjectflockService.GetProjectFlockKandangTransferStateAtDate(c, result.Id, recordDate); serr != nil {
 		return serr
 	} else {
-		dtoResult.IsTransition = false
+		dtoResult.IsTransition = isTransition
 		dtoResult.IsLaying = isLaying
 	}
 	applyCutOverLayingLookupOverride(&dtoResult)
@@ -346,7 +346,7 @@ func (u *ProjectflockController) LookupProjectFlockKandang(c *fiber.Ctx) error {
 }
 
 func applyCutOverLayingLookupOverride(result *dto.ProjectFlockKandangDTO) {
-	if result == nil || result.ProjectFlock == nil || result.IsLaying || result.ChickInDate == nil {
+	if result == nil || result.ProjectFlock == nil || result.IsLaying || result.IsTransition || result.ChickInDate == nil {
 		return
 	}
 

internal/modules/production/project_flocks/services/projectflock.service.go

@@ -588,11 +588,6 @@ func (s projectflockService) GetProjectFlockKandangTransferStateAtDate(ctx *fibe
 	switch category {
 	case strings.ToUpper(string(utils.ProjectFlockCategoryGrowing)):
 		transfer, err = s.TransferLayingRepo.GetLatestApprovedBySourceKandang(ctx.Context(), projectFlockKandangID)
-	case strings.ToUpper(string(utils.ProjectFlockCategoryLaying)):
-		transfer, err = s.TransferLayingRepo.GetLatestApprovedByTargetKandang(ctx.Context(), projectFlockKandangID)
-	default:
-		return false, false, nil
-	}
 		if err != nil {
 			if errors.Is(err, gorm.ErrRecordNotFound) {
 				return false, false, nil
@@ -600,6 +595,23 @@ func (s projectflockService) GetProjectFlockKandangTransferStateAtDate(ctx *fibe
 			s.Log.Errorf("Failed to resolve transfer state for project flock kandang %d: %+v", projectFlockKandangID, err)
 			return false, false, fiber.NewError(fiber.StatusInternalServerError, "Failed to resolve transfer state")
 		}
+	case strings.ToUpper(string(utils.ProjectFlockCategoryLaying)):
+		// Multi-source: target kandang bisa menerima dari multiple transfer terpisah. Pakai
+		// EARLIEST transfer (transfer_date ASC) sebagai anchor — kandang masuk transition/laying
+		// mengikuti batch pertama yang sampai.
+		allTransfers, allErr := s.TransferLayingRepo.GetAllApprovedByTargetKandang(ctx.Context(), projectFlockKandangID)
+		if allErr != nil {
+			s.Log.Errorf("Failed to resolve transfers for project flock kandang %d: %+v", projectFlockKandangID, allErr)
+			return false, false, fiber.NewError(fiber.StatusInternalServerError, "Failed to resolve transfer state")
+		}
+		if len(allTransfers) == 0 {
+			return false, false, nil
+		}
+		// Repository ORDER BY transfer_date ASC, id ASC → [0] = earliest
+		transfer = &allTransfers[0]
+	default:
+		return false, false, nil
+	}
 	if transfer == nil {
 		return false, false, nil
 	}

internal/modules/production/recordings/controllers/recording.export.go

@@ -79,8 +79,6 @@ func setRecordingExportColumns(file *excelize.File, sheet string) error {
 		"AB": 18,
 		"AC": 24,
 		"AD": 18,
-		"AE": 18,
-		"AF": 18,
 	}
 
 	for col, width := range columnWidths {
@@ -100,7 +98,7 @@ func setRecordingExportColumns(file *excelize.File, sheet string) error {
 }
 
 func setRecordingExportHeaders(file *excelize.File, sheet string) error {
-	verticalHeaderCols := []string{"A", "B", "C", "D", "E", "F", "G", "H", "I", "Y", "Z", "AA", "AB", "AC", "AD", "AE", "AF"}
+	verticalHeaderCols := []string{"A", "B", "C", "D", "E", "F", "G", "H", "I", "Y", "Z", "AA", "AB", "AC", "AD"}
 	for _, col := range verticalHeaderCols {
 		if err := file.MergeCell(sheet, col+"1", col+"2"); err != nil {
 			return err
@@ -121,10 +119,8 @@ func setRecordingExportHeaders(file *excelize.File, sheet string) error {
 		"Z1":   "Catatan Approval",
 		"AA1":  "Dibuat Oleh",
 		"AB1":  "Tanggal Submit",
-		"AC1":  "Nama Pakan",
+		"AC1":  "Nama Sapronak",
-		"AD1":  "Jumlah Input Pakan",
+		"AD1":  "Jumlah Input Sapronak",
-		"AE1":  "Jumlah Penggunaan",
-		"AF1":  "Pending Qty",
 	}
 	for cell, value := range headerValues {
 		if err := file.SetCellValue(sheet, cell, value); err != nil {
@@ -238,7 +234,7 @@ func setRecordingExportHeaders(file *excelize.File, sheet string) error {
 		return err
 	}
 
-	return file.SetCellStyle(sheet, "A1", "AF2", headerStyle)
+	return file.SetCellStyle(sheet, "A1", "AD2", headerStyle)
 }
 
 func setRecordingExportRows(file *excelize.File, sheet string, items []dto.RecordingListDTO) error {
@@ -249,12 +245,14 @@ func setRecordingExportRows(file *excelize.File, sheet string, items []dto.Recor
 	columns := []string{
 		"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N",
 		"O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "AA", "AB",
-		"AC", "AD", "AE", "AF",
+		"AC", "AD",
 	}
 
-	for i, item := range items {
+	currentRow := 3
-		rowNumber := i + 3
+	type rowRange struct{ start, end int }
+	itemRanges := make([]rowRange, 0, len(items))
 
+	for i, item := range items {
 		fcrStd := 0.0
 		if item.ProjectFlock.Fcr != nil {
 			fcrStd = item.ProjectFlock.Fcr.FcrStd
@@ -292,73 +290,79 @@ func setRecordingExportRows(file *excelize.File, sheet string, items []dto.Recor
 			createdBy = safeExportText(item.Approval.ActionBy.Name)
 		}
 
-		// Build feed usage columns — concatenate multiple feeds with newline
+		// Expand recordings into one row per sapronak
-		feedNames := make([]string, 0, len(item.FeedUsage))
+		type sapronakRow struct {
-		usageAmounts := make([]string, 0, len(item.FeedUsage))
+			name  string
-		pendingQtys := make([]string, 0, len(item.FeedUsage))
+			input string
-		inputQtys := make([]string, 0, len(item.FeedUsage))
+		}
+		sapronaks := make([]sapronakRow, 0)
+		if len(item.FeedUsage) > 0 {
 			for _, fu := range item.FeedUsage {
-			feedNames = append(feedNames, safeExportText(fu.ProductName))
+				sapronaks = append(sapronaks, sapronakRow{
-			usageAmounts = append(usageAmounts, formatNumberID(fu.UsageAmount, 2, true))
+					name:  safeExportText(fu.ProductName),
-			pendingQtys = append(pendingQtys, formatNumberID(fu.PendingQty, 2, true))
+					input: formatNumberID(fu.UsageAmount+fu.PendingQty, 2, true),
-			inputQtys = append(inputQtys, formatNumberID(fu.UsageAmount+fu.PendingQty, 2, true))
+				})
+			}
+		} else {
+			sapronaks = append(sapronaks, sapronakRow{name: "-", input: "-"})
 		}
 
-		feedNameCol := "-"
+		groupStart := currentRow
-		usageCol := "-"
-		pendingCol := "-"
-		inputCol := "-"
-		if len(feedNames) > 0 {
-			feedNameCol = strings.Join(feedNames, "\n")
-			usageCol = strings.Join(usageAmounts, "\n")
-			pendingCol = strings.Join(pendingQtys, "\n")
-			inputCol = strings.Join(inputQtys, "\n")
-		}
 
+		for sIdx, s := range sapronaks {
+			if sIdx == 0 {
 				rowValues := []interface{}{
-			i + 1,
+					i + 1,                                          // A
-			locationName,
+					locationName,                                   // B
-			safeExportText(item.ProjectFlock.FlockName),
+					safeExportText(item.ProjectFlock.FlockName),    // C
-			kandangName,
+					kandangName,                                    // D
-			item.ProjectFlock.Period,
+					item.ProjectFlock.Period,                        // E
-			formatCategoryLabel(item.ProjectFlock.ProjectFlockCategory),
+					formatCategoryLabel(item.ProjectFlock.ProjectFlockCategory), // F
-			formatAgeLabel(item),
+					formatAgeLabel(item),                             // G
-			formatDateIndonesian(item.RecordDatetime),
+					formatDateIndonesian(item.RecordDatetime),        // H
-			formatNumberID(item.ProjectFlock.TotalChickQty, 0, false),
+					formatNumberID(item.ProjectFlock.TotalChickQty, 0, false), // I
-			formatNumberID(item.FcrValue, 2, true),
+					formatNumberID(item.FcrValue, 2, true),          // J
-			formatNumberID(fcrStd, 2, true),
+					formatNumberID(fcrStd, 2, true),                 // K
-			formatNumberID(item.FeedIntake, 2, true),
+					formatNumberID(item.FeedIntake, 2, true),         // L
-			formatNumberID(feedIntakeStd, 2, true),
+					formatNumberID(feedIntakeStd, 2, true),           // M
-			formatPercentID(item.CumDepletionRate, 2),
+					formatPercentID(item.CumDepletionRate, 2),        // N
-			formatPercentID(maxDepletionStd, 2),
+					formatPercentID(maxDepletionStd, 2),              // O
-			formatNumberID(item.TotalDepletionQty, 2, true),
+					formatNumberID(item.TotalDepletionQty, 2, true),  // P
-			formatNumberID(item.EggMass, 2, true),
+					formatNumberID(item.EggMass, 2, true),            // Q
-			formatNumberID(eggMassStd, 2, true),
+					formatNumberID(eggMassStd, 2, true),              // R
-			formatNumberID(item.EggWeight, 2, true),
+					formatNumberID(item.EggWeight, 2, true),          // S
-			formatNumberID(eggWeightStd, 2, true),
+					formatNumberID(eggWeightStd, 2, true),            // T
-			formatPercentID(item.HenDay, 2),
+					formatPercentID(item.HenDay, 2),                  // U
-			formatPercentID(henDayStd, 2),
+					formatPercentID(henDayStd, 2),                    // V
-			formatPercentID(item.HenHouse, 2),
+					formatPercentID(item.HenHouse, 2),                // W
-			formatPercentID(henHouseStd, 2),
+					formatPercentID(henHouseStd, 2),                  // X
-			formatApprovalStatus(item),
+					formatApprovalStatus(item),                       // Y
-			safeExportText(pointerString(item.Approval.Notes)),
+					safeExportText(pointerString(item.Approval.Notes)), // Z
-			createdBy,
+					createdBy,                                        // AA
-			formatDateIndonesian(item.CreatedAt),
+					formatDateIndonesian(item.CreatedAt),             // AB
-			feedNameCol,  // AC
+					s.name,                                           // AC
-			inputCol,     // AD - Jumlah Input Pakan
+					s.input,                                          // AD
-			usageCol,     // AE - Jumlah Penggunaan
-			pendingCol,   // AF - Pending Qty
 				}
 
 				for idx, col := range columns {
-			cell := fmt.Sprintf("%s%d", col, rowNumber)
+					cell := fmt.Sprintf("%s%d", col, currentRow)
 					if err := file.SetCellValue(sheet, cell, rowValues[idx]); err != nil {
 						return err
 					}
 				}
+			} else {
+				file.SetCellValue(sheet, fmt.Sprintf("AC%d", currentRow), s.name)
+				file.SetCellValue(sheet, fmt.Sprintf("AD%d", currentRow), s.input)
 			}
 
-	lastRow := len(items) + 2
+			currentRow++
+		}
+
+		itemRanges = append(itemRanges, rowRange{groupStart, currentRow - 1})
+	}
+
+	lastRow := currentRow - 1
+
 	dataCenterStyle, err := file.NewStyle(&excelize.Style{
 		Alignment: &excelize.Alignment{
 			Horizontal: "center",
@@ -375,7 +379,7 @@ func setRecordingExportRows(file *excelize.File, sheet string, items []dto.Recor
 	if err != nil {
 		return err
 	}
-	if err := file.SetCellStyle(sheet, "A3", fmt.Sprintf("AF%d", lastRow), dataCenterStyle); err != nil {
+	if err := file.SetCellStyle(sheet, "A3", fmt.Sprintf("AD%d", lastRow), dataCenterStyle); err != nil {
 		return err
 	}
 
@@ -403,6 +407,55 @@ func setRecordingExportRows(file *excelize.File, sheet string, items []dto.Recor
 		}
 	}
 
+	// Apply bottom border on the last sapronak row of each recording group
+	// Separate styles to preserve alignment (AC=left, AD=center) and thin borders
+	borderBottomLeftStyle, err := file.NewStyle(&excelize.Style{
+		Alignment: &excelize.Alignment{
+			Horizontal: "left",
+			Vertical:   "center",
+			WrapText:   true,
+		},
+		Border: []excelize.Border{
+			{Type: "left", Color: "E6E6E6", Style: 1},
+			{Type: "top", Color: "E6E6E6", Style: 1},
+			{Type: "bottom", Color: "999999", Style: 2},
+			{Type: "right", Color: "E6E6E6", Style: 1},
+		},
+	})
+	if err != nil {
+		return err
+	}
+
+	borderBottomCenterStyle, err := file.NewStyle(&excelize.Style{
+		Alignment: &excelize.Alignment{
+			Horizontal: "center",
+			Vertical:   "center",
+			WrapText:   true,
+		},
+		Border: []excelize.Border{
+			{Type: "left", Color: "E6E6E6", Style: 1},
+			{Type: "top", Color: "E6E6E6", Style: 1},
+			{Type: "bottom", Color: "999999", Style: 2},
+			{Type: "right", Color: "E6E6E6", Style: 1},
+		},
+	})
+	if err != nil {
+		return err
+	}
+
+	mergeCols := []string{"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N",
+		"O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "AA", "AB",
+	}
+	for _, rng := range itemRanges {
+		if rng.end > rng.start {
+			for _, col := range mergeCols {
+				file.MergeCell(sheet, fmt.Sprintf("%s%d", col, rng.start), fmt.Sprintf("%s%d", col, rng.end))
+			}
+		}
+		file.SetCellStyle(sheet, fmt.Sprintf("AC%d", rng.end), fmt.Sprintf("AC%d", rng.end), borderBottomLeftStyle)
+		file.SetCellStyle(sheet, fmt.Sprintf("AD%d", rng.end), fmt.Sprintf("AD%d", rng.end), borderBottomCenterStyle)
+	}
+
 	return nil
 }
 

internal/modules/production/recordings/dto/recording.dto.go

@@ -74,6 +74,8 @@ type RecordingRelationDTO struct {
 	ProjectFlock         RecordingProjectFlockDTO        `json:"project_flock"`
 	RecordDatetime       time.Time                       `json:"record_datetime"`
 	Day                  int                             `json:"day"`
+	Week                 int                             `json:"week"`
+	ExcessDays           int                             `json:"excess_days"`
 	TotalDepletionQty    float64                         `json:"total_depletion_qty"`
 	TotalDepletionCumQty float64                         `json:"total_depletion_cum_qty"`
 	CumDepletionRate     float64                         `json:"cum_depletion_rate"`
@@ -270,11 +272,15 @@ func toRecordingRelationDTO(e entity.Recording) RecordingRelationDTO {
 		latestApproval = snapshot
 	}
 
+	day := intValue(e.Day)
+
 	return RecordingRelationDTO{
 		Id:                   e.Id,
 		ProjectFlock:         toRecordingProjectFlockDTO(e),
 		RecordDatetime:       e.RecordDatetime,
-		Day:                  intValue(e.Day),
+		Day:                  day,
+		Week:                 day / 7,
+		ExcessDays:           day % 7,
 		TotalDepletionQty:    floatValue(e.TotalDepletionQty),
 		TotalDepletionCumQty: floatValue(e.TotalDepletionCumQty),
 		CumDepletionRate:     roundFloatValue(e.CumDepletionRate, 2),
@@ -314,9 +320,13 @@ func toRecordingProjectFlockDTO(e entity.Recording) RecordingProjectFlockDTO {
 	result.Period = pfk.Period
 
 	if pfk.ProjectFlock.ProductionStandard.Id != 0 {
+		week := recordingWeekValue(e)
+		if e.StandardWeek != nil && *e.StandardWeek > 0 {
+			week = *e.StandardWeek
+		}
 		result.ProductionStandart = &RecordingProductionStandardDTO{
 			Id:              pfk.ProjectFlock.ProductionStandard.Id,
-			Week:            recordingWeekValue(e),
+			Week:            week,
 			Name:            pfk.ProjectFlock.ProductionStandard.Name,
 			HenDayStd:       floatValue(e.StandardHenDay),
 			HenHouseStd:     floatValue(e.StandardHenHouse),

internal/modules/production/recordings/services/recording.service.go

@@ -198,10 +198,22 @@ func (s recordingService) GetAll(c *fiber.Ctx, params *validation.Query) ([]enti
 	if err != nil {
 		return nil, 0, err
 	}
-	targetTransferByPFK, err := s.TransferLayingRepo.GetLatestApprovedByTargetKandangs(c.Context(), layingPFKIDs)
+	// Multi-source support: 1 target kandang bisa menerima dari multiple transfer terpisah.
+	// Untuk state evaluation (IsTransition/IsLaying), kita pakai EARLIEST transfer sebagai anchor
+	// (sesuai dengan rule "kandang masuk fase laying mengikuti batch pertama yang sampai").
+	allTransfersByTarget, err := s.TransferLayingRepo.GetAllApprovedByTargetKandangs(c.Context(), layingPFKIDs)
 	if err != nil {
 		return nil, 0, err
 	}
+	targetTransferByPFK := make(map[uint]*entity.LayingTransfer, len(allTransfersByTarget))
+	for pfkID, list := range allTransfersByTarget {
+		if len(list) == 0 {
+			continue
+		}
+		// list sudah ORDER BY transfer_date ASC, id ASC → element [0] adalah earliest
+		earliest := list[0]
+		targetTransferByPFK[pfkID] = &earliest
+	}
 	hasTargetRecordingCache := make(map[uint]bool)
 
 	cutOverChickinAvailability := make(map[uint]bool)
@@ -1292,11 +1304,6 @@ func (s *recordingService) evaluatePopulationMutationState(ctx context.Context,
 	switch category {
 	case strings.ToUpper(string(utils.ProjectFlockCategoryGrowing)):
 		transfer, err = s.TransferLayingRepo.GetLatestApprovedBySourceKandang(ctx, recording.ProjectFlockKandangId)
-	case strings.ToUpper(string(utils.ProjectFlockCategoryLaying)):
-		transfer, err = s.TransferLayingRepo.GetLatestApprovedByTargetKandang(ctx, recording.ProjectFlockKandangId)
-	default:
-		return true, false, false, false, nil, time.Time{}, nil
-	}
 		if err != nil {
 			if errors.Is(err, gorm.ErrRecordNotFound) {
 				return true, false, false, false, nil, time.Time{}, nil
@@ -1304,6 +1311,23 @@ func (s *recordingService) evaluatePopulationMutationState(ctx context.Context,
 			s.Log.Errorf("Failed to resolve approved transfer for recording %d: %+v", recording.Id, err)
 			return true, false, false, false, nil, time.Time{}, fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi perubahan populasi recording")
 		}
+	case strings.ToUpper(string(utils.ProjectFlockCategoryLaying)):
+		// Multi-source: target kandang bisa menerima dari multiple transfer terpisah.
+		// Pakai EARLIEST transfer (transfer_date ASC) sebagai anchor untuk state evaluation —
+		// kandang dianggap masuk transition/laying berdasarkan batch pertama yang masuk.
+		allTransfers, allErr := s.TransferLayingRepo.GetAllApprovedByTargetKandang(ctx, recording.ProjectFlockKandangId)
+		if allErr != nil {
+			s.Log.Errorf("Failed to resolve approved transfers for recording %d: %+v", recording.Id, allErr)
+			return true, false, false, false, nil, time.Time{}, fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi perubahan populasi recording")
+		}
+		if len(allTransfers) == 0 {
+			return true, false, false, false, nil, time.Time{}, nil
+		}
+		// Repository sudah ORDER BY transfer_date ASC, id ASC → element [0] adalah earliest.
+		transfer = &allTransfers[0]
+	default:
+		return true, false, false, false, nil, time.Time{}, nil
+	}
 	if transfer == nil {
 		return true, false, false, false, nil, time.Time{}, nil
 	}
@@ -2434,21 +2458,24 @@ func (s *recordingService) computeRecordingDay(ctx context.Context, projectFlock
 		return 0, fiber.NewError(fiber.StatusBadRequest, "Project flock kandang tidak valid")
 	}
 
-	populations, err := s.ProjectFlockPopulationRepo.GetByProjectFlockKandangID(ctx, projectFlockKandangID)
+	// If this PFK is a laying transfer target, use source growing PFK's chick_in_date
-	if err != nil {
+	sourcePFKIDs := s.getLayingTransferSourcePFKIDs(ctx, projectFlockKandangID)
-		s.Log.Errorf("Failed to fetch populations for project_flock_kandang_id=%d: %+v", projectFlockKandangID, err)
-		return 0, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil data populasi")
-	}
 
 	var chickinDate time.Time
-	for _, pop := range populations {
+	if len(sourcePFKIDs) > 0 {
-		if pop.ProjectChickin == nil || pop.ProjectChickin.ChickInDate.IsZero() {
+		for _, pfkID := range sourcePFKIDs {
-			continue
+			cd := s.getEarliestChickInDate(ctx, pfkID)
-		}
+			if !cd.IsZero() && (chickinDate.IsZero() || cd.Before(chickinDate)) {
-		if chickinDate.IsZero() || pop.ProjectChickin.ChickInDate.Before(chickinDate) {
+				chickinDate = cd
-			chickinDate = pop.ProjectChickin.ChickInDate
 			}
 		}
+	}
+
+	// Fallback: use current PFK's own chick_in_date (cut-over or non-laying)
+	if chickinDate.IsZero() {
+		chickinDate = s.getEarliestChickInDate(ctx, projectFlockKandangID)
+	}
+
 	if chickinDate.IsZero() {
 		return 0, fiber.NewError(fiber.StatusBadRequest, "Tanggal chick in tidak ditemukan")
 	}
@@ -2463,6 +2490,55 @@ func (s *recordingService) computeRecordingDay(ctx context.Context, projectFlock
 	return diff, nil
 }
 
+func (s *recordingService) getLayingTransferSourcePFKIDs(ctx context.Context, targetPFKID uint) []uint {
+	transfer, err := s.TransferLayingRepo.GetLatestApprovedByTargetKandang(ctx, targetPFKID)
+	if err != nil {
+		if !errors.Is(err, gorm.ErrRecordNotFound) {
+			s.Log.Errorf("Failed to check laying transfer for pfk=%d: %+v", targetPFKID, err)
+		}
+		return nil
+	}
+	if transfer == nil {
+		return nil
+	}
+
+	ids := make([]uint, 0)
+	if transfer.SourceProjectFlockKandangId != nil {
+		ids = append(ids, *transfer.SourceProjectFlockKandangId)
+	}
+
+	// Check multi-source transfers
+	var sources []entity.LayingTransferSource
+	if err := s.Repository.DB().WithContext(ctx).
+		Where("laying_transfer_id = ?", transfer.Id).
+		Find(&sources).Error; err == nil {
+		for _, src := range sources {
+			ids = append(ids, src.SourceProjectFlockKandangId)
+		}
+	}
+
+	return ids
+}
+
+func (s *recordingService) getEarliestChickInDate(ctx context.Context, pfkID uint) time.Time {
+	populations, err := s.ProjectFlockPopulationRepo.GetByProjectFlockKandangID(ctx, pfkID)
+	if err != nil {
+		s.Log.Errorf("Failed to fetch populations for pfk=%d: %+v", pfkID, err)
+		return time.Time{}
+	}
+
+	var chickinDate time.Time
+	for _, pop := range populations {
+		if pop.ProjectChickin == nil || pop.ProjectChickin.ChickInDate.IsZero() {
+			continue
+		}
+		if chickinDate.IsZero() || pop.ProjectChickin.ChickInDate.Before(chickinDate) {
+			chickinDate = pop.ProjectChickin.ChickInDate
+		}
+	}
+	return chickinDate
+}
+
 func (s *recordingService) computeAndUpdateMetrics(ctx context.Context, tx *gorm.DB, recording *entity.Recording) error {
 	day := 0
 	if recording.Day != nil {

internal/modules/production/transfer_layings/repositories/laying_transfer.repository.go

@@ -19,6 +19,11 @@ type TransferLayingRepository interface {
 	GetLatestApprovedByTargetKandang(ctx context.Context, targetProjectFlockKandangID uint) (*entity.LayingTransfer, error)
 	GetLatestApprovedBySourceKandangs(ctx context.Context, pfkIDs []uint) (map[uint]*entity.LayingTransfer, error)
 	GetLatestApprovedByTargetKandangs(ctx context.Context, pfkIDs []uint) (map[uint]*entity.LayingTransfer, error)
+	// GetAllApprovedByTargetKandang return semua approved transfer yang menuju ke target kandang itu.
+	// Dipakai untuk multi-source case di mana 1 target kandang bisa menerima dari multiple transfer
+	// terpisah (tiap transfer = 1 source). Order: transfer_date ASC, id ASC (kronologis).
+	GetAllApprovedByTargetKandang(ctx context.Context, targetProjectFlockKandangID uint) ([]entity.LayingTransfer, error)
+	GetAllApprovedByTargetKandangs(ctx context.Context, pfkIDs []uint) (map[uint][]entity.LayingTransfer, error)
 
 	// Tambah method baru untuk query dengan filter lengkap
 	GetAllWithFilters(ctx context.Context, offset int, limit int, params *GetAllFilterParams) ([]entity.LayingTransfer, int64, error)
@@ -362,3 +367,89 @@ func (r *TransferLayingRepositoryImpl) GetLatestApprovedByTargetKandangs(ctx con
 	}
 	return result, nil
 }
+
+// GetAllApprovedByTargetKandang return SEMUA approved transfer ke target kandang itu (bukan hanya yang
+// terbaru). Dipakai untuk skenario multi-source di mana 1 target kandang menerima dari multiple transfer
+// terpisah, sehingga depresiasi/HPP/recording state perlu aggregate dari semua transfer.
+func (r *TransferLayingRepositoryImpl) GetAllApprovedByTargetKandang(ctx context.Context, targetProjectFlockKandangID uint) ([]entity.LayingTransfer, error) {
+	if targetProjectFlockKandangID == 0 {
+		return nil, nil
+	}
+
+	var transfers []entity.LayingTransfer
+	err := r.db.WithContext(ctx).
+		Model(&entity.LayingTransfer{}).
+		Joins("JOIN laying_transfer_targets ltt ON ltt.laying_transfer_id = laying_transfers.id AND ltt.deleted_at IS NULL").
+		Where("ltt.target_project_flock_kandang_id = ?", targetProjectFlockKandangID).
+		Where("laying_transfers.deleted_at IS NULL").
+		Where(`(
+			SELECT a.action
+			FROM approvals a
+			WHERE a.approvable_type = ?
+			  AND a.approvable_id = laying_transfers.id
+			ORDER BY a.id DESC
+			LIMIT 1
+		) = ?`, string(utils.ApprovalWorkflowTransferToLaying), entity.ApprovalActionApproved).
+		Order("laying_transfers.transfer_date ASC, laying_transfers.id ASC").
+		Distinct("laying_transfers.*").
+		Find(&transfers).Error
+	if err != nil {
+		return nil, err
+	}
+	return transfers, nil
+}
+
+// GetAllApprovedByTargetKandangs batch version: return map dari target_pfk_id ke list of approved transfers.
+// Order per target: transfer_date ASC, id ASC.
+func (r *TransferLayingRepositoryImpl) GetAllApprovedByTargetKandangs(ctx context.Context, pfkIDs []uint) (map[uint][]entity.LayingTransfer, error) {
+	result := make(map[uint][]entity.LayingTransfer)
+	if len(pfkIDs) == 0 {
+		return result, nil
+	}
+
+	type targetTransferRow struct {
+		TargetPFKID uint `gorm:"column:target_pfk_id"`
+		TransferID  uint `gorm:"column:transfer_id"`
+	}
+
+	var rows []targetTransferRow
+	err := r.db.WithContext(ctx).Raw(`
+		SELECT ltt.target_project_flock_kandang_id AS target_pfk_id, ltt.laying_transfer_id AS transfer_id
+		FROM laying_transfer_targets ltt
+		JOIN laying_transfers t ON t.id = ltt.laying_transfer_id AND t.deleted_at IS NULL
+		WHERE ltt.target_project_flock_kandang_id IN ?
+		  AND ltt.deleted_at IS NULL
+		  AND (
+		      SELECT a.action FROM approvals a
+		      WHERE a.approvable_type = ? AND a.approvable_id = t.id
+		      ORDER BY a.id DESC LIMIT 1
+		  ) = ?
+		ORDER BY t.transfer_date ASC, t.id ASC
+	`,
+		pfkIDs, string(utils.ApprovalWorkflowTransferToLaying), string(entity.ApprovalActionApproved),
+	).Scan(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+	if len(rows) == 0 {
+		return result, nil
+	}
+
+	transferIDs := make([]uint, 0, len(rows))
+	targetsByTransfer := make(map[uint][]uint, len(rows))
+	for _, row := range rows {
+		transferIDs = append(transferIDs, row.TransferID)
+		targetsByTransfer[row.TransferID] = append(targetsByTransfer[row.TransferID], row.TargetPFKID)
+	}
+
+	var transfers []entity.LayingTransfer
+	if err := r.db.WithContext(ctx).Where("id IN ? AND deleted_at IS NULL", transferIDs).Order("transfer_date ASC, id ASC").Find(&transfers).Error; err != nil {
+		return nil, err
+	}
+	for i := range transfers {
+		for _, targetID := range targetsByTransfer[transfers[i].Id] {
+			result[targetID] = append(result[targetID], transfers[i])
+		}
+	}
+	return result, nil
+}

internal/modules/production/transfer_layings/services/transfer_laying.service.go

@@ -1617,6 +1617,13 @@ func (s *transferLayingService) validateKandangOwnership(
 	return nil
 }
 
+// validateTargetSourceLineage memvalidasi bahwa source kandang yang sama TIDAK boleh ditransfer 2x ke
+// target kandang yang sama (anti-duplicate pair). Aturan lama "satu target hanya boleh punya satu
+// source" sudah dihapus — sekarang 1 target boleh menerima dari multiple source kandang via transfer
+// terpisah (multi-source via N-call approach).
+//
+// Yang ditolak: kalau ada approved transfer lain (id != excludeTransferID) yang punya pair
+// (source = sourceProjectFlockKandangID, target ∈ targetKandangIDs) yang sama.
 func (s *transferLayingService) validateTargetSourceLineage(
 	ctx context.Context,
 	sourceProjectFlockKandangID uint,
@@ -1637,7 +1644,7 @@ func (s *transferLayingService) validateTargetSourceLineage(
 		}
 		seen[targetKandangID] = struct{}{}
 
-		existingTransfer, err := s.Repository.GetLatestApprovedByTargetKandang(ctx, targetKandangID)
+		existingTransfers, err := s.Repository.GetAllApprovedByTargetKandang(ctx, targetKandangID)
 		if err != nil {
 			if errors.Is(err, gorm.ErrRecordNotFound) {
 				continue
@@ -1645,17 +1652,21 @@ func (s *transferLayingService) validateTargetSourceLineage(
 			s.Log.Errorf("Failed to validate transfer lineage for target kandang %d: %+v", targetKandangID, err)
 			return fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi relasi sumber transfer ke laying")
 		}
-		if existingTransfer == nil {
+
-			continue
+		for i := range existingTransfers {
-		}
+			existingTransfer := &existingTransfers[i]
 			if excludeTransferID != 0 && existingTransfer.Id == excludeTransferID {
 				continue
 			}
 
+			// Source di header (single source of truth per migration 20260307130342).
 			existingSourceID := uint(0)
 			if existingTransfer.SourceProjectFlockKandangId != nil && *existingTransfer.SourceProjectFlockKandangId != 0 {
 				existingSourceID = *existingTransfer.SourceProjectFlockKandangId
 			}
+
+			// Fallback ke laying_transfer_sources untuk transfer yang belum punya source di header
+			// (historis pre-migration 20260307130342).
 			if existingSourceID == 0 && s.LayingTransferSourceRepo != nil {
 				sources, sourceErr := s.LayingTransferSourceRepo.GetByLayingTransferId(ctx, existingTransfer.Id)
 				if sourceErr != nil {
@@ -1663,30 +1674,28 @@ func (s *transferLayingService) validateTargetSourceLineage(
 					return fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi relasi sumber transfer ke laying")
 				}
 				for _, source := range sources {
-				if source.SourceProjectFlockKandangId != 0 {
+					if source.SourceProjectFlockKandangId == sourceProjectFlockKandangID {
 						existingSourceID = source.SourceProjectFlockKandangId
 						break
 					}
 				}
 			}
-		if existingSourceID == 0 {
+
-			continue
+			if existingSourceID != sourceProjectFlockKandangID {
-		}
-		if existingSourceID == sourceProjectFlockKandangID {
 				continue
 			}
 
 			return fiber.NewError(
 				fiber.StatusBadRequest,
 				fmt.Sprintf(
-				"Kandang tujuan %d sudah memiliki lineage sumber kandang %d dari transfer %s. Tidak boleh ganti ke sumber kandang %d.",
+					"Source kandang %d sudah pernah ditransfer ke target kandang %d via transfer %s. Tidak boleh duplikat (source, target) pair yang sama.",
-				targetKandangID,
-				existingSourceID,
-				existingTransfer.TransferNumber,
 					sourceProjectFlockKandangID,
+					targetKandangID,
+					existingTransfer.TransferNumber,
 				),
 			)
 		}
+	}
 
 	return nil
 }

internal/modules/purchases/controllers/purchase.controller.go

@@ -91,17 +91,17 @@ func buildPurchaseQuery(c *fiber.Ctx) *validation.Query {
 		Limit:                 c.QueryInt("limit", 10),
 		Search:                strings.TrimSpace(c.Query("search")),
 		ApprovalStatus:        strings.TrimSpace(c.Query("approval_status")),
-		PoDate:                strings.TrimSpace(c.Query("po_date")),
+		StartDate:             strings.TrimSpace(c.Query("start_date")),
-		PoDateFrom:            strings.TrimSpace(c.Query("po_date_from")),
+		EndDate:               strings.TrimSpace(c.Query("end_date")),
-		PoDateTo:              strings.TrimSpace(c.Query("po_date_to")),
+		FilterBy:              strings.TrimSpace(c.Query("filter_by")),
-		CreatedFrom:           strings.TrimSpace(c.Query("created_from")),
-		CreatedTo:             strings.TrimSpace(c.Query("created_to")),
 		SupplierID:            uint(c.QueryInt("supplier_id", 0)),
 		AreaID:                uint(c.QueryInt("area_id", 0)),
 		LocationID:            uint(c.QueryInt("location_id", 0)),
 		ProjectFlockID:        uint(c.QueryInt("project_flock_id", 0)),
 		ProjectFlockKandangID: uint(c.QueryInt("project_flock_kandang_id", 0)),
 		ProductCategoryID:     strings.TrimSpace(c.Query("product_category_id")),
+		SortBy:                strings.TrimSpace(c.Query("sort_by", "")),
+		SortOrder:             strings.TrimSpace(c.Query("sort_order", "")),
 	}
 }
 

internal/modules/purchases/controllers/purchase.export.go

@@ -2,7 +2,6 @@ package controller
 
 import (
 	"fmt"
-	"math"
 	"strconv"
 	"strings"
 	"time"
@@ -43,15 +42,13 @@ func buildPurchaseExportWorkbook(purchases []entity.Purchase) ([]byte, error) {
 		}
 	}
 
-	grandTotals := buildPurchaseGrandTotalMap(purchases)
-
 	if err := setPurchaseExportColumns(file, purchaseExportSheetName); err != nil {
 		return nil, err
 	}
 	if err := setPurchaseExportHeaders(file, purchaseExportSheetName); err != nil {
 		return nil, err
 	}
-	if err := setPurchaseExportRows(file, purchaseExportSheetName, purchases, grandTotals); err != nil {
+	if err := setPurchaseExportRows(file, purchaseExportSheetName, purchases); err != nil {
 		return nil, err
 	}
 	if err := file.SetPanes(purchaseExportSheetName, &excelize.Panes{
@@ -80,9 +77,17 @@ func setPurchaseExportColumns(file *excelize.File, sheet string) error {
 		"F": 22,
 		"G": 22,
 		"H": 32,
-		"I": 18,
+		"I": 10,
-		"J": 18,
+		"J": 12,
-		"K": 24,
+		"K": 16,
+		"L": 16,
+		"M": 22,
+		"N": 12,
+		"O": 16,
+		"P": 16,
+		"Q": 18,
+		"R": 18,
+		"S": 24,
 	}
 
 	for col, width := range columnWidths {
@@ -99,17 +104,25 @@ func setPurchaseExportColumns(file *excelize.File, sheet string) error {
 
 func setPurchaseExportHeaders(file *excelize.File, sheet string) error {
 	headers := []string{
-		"PR Number",
+		"PR Number",       // A
-		"PO Number",
+		"PO Number",       // B
-		"Tanggal PO",
+		"Tanggal PO",      // C
-		"Tanggal Terima",
+		"Tanggal Terima",  // D
-		"Supplier",
+		"Supplier",        // E
-		"Lokasi",
+		"Lokasi",          // F
-		"Gudang",
+		"Gudang",          // G
-		"Product",
+		"Product",         // H
-		"Status",
+		"Qty",             // I
-		"Grand Total",
+		"Satuan",          // J
-		"Notes",
+		"Price",           // K
+		"Total Produk",    // L
+		"Vendor Ekspedisi",// M
+		"Qty Ekspedisi",   // N
+		"Price Ekspedisi", // O
+		"Total Ekspedisi", // P
+		"Grand Total All", // Q
+		"Status",          // R
+		"Notes",           // S
 	}
 
 	for i, header := range headers {
@@ -137,34 +150,36 @@ func setPurchaseExportHeaders(file *excelize.File, sheet string) error {
 		return err
 	}
 
-	return file.SetCellStyle(sheet, "A1", "K1", headerStyle)
+	return file.SetCellStyle(sheet, "A1", "S1", headerStyle)
 }
 
-func setPurchaseExportRows(file *excelize.File, sheet string, purchases []entity.Purchase, grandTotals map[uint]float64) error {
+func setPurchaseExportRows(file *excelize.File, sheet string, purchases []entity.Purchase) error {
 	if len(purchases) == 0 {
 		return nil
 	}
 
+	var sumL, sumP, sumQ float64
+
 	rowIdx := 2
 	for p := range purchases {
 		purchase := &purchases[p]
-		total := grandTotals[purchase.Id]
 		if len(purchase.Items) == 0 {
-			if err := writePurchaseExportRow(file, sheet, rowIdx, purchase, nil, total); err != nil {
+			if err := writePurchaseExportRow(file, sheet, rowIdx, purchase, nil, &sumL, &sumP, &sumQ); err != nil {
 				return err
 			}
 			rowIdx++
 			continue
 		}
 		for it := range purchase.Items {
-			if err := writePurchaseExportRow(file, sheet, rowIdx, purchase, &purchase.Items[it], total); err != nil {
+			if err := writePurchaseExportRow(file, sheet, rowIdx, purchase, &purchase.Items[it], &sumL, &sumP, &sumQ); err != nil {
 				return err
 			}
 			rowIdx++
 		}
 	}
 
-	lastRow := rowIdx - 1
+	lastDataRow := rowIdx - 1
+
 	dataStyle, err := file.NewStyle(&excelize.Style{
 		Alignment: &excelize.Alignment{
 			Horizontal: "left",
@@ -181,7 +196,7 @@ func setPurchaseExportRows(file *excelize.File, sheet string, purchases []entity
 	if err != nil {
 		return err
 	}
-	if err := file.SetCellStyle(sheet, "A2", "K"+strconv.Itoa(lastRow), dataStyle); err != nil {
+	if err := file.SetCellStyle(sheet, "A2", "S"+strconv.Itoa(lastDataRow), dataStyle); err != nil {
 		return err
 	}
 
@@ -200,14 +215,17 @@ func setPurchaseExportRows(file *excelize.File, sheet string, purchases []entity
 	if err != nil {
 		return err
 	}
-
+	if err := file.SetCellStyle(sheet, "K2", "Q"+strconv.Itoa(lastDataRow), moneyStyle); err != nil {
-	return file.SetCellStyle(sheet, "J2", "J"+strconv.Itoa(lastRow), moneyStyle)
+		return err
 	}
 
-func writePurchaseExportRow(file *excelize.File, sheet string, rowIdx int, purchase *entity.Purchase, item *entity.PurchaseItem, grandTotal float64) error {
+	return addPurchaseExportSumRow(file, sheet, rowIdx, sumL, sumP, sumQ)
+}
+
+func writePurchaseExportRow(file *excelize.File, sheet string, rowIdx int, purchase *entity.Purchase, item *entity.PurchaseItem, sumL, sumP, sumQ *float64) error {
 	row := strconv.Itoa(rowIdx)
 
-	// Purchase-level columns (repeat across rows of the same purchase)
+	// Purchase-level columns (repeat for every item row of the same purchase)
 	if err := file.SetCellValue(sheet, "A"+row, safePurchaseExportText(purchase.PrNumber)); err != nil {
 		return err
 	}
@@ -220,26 +238,40 @@ func writePurchaseExportRow(file *excelize.File, sheet string, rowIdx int, purch
 	if err := file.SetCellValue(sheet, "E"+row, safePurchaseExportEntitySupplierName(purchase)); err != nil {
 		return err
 	}
-	if err := file.SetCellValue(sheet, "I"+row, formatPurchaseExportEntityStatus(purchase)); err != nil {
+	if err := file.SetCellValue(sheet, "R"+row, formatPurchaseExportEntityStatus(purchase)); err != nil {
 		return err
 	}
-	if err := file.SetCellValue(sheet, "J"+row, formatPurchaseRupiah(grandTotal)); err != nil {
+	if err := file.SetCellValue(sheet, "S"+row, safePurchaseExportPointerText(purchase.Notes)); err != nil {
-		return err
-	}
-	if err := file.SetCellValue(sheet, "K"+row, safePurchaseExportPointerText(purchase.Notes)); err != nil {
 		return err
 	}
 
-	// Item-level columns
 	if item == nil {
-		for _, col := range []string{"D", "F", "G", "H"} {
+		for _, col := range []string{"D", "F", "G", "H", "J", "M"} {
 			if err := file.SetCellValue(sheet, col+row, "-"); err != nil {
 				return err
 			}
 		}
+		for _, col := range []string{"I", "K", "L", "N", "O", "P", "Q"} {
+			if err := file.SetCellValue(sheet, col+row, 0); err != nil {
+				return err
+			}
+		}
 		return nil
 	}
 
+	// Item-level columns
+	var expeditionQty, expeditionPrice, expeditionTotal float64
+	if item.ExpenseNonstock != nil {
+		expeditionQty = item.ExpenseNonstock.Qty
+		expeditionPrice = item.ExpenseNonstock.Price
+		expeditionTotal = expeditionQty * expeditionPrice
+	}
+	itemGrandTotal := item.TotalPrice + expeditionTotal
+
+	*sumL += item.TotalPrice
+	*sumP += expeditionTotal
+	*sumQ += itemGrandTotal
+
 	if err := file.SetCellValue(sheet, "D"+row, formatPurchaseExportDate(item.ReceivedDate)); err != nil {
 		return err
 	}
@@ -252,20 +284,96 @@ func writePurchaseExportRow(file *excelize.File, sheet string, rowIdx int, purch
 	if err := file.SetCellValue(sheet, "H"+row, safePurchaseItemProductName(item)); err != nil {
 		return err
 	}
+	if err := file.SetCellValue(sheet, "I"+row, item.TotalQty); err != nil {
+		return err
+	}
+	if err := file.SetCellValue(sheet, "J"+row, safePurchaseItemUomName(item)); err != nil {
+		return err
+	}
+	if err := file.SetCellValue(sheet, "K"+row, item.Price); err != nil {
+		return err
+	}
+	if err := file.SetCellValue(sheet, "L"+row, item.TotalPrice); err != nil {
+		return err
+	}
+	if err := file.SetCellValue(sheet, "M"+row, safePurchaseItemExpeditionVendorName(item)); err != nil {
+		return err
+	}
+	if err := file.SetCellValue(sheet, "N"+row, expeditionQty); err != nil {
+		return err
+	}
+	if err := file.SetCellValue(sheet, "O"+row, expeditionPrice); err != nil {
+		return err
+	}
+	if err := file.SetCellValue(sheet, "P"+row, expeditionTotal); err != nil {
+		return err
+	}
+	if err := file.SetCellValue(sheet, "Q"+row, itemGrandTotal); err != nil {
+		return err
+	}
 
 	return nil
 }
 
-func buildPurchaseGrandTotalMap(items []entity.Purchase) map[uint]float64 {
+func addPurchaseExportSumRow(file *excelize.File, sheet string, rowIdx int, sumL, sumP, sumQ float64) error {
-	result := make(map[uint]float64, len(items))
+	row := strconv.Itoa(rowIdx)
-	for i := range items {
+
-		total := 0.0
+	sumStyle, err := file.NewStyle(&excelize.Style{
-		for j := range items[i].Items {
+		Font: &excelize.Font{Bold: true, Color: "1F2937"},
-			total += items[i].Items[j].TotalPrice
+		Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"FEF3C7"}},
+		Alignment: &excelize.Alignment{
+			Horizontal: "left",
+			Vertical:   "center",
+		},
+		Border: []excelize.Border{
+			{Type: "left", Color: "D1D5DB", Style: 1},
+			{Type: "top", Color: "D1D5DB", Style: 2},
+			{Type: "bottom", Color: "D1D5DB", Style: 1},
+			{Type: "right", Color: "D1D5DB", Style: 1},
+		},
+	})
+	if err != nil {
+		return err
 	}
-		result[items[i].Id] = total
+
+	sumMoneyStyle, err := file.NewStyle(&excelize.Style{
+		Font: &excelize.Font{Bold: true, Color: "1F2937"},
+		Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"FEF3C7"}},
+		Alignment: &excelize.Alignment{
+			Horizontal: "right",
+			Vertical:   "center",
+		},
+		Border: []excelize.Border{
+			{Type: "left", Color: "D1D5DB", Style: 1},
+			{Type: "top", Color: "D1D5DB", Style: 2},
+			{Type: "bottom", Color: "D1D5DB", Style: 1},
+			{Type: "right", Color: "D1D5DB", Style: 1},
+		},
+	})
+	if err != nil {
+		return err
 	}
-	return result
+
+	if err := file.SetCellStyle(sheet, "A"+row, "S"+row, sumStyle); err != nil {
+		return err
+	}
+	if err := file.SetCellStyle(sheet, "L"+row, "L"+row, sumMoneyStyle); err != nil {
+		return err
+	}
+	if err := file.SetCellStyle(sheet, "P"+row, "Q"+row, sumMoneyStyle); err != nil {
+		return err
+	}
+
+	if err := file.SetCellValue(sheet, "A"+row, "TOTAL"); err != nil {
+		return err
+	}
+	if err := file.SetCellValue(sheet, "L"+row, sumL); err != nil {
+		return err
+	}
+	if err := file.SetCellValue(sheet, "P"+row, sumP); err != nil {
+		return err
+	}
+	return file.SetCellValue(sheet, "Q"+row, sumQ)
 }
 
 func safePurchaseExportEntitySupplierName(purchase *entity.Purchase) string {
@@ -296,6 +404,24 @@ func safePurchaseItemProductName(item *entity.PurchaseItem) string {
 	return safePurchaseExportText(item.Product.Name)
 }
 
+func safePurchaseItemUomName(item *entity.PurchaseItem) string {
+	if item.Product == nil || item.Product.Uom.Id == 0 {
+		return "-"
+	}
+	return safePurchaseExportText(item.Product.Uom.Name)
+}
+
+func safePurchaseItemExpeditionVendorName(item *entity.PurchaseItem) string {
+	if item.ExpenseNonstock == nil || item.ExpenseNonstock.Expense == nil {
+		return "-"
+	}
+	exp := item.ExpenseNonstock.Expense
+	if exp.Supplier == nil || exp.Supplier.Id == 0 {
+		return "-"
+	}
+	return safePurchaseExportText(exp.Supplier.Name)
+}
+
 func formatPurchaseExportEntityStatus(purchase *entity.Purchase) string {
 	if purchase.LatestApproval == nil {
 		return "-"
@@ -309,6 +435,21 @@ func formatPurchaseExportEntityStatus(purchase *entity.Purchase) string {
 	return safePurchaseExportText(purchase.LatestApproval.StepName)
 }
 
+var purchaseIndonesianMonths = map[time.Month]string{
+	time.January:   "Jan",
+	time.February:  "Feb",
+	time.March:     "Mar",
+	time.April:     "Apr",
+	time.May:       "Mei",
+	time.June:      "Jun",
+	time.July:      "Jul",
+	time.August:    "Ags",
+	time.September: "Sep",
+	time.October:   "Okt",
+	time.November:  "Nov",
+	time.December:  "Des",
+}
+
 func formatPurchaseExportDate(value *time.Time) string {
 	if value == nil || value.IsZero() {
 		return "-"
@@ -320,7 +461,8 @@ func formatPurchaseExportDate(value *time.Time) string {
 		t = t.In(location)
 	}
 
-	return t.Format("02-01-2006")
+	month := purchaseIndonesianMonths[t.Month()]
+	return fmt.Sprintf("%d-%s-%02d", t.Day(), month, t.Year()%100)
 }
 
 func safePurchaseExportPointerText(value *string) string {
@@ -338,37 +480,3 @@ func safePurchaseExportText(value string) string {
 	return trimmed
 }
 
-func formatPurchaseRupiah(value float64) string {
-	if math.IsNaN(value) || math.IsInf(value, 0) {
-		return "Rp 0"
-	}
-
-	rounded := int64(math.Round(value))
-	sign := ""
-	if rounded < 0 {
-		sign = "-"
-		rounded = -rounded
-	}
-
-	raw := strconv.FormatInt(rounded, 10)
-	if raw == "" {
-		raw = "0"
-	}
-
-	var grouped strings.Builder
-	rem := len(raw) % 3
-	if rem > 0 {
-		grouped.WriteString(raw[:rem])
-		if len(raw) > rem {
-			grouped.WriteString(".")
-		}
-	}
-	for i := rem; i < len(raw); i += 3 {
-		grouped.WriteString(raw[i : i+3])
-		if i+3 < len(raw) {
-			grouped.WriteString(".")
-		}
-	}
-
-	return "Rp " + sign + grouped.String()
-}

internal/modules/purchases/controllers/purchase.export_test.go

@@ -22,9 +22,8 @@ func TestBuildPurchaseExportWorkbookHeadersAndRows(t *testing.T) {
 			nil,
 			"catatan",
 			[]entity.PurchaseItem{
-				buildPurchaseItemForExportTest(11, "Pakan Starter", 1000000, "Location A"),
+				buildPurchaseItemForExportTest(11, "Pakan Starter", 500, 2, 1000000, "Location A", "kg"),
-				buildPurchaseItemForExportTest(12, "Vitamin A", 350000, "Location B"),
+				buildPurchaseItemForExportTest(12, "Vitamin A", 350, 1, 350000, "Location B", "botol"),
-				buildPurchaseItemForExportTest(11, "Pakan Starter", 0, ""),
 			},
 		),
 		buildPurchaseForExportTest(
@@ -37,7 +36,7 @@ func TestBuildPurchaseExportWorkbookHeadersAndRows(t *testing.T) {
 			ptrApprovalAction(entity.ApprovalActionRejected),
 			"",
 			[]entity.PurchaseItem{
-				buildPurchaseItemForExportTest(21, "Obat X", 75000, ""),
+				buildPurchaseItemForExportTest(21, "Obat X", 75000, 1, 75000, "", ""),
 			},
 		),
 	})
@@ -51,16 +50,27 @@ func TestBuildPurchaseExportWorkbookHeadersAndRows(t *testing.T) {
 	}
 	defer file.Close()
 
+	// Verify all 19 headers
 	expectedHeaders := map[string]string{
 		"A1": "PR Number",
 		"B1": "PO Number",
 		"C1": "Tanggal PO",
-		"D1": "Supplier",
+		"D1": "Tanggal Terima",
-		"E1": "Lokasi",
+		"E1": "Supplier",
-		"F1": "Status",
+		"F1": "Lokasi",
-		"G1": "Grand Total",
+		"G1": "Gudang",
-		"H1": "Products",
+		"H1": "Product",
-		"I1": "Notes",
+		"I1": "Qty",
+		"J1": "Satuan",
+		"K1": "Price",
+		"L1": "Total Produk",
+		"M1": "Vendor Ekspedisi",
+		"N1": "Qty Ekspedisi",
+		"O1": "Price Ekspedisi",
+		"P1": "Total Ekspedisi",
+		"Q1": "Grand Total All",
+		"R1": "Status",
+		"S1": "Notes",
 	}
 	for cell, expected := range expectedHeaders {
 		got, err := file.GetCellValue(purchaseExportSheetName, cell)
@@ -72,24 +82,46 @@ func TestBuildPurchaseExportWorkbookHeadersAndRows(t *testing.T) {
 		}
 	}
 
+	// Row 2: Purchase 1, Item 1 (Pakan Starter)
 	assertPurchaseCellEquals(t, file, "A2", "PR-00011")
 	assertPurchaseCellEquals(t, file, "B2", "PO-00011")
 	assertPurchaseCellEquals(t, file, "C2", "22-04-2026")
-	assertPurchaseCellEquals(t, file, "D2", "Supplier A")
+	assertPurchaseCellEquals(t, file, "E2", "Supplier A")
-	assertPurchaseCellEquals(t, file, "E2", "Location A")
+	assertPurchaseCellEquals(t, file, "F2", "Location A")
-	assertPurchaseCellEquals(t, file, "F2", "Manager Purchase")
+	assertPurchaseCellEquals(t, file, "H2", "Pakan Starter")
-	assertPurchaseCellEquals(t, file, "G2", "Rp 1.350.000")
+	assertPurchaseCellEquals(t, file, "J2", "kg")
-	assertPurchaseCellEquals(t, file, "H2", "Pakan Starter, Vitamin A")
+	assertPurchaseCellEquals(t, file, "K2", "500")
-	assertPurchaseCellEquals(t, file, "I2", "catatan")
+	assertPurchaseCellEquals(t, file, "L2", "1000000")
+	assertPurchaseCellEquals(t, file, "M2", "-")
+	assertPurchaseCellEquals(t, file, "P2", "0")
+	assertPurchaseCellEquals(t, file, "Q2", "1000000")
+	assertPurchaseCellEquals(t, file, "R2", "Manager Purchase")
+	assertPurchaseCellEquals(t, file, "S2", "catatan")
 
-	assertPurchaseCellEquals(t, file, "A3", "PR-00012")
+	// Row 3: Purchase 1, Item 2 (Vitamin A)
-	assertPurchaseCellEquals(t, file, "B3", "-")
+	assertPurchaseCellEquals(t, file, "A3", "PR-00011")
-	assertPurchaseCellEquals(t, file, "C3", "-")
+	assertPurchaseCellEquals(t, file, "H3", "Vitamin A")
-	assertPurchaseCellEquals(t, file, "E3", "-")
+	assertPurchaseCellEquals(t, file, "J3", "botol")
-	assertPurchaseCellEquals(t, file, "F3", "Ditolak")
+	assertPurchaseCellEquals(t, file, "L3", "350000")
-	assertPurchaseCellEquals(t, file, "G3", "Rp 75.000")
+	assertPurchaseCellEquals(t, file, "Q3", "350000")
-	assertPurchaseCellEquals(t, file, "H3", "Obat X")
+
-	assertPurchaseCellEquals(t, file, "I3", "-")
+	// Row 4: Purchase 2, Item 1 (Obat X) — no location, rejected
+	assertPurchaseCellEquals(t, file, "A4", "PR-00012")
+	assertPurchaseCellEquals(t, file, "B4", "-")
+	assertPurchaseCellEquals(t, file, "C4", "-")
+	assertPurchaseCellEquals(t, file, "F4", "-")
+	assertPurchaseCellEquals(t, file, "H4", "Obat X")
+	assertPurchaseCellEquals(t, file, "J4", "-")
+	assertPurchaseCellEquals(t, file, "L4", "75000")
+	assertPurchaseCellEquals(t, file, "Q4", "75000")
+	assertPurchaseCellEquals(t, file, "R4", "Ditolak")
+	assertPurchaseCellEquals(t, file, "S4", "-")
+
+	// Row 5: SUM row — total produk=1425000, ekspedisi=0, grand total all=1425000
+	assertPurchaseCellEquals(t, file, "A5", "TOTAL")
+	assertPurchaseCellEquals(t, file, "L5", "1425000")
+	assertPurchaseCellEquals(t, file, "P5", "0")
+	assertPurchaseCellEquals(t, file, "Q5", "1425000")
 }
 
 func assertPurchaseCellEquals(t *testing.T, file *excelize.File, cell, expected string) {
@@ -144,13 +176,20 @@ func buildPurchaseForExportTest(
 	}
 }
 
-func buildPurchaseItemForExportTest(productID uint, productName string, totalPrice float64, locationName string) entity.PurchaseItem {
+func buildPurchaseItemForExportTest(productID uint, productName string, price, totalQty, totalPrice float64, locationName, uomName string) entity.PurchaseItem {
+	uomID := uint(0)
+	if uomName != "" {
+		uomID = productID + 2000
+	}
 	item := entity.PurchaseItem{
 		ProductId:  productID,
+		Price:      price,
+		TotalQty:   totalQty,
 		TotalPrice: totalPrice,
 		Product: &entity.Product{
 			Id:   productID,
 			Name: productName,
+			Uom:  entity.Uom{Id: uomID, Name: uomName},
 		},
 	}
 

internal/modules/purchases/dto/purchase.dto.go

@@ -38,6 +38,9 @@ type PurchaseListDTO struct {
 	CreatedAt       time.Time                        `json:"created_at"`
 	UpdatedAt       time.Time                        `json:"updated_at"`
 	LatestApproval  *approvalDTO.ApprovalRelationDTO `json:"latest_approval"`
+	ProductsTotal   float64                          `json:"products_total"`
+	ExpeditionTotal float64                          `json:"expedition_total"`
+	GrandTotalAll   float64                          `json:"grand_total_all"`
 }
 
 type PurchaseDetailDTO struct {
@@ -69,6 +72,8 @@ type PurchaseItemDTO struct {
 	VehicleNumber      *string                            `json:"vehicle_number"`
 	TransportPerItem   *float64                           `json:"transport_per_item,omitempty"`
 	ExpeditionVendor   *supplierDTO.SupplierRelationDTO   `json:"expedition_vendor,omitempty"`
+	ExpeditionQty      float64                            `json:"expedition_qty"`
+	ExpeditionTotal    float64                            `json:"expedition_total"`
 	HasChickin         bool                               `json:"has_chickin"`
 }
 
@@ -127,6 +132,8 @@ func ToPurchaseItemDTO(item entity.PurchaseItem) PurchaseItemDTO {
 	if item.ExpenseNonstock != nil {
 		priceCopy := item.ExpenseNonstock.Price
 		dto.TransportPerItem = &priceCopy
+		dto.ExpeditionQty = item.ExpenseNonstock.Qty
+		dto.ExpeditionTotal = item.ExpenseNonstock.Qty * item.ExpenseNonstock.Price
 
 		if item.ExpenseNonstock.Expense != nil {
 			exp := item.ExpenseNonstock.Expense
@@ -177,11 +184,17 @@ func ToPurchaseListDTO(p entity.Purchase) PurchaseListDTO {
 		location        *locationDTO.LocationRelationDTO
 		area            *areaDTO.AreaRelationDTO
 		receivedDate    *time.Time
+		productsTotal   float64
+		expeditionTotal float64
 	)
 	productMap := make(map[uint]productDTO.ProductRelationDTO)
 	expeditionRefSet := make(map[uint64]struct{})
 	for i := range p.Items {
 		item := p.Items[i]
+		productsTotal += item.TotalPrice
+		if item.ExpenseNonstock != nil {
+			expeditionTotal += item.ExpenseNonstock.Qty * item.ExpenseNonstock.Price
+		}
 		if item.Product != nil && item.Product.Id != 0 {
 			if _, exists := productMap[item.Product.Id]; !exists {
 				productMap[item.Product.Id] = productDTO.ToProductRelationDTO(*item.Product)
@@ -235,6 +248,9 @@ func ToPurchaseListDTO(p entity.Purchase) PurchaseListDTO {
 		CreatedAt:           p.CreatedAt,
 		UpdatedAt:           p.UpdatedAt,
 		LatestApproval:      latestApproval,
+		ProductsTotal:       productsTotal,
+		ExpeditionTotal:     expeditionTotal,
+		GrandTotalAll:       productsTotal + expeditionTotal,
 	}
 }
 

internal/modules/purchases/services/purchase.service.go

@@ -145,33 +145,16 @@ func (s *purchaseService) GetAll(c *fiber.Ctx, params *validation.Query) ([]enti
 
 	offset := (params.Page - 1) * params.Limit
 
-	createdFrom, createdTo, err := utils.ParseDateRangeForQuery(params.CreatedFrom, params.CreatedTo)
-	if err != nil {
-		return nil, 0, utils.BadRequest(err.Error())
-	}
-
 	productCategoryIDs, err := parseUintCSVFilter(params.ProductCategoryID, "product_category_id")
 	if err != nil {
 		return nil, 0, utils.BadRequest(err.Error())
 	}
 
-	var poDateStart *time.Time
+	dateStart, dateEnd, err := parsePurchaseDateRangeForQuery(params.StartDate, params.EndDate, "date")
-	var poDateEnd *time.Time
-
-	if strings.TrimSpace(params.PoDate) != "" {
-		poDate, parseErr := utils.ParseDateString(strings.TrimSpace(params.PoDate))
-		if parseErr != nil {
-			return nil, 0, utils.BadRequest("po_date must use format YYYY-MM-DD")
-		}
-		poDateStart = &poDate
-		poDateEndValue := poDate.AddDate(0, 0, 1)
-		poDateEnd = &poDateEndValue
-	} else {
-		poDateStart, poDateEnd, err = parsePoDateRangeForQuery(params.PoDateFrom, params.PoDateTo)
 	if err != nil {
 		return nil, 0, utils.BadRequest(err.Error())
 	}
-	}
+	filterBy := strings.TrimSpace(params.FilterBy)
 
 	search := strings.ToLower(strings.TrimSpace(params.Search))
 	approvalStatuses := parseStringCSVFilter(params.ApprovalStatus)
@@ -187,23 +170,41 @@ func (s *purchaseService) GetAll(c *fiber.Ctx, params *validation.Query) ([]enti
 			db = db.Where("supplier_id = ?", params.SupplierID)
 		}
 
-		if createdFrom != nil {
+		switch filterBy {
-			db = db.Where("created_at >= ?", *createdFrom)
+		case "po_date":
+			if dateStart != nil {
+				db = db.Where("purchases.po_date >= ?", *dateStart)
 			}
-
+			if dateEnd != nil {
-		if createdTo != nil {
+				db = db.Where("purchases.po_date < ?", *dateEnd)
-			db = db.Where("created_at < ?", *createdTo)
 			}
-		if poDateStart != nil {
+		case "due_date":
-			db = db.Where("purchases.po_date >= ?", *poDateStart)
+			if dateStart != nil {
+				db = db.Where("purchases.due_date >= ?", *dateStart)
 			}
-
+			if dateEnd != nil {
-		if poDateStart != nil {
+				db = db.Where("purchases.due_date < ?", *dateEnd)
-			db = db.Where("purchases.po_date >= ?", *poDateStart)
+			}
+		case "received_date":
+			if dateStart != nil {
+				db = db.Where(
+					`EXISTS (SELECT 1 FROM purchase_items pi WHERE pi.purchase_id = purchases.id AND pi.received_date >= ?)`,
+					*dateStart,
+				)
+			}
+			if dateEnd != nil {
+				db = db.Where(
+					`EXISTS (SELECT 1 FROM purchase_items pi WHERE pi.purchase_id = purchases.id AND pi.received_date < ?)`,
+					*dateEnd,
+				)
+			}
+		default:
+			if dateStart != nil {
+				db = db.Where("purchases.created_at >= ?", *dateStart)
+			}
+			if dateEnd != nil {
+				db = db.Where("purchases.created_at < ?", *dateEnd)
 			}
-
-		if poDateEnd != nil {
-			db = db.Where("purchases.po_date < ?", *poDateEnd)
 		}
 
 		if scope.Restrict {
@@ -261,7 +262,56 @@ func (s *purchaseService) GetAll(c *fiber.Ctx, params *validation.Query) ([]enti
 		db = applyPurchaseApprovalStatusFilter(db, approvalStatuses)
 		db = applyPurchaseSearchFilter(db, search)
 
+		sortBy := strings.TrimSpace(params.SortBy)
+		sortOrder := strings.ToUpper(strings.TrimSpace(params.SortOrder))
+
+		if sortBy == "" && (filterBy == "po_date" || filterBy == "due_date" || filterBy == "received_date" || filterBy == "created_at") {
+			sortBy = filterBy
+			if sortOrder == "" {
+				sortOrder = "ASC"
+			}
+		}
+
+		if sortOrder == "" {
+			sortOrder = "DESC"
+		}
+
+		switch sortBy {
+		case "po_expedition":
+			return db.Order(`(SELECT MIN(e.reference_number) FROM purchase_items pi
+				 LEFT JOIN expense_nonstocks en ON en.id = pi.expense_nonstock_id
+				 LEFT JOIN expenses e ON e.id = en.expense_id
+				 WHERE pi.purchase_id = purchases.id) ` + sortOrder + " NULLS LAST")
+		case "supplier":
+			return db.Order(`(SELECT COALESCE(s.name, '') FROM suppliers s WHERE s.id = purchases.supplier_id) ` + sortOrder)
+		case "requester_name":
+			return db.Order(`(SELECT COALESCE(u.name, '') FROM users u WHERE u.id = purchases.created_by) ` + sortOrder)
+		case "products":
+			return db.Order(`(SELECT MIN(COALESCE(p.name, '')) FROM purchase_items pi
+				 JOIN products p ON p.id = pi.product_id
+				 WHERE pi.purchase_id = purchases.id) ` + sortOrder)
+		case "location":
+			return db.Order(`(SELECT MIN(COALESCE(l.name, '')) FROM purchase_items pi
+				 JOIN warehouses w ON w.id = pi.warehouse_id
+				 JOIN locations l ON l.id = w.location_id
+				 WHERE pi.purchase_id = purchases.id) ` + sortOrder)
+		case "po_date":
+			return db.Order("purchases.po_date " + sortOrder)
+		case "po_number":
+			return db.Order("COALESCE(purchases.po_number, purchases.pr_number) " + sortOrder)
+		case "received_date":
+			return db.Order(`(SELECT MIN(pi2.received_date) FROM purchase_items pi2 WHERE pi2.purchase_id = purchases.id) ` + sortOrder)
+		case "due_date":
+			return db.Order("purchases.due_date " + sortOrder)
+		case "status":
+			return db.Order(`(SELECT COALESCE(a.step_name, '') FROM approvals a
+				 WHERE a.approvable_type = 'PURCHASES' AND a.approvable_id = purchases.id
+				 ORDER BY a.action_at DESC, a.id DESC LIMIT 1) ` + sortOrder)
+		case "created_at":
+			return db.Order("purchases.created_at " + sortOrder)
+		default:
 			return db.Order("created_at DESC").Order("purchases.id DESC")
+		}
 	})
 
 	if err != nil {
@@ -2197,30 +2247,36 @@ func (s *purchaseService) attachLatestApprovals(ctx context.Context, items []ent
 	return nil
 }
 
-func parsePoDateRangeForQuery(fromStr, toStr string) (*time.Time, *time.Time, error) {
+func parsePurchaseDateRangeForQuery(fromStr, toStr, fieldName string) (*time.Time, *time.Time, error) {
+	jakartaLoc, err := time.LoadLocation("Asia/Jakarta")
+	if err != nil {
+		jakartaLoc = time.FixedZone("WIB", 7*60*60)
+	}
+
 	var fromPtr *time.Time
 	var toPtr *time.Time
 
 	if strings.TrimSpace(fromStr) != "" {
 		parsed, err := utils.ParseDateString(strings.TrimSpace(fromStr))
 		if err != nil {
-			return nil, nil, errors.New("po_date_from must use format YYYY-MM-DD")
+			return nil, nil, errors.New(fieldName + "_from must use format YYYY-MM-DD")
 		}
-		fromValue := parsed
+		t := time.Date(parsed.Year(), parsed.Month(), parsed.Day(), 0, 0, 0, 0, jakartaLoc)
-		fromPtr = &fromValue
+		fromPtr = &t
 	}
 
 	if strings.TrimSpace(toStr) != "" {
 		parsed, err := utils.ParseDateString(strings.TrimSpace(toStr))
 		if err != nil {
-			return nil, nil, errors.New("po_date_to must use format YYYY-MM-DD")
+			return nil, nil, errors.New(fieldName + "_to must use format YYYY-MM-DD")
 		}
-		nextDay := parsed.AddDate(0, 0, 1)
+		t := time.Date(parsed.Year(), parsed.Month(), parsed.Day(), 0, 0, 0, 0, jakartaLoc)
+		nextDay := t.AddDate(0, 0, 1)
 		toPtr = &nextDay
 	}
 
 	if fromPtr != nil && toPtr != nil && fromPtr.After(*toPtr) {
-		return nil, nil, errors.New("po_date_from must be earlier than po_date_to")
+		return nil, nil, errors.New(fieldName + "_from must be earlier than " + fieldName + "_to")
 	}
 
 	return fromPtr, toPtr, nil

internal/modules/purchases/validations/purchase.validation.go

@@ -75,10 +75,10 @@ type Query struct {
 	ProjectFlockKandangID uint   `query:"project_flock_kandang_id" validate:"omitempty,gt=0"`
 	ProductCategoryID     string `query:"product_category_id" validate:"omitempty,max=500"`
 	ApprovalStatus        string `query:"approval_status" validate:"omitempty,max=500"`
-	PoDate                string `query:"po_date" validate:"omitempty,datetime=2006-01-02"`
+	StartDate             string `query:"start_date" validate:"omitempty,datetime=2006-01-02"`
-	PoDateFrom            string `query:"po_date_from" validate:"omitempty,datetime=2006-01-02"`
+	EndDate               string `query:"end_date" validate:"omitempty,datetime=2006-01-02"`
-	PoDateTo              string `query:"po_date_to" validate:"omitempty,datetime=2006-01-02"`
+	FilterBy              string `query:"filter_by" validate:"omitempty,oneof=po_date due_date received_date created_at"`
 	Search                string `query:"search" validate:"omitempty,max=100"`
-	CreatedFrom           string `query:"created_from" validate:"omitempty,datetime=2006-01-02"`
+	SortBy                string `query:"sort_by" validate:"omitempty,oneof=po_expedition supplier requester_name products location po_date received_date due_date status created_at po_number"`
-	CreatedTo             string `query:"created_to" validate:"omitempty,datetime=2006-01-02"`
+	SortOrder             string `query:"sort_order" validate:"omitempty,oneof=asc desc ASC DESC"`
 }

internal/modules/repports/controllers/repport.balance_monitoring.export.go

@@ -0,0 +1,286 @@
+package controller
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/xuri/excelize/v2"
+	"gitlab.com/mbugroup/lti-api.git/internal/modules/repports/dto"
+)
+
+func isBalanceMonitoringExcelExportRequest(c *fiber.Ctx) bool {
+	return strings.EqualFold(strings.TrimSpace(c.Query("export")), "excel")
+}
+
+func exportBalanceMonitoringExcel(c *fiber.Ctx, items []dto.BalanceMonitoringRowDTO, totals dto.BalanceMonitoringTotalsDTO) error {
+	content, err := buildBalanceMonitoringWorkbook(items, totals)
+	if err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "failed to generate excel file")
+	}
+
+	filename := fmt.Sprintf("laporan-balance-monitoring-%s.xlsx", time.Now().Format("2006-01-02-1504"))
+	c.Set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+	c.Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, filename))
+	return c.Status(fiber.StatusOK).Send(content)
+}
+
+func buildBalanceMonitoringWorkbook(items []dto.BalanceMonitoringRowDTO, totals dto.BalanceMonitoringTotalsDTO) ([]byte, error) {
+	file := excelize.NewFile()
+	defer file.Close()
+
+	const sheet = "Balance Monitoring"
+	defaultSheet := file.GetSheetName(file.GetActiveSheetIndex())
+	if defaultSheet != sheet {
+		if err := file.SetSheetName(defaultSheet, sheet); err != nil {
+			return nil, err
+		}
+	}
+
+	if err := setBalanceMonitoringColumns(file, sheet); err != nil {
+		return nil, err
+	}
+	if err := setBalanceMonitoringHeaders(file, sheet); err != nil {
+		return nil, err
+	}
+	if err := writeBalanceMonitoringRows(file, sheet, items, totals); err != nil {
+		return nil, err
+	}
+	if err := file.SetPanes(sheet, &excelize.Panes{
+		Freeze:      true,
+		YSplit:      2,
+		TopLeftCell: "A3",
+		ActivePane:  "bottomLeft",
+	}); err != nil {
+		return nil, err
+	}
+
+	buf, err := file.WriteToBuffer()
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+var bmColumnWidths = map[string]float64{
+	"A": 5,
+	"B": 28,
+	"C": 18,
+	"D": 12,
+	"E": 12,
+	"F": 20,
+	"G": 12,
+	"H": 12,
+	"I": 20,
+	"J": 20,
+	"K": 18,
+	"L": 12,
+	"M": 16,
+	"N": 20,
+}
+
+func setBalanceMonitoringColumns(file *excelize.File, sheet string) error {
+	for col, width := range bmColumnWidths {
+		if err := file.SetColWidth(sheet, col, col, width); err != nil {
+			return err
+		}
+	}
+	if err := file.SetRowHeight(sheet, 1, 24); err != nil {
+		return err
+	}
+	return file.SetRowHeight(sheet, 2, 24)
+}
+
+func setBalanceMonitoringHeaders(file *excelize.File, sheet string) error {
+	borderStyle := []excelize.Border{
+		{Type: "left", Color: "000000", Style: 1},
+		{Type: "top", Color: "000000", Style: 1},
+		{Type: "bottom", Color: "000000", Style: 1},
+		{Type: "right", Color: "000000", Style: 1},
+	}
+	headerStyle, err := file.NewStyle(&excelize.Style{
+		Font: &excelize.Font{Bold: true, Color: "FFFFFF", Family: "Arial", Size: 10},
+		Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"4472C4"}},
+		Alignment: &excelize.Alignment{
+			Horizontal: "center",
+			Vertical:   "center",
+			WrapText:   true,
+		},
+		Border: borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	// Single-column headers: merge rows 1 and 2 vertically
+	singleColHeaders := map[string]string{
+		"A": "No",
+		"B": "Customer",
+		"C": "Saldo Awal",
+		"J": "Penjualan Trading",
+		"K": "Pembayaran",
+		"L": "Aging",
+		"M": "Aging Rata-Rata",
+		"N": "Saldo Akhir",
+	}
+	for col, header := range singleColHeaders {
+		if err := file.SetCellValue(sheet, col+"1", header); err != nil {
+			return err
+		}
+		if err := file.MergeCell(sheet, col+"1", col+"2"); err != nil {
+			return err
+		}
+	}
+
+	// Group headers: merge columns horizontally in row 1
+	if err := file.SetCellValue(sheet, "D1", "Penjualan Ayam"); err != nil {
+		return err
+	}
+	if err := file.MergeCell(sheet, "D1", "F1"); err != nil {
+		return err
+	}
+	if err := file.SetCellValue(sheet, "G1", "Penjualan Telur"); err != nil {
+		return err
+	}
+	if err := file.MergeCell(sheet, "G1", "I1"); err != nil {
+		return err
+	}
+
+	// Sub-column headers in row 2
+	subHeaders := map[string]string{
+		"D": "Ekor",
+		"E": "Kg",
+		"F": "Nominal",
+		"G": "Butir",
+		"H": "Kg",
+		"I": "Nominal",
+	}
+	for col, header := range subHeaders {
+		if err := file.SetCellValue(sheet, col+"2", header); err != nil {
+			return err
+		}
+	}
+
+	return file.SetCellStyle(sheet, "A1", "N2", headerStyle)
+}
+
+func writeBalanceMonitoringRows(file *excelize.File, sheet string, items []dto.BalanceMonitoringRowDTO, totals dto.BalanceMonitoringTotalsDTO) error {
+	borderStyle := []excelize.Border{
+		{Type: "left", Color: "000000", Style: 1},
+		{Type: "top", Color: "000000", Style: 1},
+		{Type: "bottom", Color: "000000", Style: 1},
+		{Type: "right", Color: "000000", Style: 1},
+	}
+
+	dataStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Color: "000000", Family: "Arial", Size: 10},
+		Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
+		Border:    borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	totalStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Bold: true, Color: "000000", Family: "Arial", Size: 10},
+		Fill:      excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"E2EFDA"}},
+		Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
+		Border:    borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	redDataStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Color: "FF0000", Family: "Arial", Size: 10},
+		Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
+		Border:    borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	redTotalStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Bold: true, Color: "FF0000", Family: "Arial", Size: 10},
+		Fill:      excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"E2EFDA"}},
+		Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
+		Border:    borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	for i, row := range items {
+		rowNum := i + 3
+		rowStr := strconv.Itoa(rowNum)
+
+		cells := map[string]interface{}{
+			"A": i + 1,
+			"B": row.Customer.Name,
+			"C": row.SaldoAwal,
+			"D": row.PenjualanAyam.Ekor,
+			"E": row.PenjualanAyam.Kg,
+			"F": row.PenjualanAyam.Nominal,
+			"G": row.PenjualanTelur.Butir,
+			"H": row.PenjualanTelur.Kg,
+			"I": row.PenjualanTelur.Nominal,
+			"J": row.PenjualanTrading.Nominal,
+			"K": row.Pembayaran,
+			"L": fmt.Sprintf("%d hari", row.Aging),
+			"M": formatBMAging(row.AgingRataRata),
+			"N": row.SaldoAkhir,
+		}
+		for col, val := range cells {
+			if err := file.SetCellValue(sheet, col+rowStr, val); err != nil {
+				return err
+			}
+		}
+		if err := file.SetCellStyle(sheet, "A"+rowStr, "N"+rowStr, dataStyle); err != nil {
+			return err
+		}
+		if row.SaldoAkhir < 0 {
+			if err := file.SetCellStyle(sheet, "N"+rowStr, "N"+rowStr, redDataStyle); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Totals row
+	totalRowStr := strconv.Itoa(len(items) + 3)
+	totalCells := map[string]interface{}{
+		"A": "Total",
+		"C": totals.SaldoAwal,
+		"D": totals.PenjualanAyam.Ekor,
+		"E": totals.PenjualanAyam.Kg,
+		"F": totals.PenjualanAyam.Nominal,
+		"G": totals.PenjualanTelur.Butir,
+		"H": totals.PenjualanTelur.Kg,
+		"I": totals.PenjualanTelur.Nominal,
+		"J": totals.PenjualanTrading.Nominal,
+		"K": totals.Pembayaran,
+		"N": totals.SaldoAkhir,
+	}
+	for col, val := range totalCells {
+		if err := file.SetCellValue(sheet, col+totalRowStr, val); err != nil {
+			return err
+		}
+	}
+	if err := file.SetCellStyle(sheet, "A"+totalRowStr, "N"+totalRowStr, totalStyle); err != nil {
+		return err
+	}
+	if totals.SaldoAkhir < 0 {
+		if err := file.SetCellStyle(sheet, "N"+totalRowStr, "N"+totalRowStr, redTotalStyle); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func formatBMAging(v float64) string {
+	s := strconv.FormatFloat(v, 'f', 2, 64)
+	s = strings.ReplaceAll(s, ".", ",")
+	return s + " hari"
+}

internal/modules/repports/controllers/repport.controller.go

@@ -51,6 +51,8 @@ func (c *RepportController) GetExpense(ctx *fiber.Ctx) error {
 		AreaId:                int64(ctx.QueryInt("area_id", 0)),
 		LocationId:            int64(ctx.QueryInt("location_id", 0)),
 		RealizationDate:       ctx.Query("realization_date", ""),
+		SortBy:                ctx.Query("sort_by", ""),
+		SortOrder:             ctx.Query("sort_order", ""),
 	}
 
 	locationScope, err := m.ResolveLocationScope(ctx, c.RepportService.DB())
@@ -322,6 +324,13 @@ func (c *RepportController) GetPurchaseSupplier(ctx *fiber.Ctx) error {
 		return err
 	}
 
+	if isPurchaseSupplierExcelExportRequest(ctx) {
+		return exportPurchaseSupplierExcel(ctx, result)
+	}
+	if isPurchaseSupplierExcelAllExportRequest(ctx) {
+		return exportPurchaseSupplierExcelAll(ctx, result)
+	}
+
 	filters := map[string]interface{}{
 		"area_id":             query.AreaIDs,
 		"supplier_id":         query.SupplierIDs,
@@ -362,6 +371,7 @@ func (c *RepportController) GetDebtSupplier(ctx *fiber.Ctx) error {
 		StartDate:   ctx.Query("start_date", ""),
 		EndDate:     ctx.Query("end_date", ""),
 		FilterBy:    ctx.Query("filter_by", ""),
+		SortBy:      ctx.Query("sort_by", ""),
 		SortOrder:   ctx.Query("sort_order", ""),
 	}
 
@@ -389,6 +399,13 @@ func (c *RepportController) GetDebtSupplier(ctx *fiber.Ctx) error {
 		return err
 	}
 
+	if isDebtSupplierExcelExportRequest(ctx) {
+		return exportDebtSupplierExcel(ctx, result)
+	}
+	if isDebtSupplierExcelAllExportRequest(ctx) {
+		return exportDebtSupplierExcelAll(ctx, result)
+	}
+
 	supplierIDs = query.SupplierIDs
 	if supplierIDs == nil {
 		supplierIDs = []int64{}
@@ -459,6 +476,8 @@ func (c *RepportController) GetCustomerPayment(ctx *fiber.Ctx) error {
 		Limit:       ctx.QueryInt("limit", 10),
 		CustomerIDs: customerIDs,
 		FilterBy:    strings.ToUpper(ctx.Query("filter_by", "")),
+		SortBy:      ctx.Query("sort_by", ""),
+		SortOrder:   ctx.Query("sort_order", ""),
 		StartDate:   ctx.Query("start_date", ""),
 		EndDate:     ctx.Query("end_date", ""),
 	}
@@ -473,6 +492,13 @@ func (c *RepportController) GetCustomerPayment(ctx *fiber.Ctx) error {
 		return err
 	}
 
+	if isCustomerPaymentExcelExportRequest(ctx) {
+		return exportCustomerPaymentExcel(ctx, result)
+	}
+	if isCustomerPaymentExcelAllExportRequest(ctx) {
+		return exportCustomerPaymentExcelAll(ctx, result)
+	}
+
 	// If single customer mode (only 1 customer ID), return without pagination
 	if len(customerIDs) == 1 {
 		return ctx.Status(fiber.StatusOK).
@@ -500,6 +526,87 @@ func (c *RepportController) GetCustomerPayment(ctx *fiber.Ctx) error {
 		})
 }
 
+type BalanceMonitoringResponse struct {
+	Code    int                              `json:"code"`
+	Status  string                           `json:"status"`
+	Message string                           `json:"message"`
+	Meta    response.Meta                    `json:"meta"`
+	Data    []dto.BalanceMonitoringRowDTO    `json:"data"`
+	Totals  dto.BalanceMonitoringTotalsDTO   `json:"totals"`
+}
+
+func (c *RepportController) GetBalanceMonitoring(ctx *fiber.Ctx) error {
+	customerIDs, err := parseUintCSV(ctx.Query("customer_ids"))
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "customer_ids must be comma separated positive integers")
+	}
+	salesIDs, err := parseUintCSV(ctx.Query("sales_ids"))
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "sales_ids must be comma separated positive integers")
+	}
+
+	query := &validation.BalanceMonitoringQuery{
+		Page:        ctx.QueryInt("page", 1),
+		Limit:       ctx.QueryInt("limit", 10),
+		CustomerIDs: customerIDs,
+		SalesIDs:    salesIDs,
+		FilterBy:    strings.ToLower(ctx.Query("filter_by", "")),
+		SortBy:      ctx.Query("sort_by", ""),
+		SortOrder:   ctx.Query("sort_order", ""),
+		StartDate:   ctx.Query("start_date", ""),
+		EndDate:     ctx.Query("end_date", ""),
+	}
+
+	result, totals, totalResults, err := c.RepportService.GetBalanceMonitoring(ctx, query)
+	if err != nil {
+		return err
+	}
+
+	if isBalanceMonitoringExcelExportRequest(ctx) {
+		return exportBalanceMonitoringExcel(ctx, result, totals)
+	}
+
+	limit := query.Limit
+	if limit < 1 {
+		limit = 10
+	}
+
+	return ctx.Status(fiber.StatusOK).JSON(BalanceMonitoringResponse{
+		Code:    fiber.StatusOK,
+		Status:  "success",
+		Message: "Get balance monitoring report successfully",
+		Meta: response.Meta{
+			Page:         query.Page,
+			Limit:        limit,
+			TotalPages:   int64(math.Ceil(float64(totalResults) / float64(limit))),
+			TotalResults: totalResults,
+		},
+		Data:   result,
+		Totals: totals,
+	})
+}
+
+func parseUintCSV(raw string) ([]uint, error) {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return nil, nil
+	}
+	parts := strings.Split(raw, ",")
+	result := make([]uint, 0, len(parts))
+	for _, part := range parts {
+		part = strings.TrimSpace(part)
+		if part == "" {
+			continue
+		}
+		id, err := strconv.ParseUint(part, 10, 32)
+		if err != nil || id == 0 {
+			return nil, fmt.Errorf("invalid id: %s", part)
+		}
+		result = append(result, uint(id))
+	}
+	return result, nil
+}
+
 func (c *RepportController) GetProductionResult(ctx *fiber.Ctx) error {
 	idParam := ctx.Params("idProjectFlockKandang")
 	if idParam == "" {

internal/modules/repports/controllers/repport.customer_payment.export.go

@@ -0,0 +1,576 @@
+package controller
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/xuri/excelize/v2"
+	"gitlab.com/mbugroup/lti-api.git/internal/modules/repports/dto"
+)
+
+func isCustomerPaymentExcelExportRequest(c *fiber.Ctx) bool {
+	return strings.EqualFold(strings.TrimSpace(c.Query("export")), "excel")
+}
+
+func isCustomerPaymentExcelAllExportRequest(c *fiber.Ctx) bool {
+	return strings.EqualFold(strings.TrimSpace(c.Query("export")), "excel-all")
+}
+
+func exportCustomerPaymentExcel(c *fiber.Ctx, items []dto.CustomerPaymentReportItem) error {
+	content, err := buildCustomerPaymentWorkbook(items)
+	if err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "failed to generate excel file")
+	}
+
+	filename := fmt.Sprintf("laporan-kontrol-pembayaran-customer-%s.xlsx", time.Now().Format("2006-01-02-1504"))
+	c.Set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+	c.Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, filename))
+	return c.Status(fiber.StatusOK).Send(content)
+}
+
+func exportCustomerPaymentExcelAll(c *fiber.Ctx, items []dto.CustomerPaymentReportItem) error {
+	content, err := buildCustomerPaymentAllWorkbook(items)
+	if err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "failed to generate excel file")
+	}
+
+	filename := fmt.Sprintf("laporan-kontrol-pembayaran-customer-all-%s.xlsx", time.Now().Format("2006-01-02-1504"))
+	c.Set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+	c.Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, filename))
+	return c.Status(fiber.StatusOK).Send(content)
+}
+
+func buildCustomerPaymentWorkbook(items []dto.CustomerPaymentReportItem) ([]byte, error) {
+	file := excelize.NewFile()
+	defer file.Close()
+
+	defaultSheet := file.GetSheetName(file.GetActiveSheetIndex())
+
+	if len(items) == 0 {
+		if err := writeCustomerPaymentSheet(file, defaultSheet, dto.CustomerPaymentReportItem{}); err != nil {
+			return nil, err
+		}
+		buf, err := file.WriteToBuffer()
+		if err != nil {
+			return nil, err
+		}
+		return buf.Bytes(), nil
+	}
+
+	for idx, item := range items {
+		sheetName := sanitizeCustomerPaymentSheetName(customerPaymentName(item))
+		if sheetName == "" {
+			sheetName = fmt.Sprintf("Customer %d", idx+1)
+		}
+
+		if idx == 0 {
+			if defaultSheet != sheetName {
+				if err := file.SetSheetName(defaultSheet, sheetName); err != nil {
+					return nil, err
+				}
+			}
+		} else {
+			if _, err := file.NewSheet(sheetName); err != nil {
+				return nil, err
+			}
+		}
+
+		if err := writeCustomerPaymentSheet(file, sheetName, item); err != nil {
+			return nil, err
+		}
+	}
+
+	buf, err := file.WriteToBuffer()
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+func buildCustomerPaymentAllWorkbook(items []dto.CustomerPaymentReportItem) ([]byte, error) {
+	file := excelize.NewFile()
+	defer file.Close()
+
+	const sheet = "Kontrol Pembayaran Customer"
+	defaultSheet := file.GetSheetName(file.GetActiveSheetIndex())
+	if defaultSheet != sheet {
+		if err := file.SetSheetName(defaultSheet, sheet); err != nil {
+			return nil, err
+		}
+	}
+
+	if err := setCustomerPaymentAllColumns(file, sheet); err != nil {
+		return nil, err
+	}
+	if err := setCustomerPaymentAllHeaders(file, sheet); err != nil {
+		return nil, err
+	}
+	if err := writeCustomerPaymentAllRows(file, sheet, items); err != nil {
+		return nil, err
+	}
+	if err := file.SetPanes(sheet, &excelize.Panes{
+		Freeze:      true,
+		YSplit:      1,
+		TopLeftCell: "A2",
+		ActivePane:  "bottomLeft",
+	}); err != nil {
+		return nil, err
+	}
+
+	buf, err := file.WriteToBuffer()
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+var cpSheetHeaders = []string{
+	"No",
+	"Tanggal DO/Bayar",
+	"Tanggal Realisasi",
+	"Aging",
+	"Referensi",
+	"Nomor Polisi",
+	"Ekor/Qty",
+	"Berat (Kg)",
+	"AVG",
+	"Harga/Unit (Rp)",
+	"Harga Akhir (Rp)",
+	"Total (Rp)",
+	"Pembayaran (Rp)",
+	"Saldo Piutang (Rp)",
+	"Keterangan",
+	"Pengambilan",
+	"Sales/Marketing",
+}
+
+var cpAllSheetHeaders = append([]string{"Customer"}, cpSheetHeaders...)
+
+var cpSheetColumnWidths = map[string]float64{
+	"A": 5,
+	"B": 15,
+	"C": 12,
+	"D": 8,
+	"E": 12,
+	"F": 15,
+	"G": 10,
+	"H": 12,
+	"I": 10,
+	"J": 15,
+	"K": 15,
+	"L": 15,
+	"M": 15,
+	"N": 15,
+	"O": 20,
+	"P": 15,
+	"Q": 20,
+}
+
+var cpAllSheetColumnWidths = map[string]float64{
+	"A": 22,
+	"B": 6,
+	"C": 15,
+	"D": 15,
+	"E": 8,
+	"F": 12,
+	"G": 15,
+	"H": 10,
+	"I": 12,
+	"J": 10,
+	"K": 15,
+	"L": 15,
+	"M": 15,
+	"N": 15,
+	"O": 15,
+	"P": 20,
+	"Q": 15,
+	"R": 20,
+}
+
+func writeCustomerPaymentSheet(file *excelize.File, sheet string, item dto.CustomerPaymentReportItem) error {
+	for col, width := range cpSheetColumnWidths {
+		if err := file.SetColWidth(sheet, col, col, width); err != nil {
+			return err
+		}
+	}
+
+	// Row 1: headers
+	for i, h := range cpSheetHeaders {
+		col, _ := excelize.ColumnNumberToName(i + 1)
+		if err := file.SetCellValue(sheet, col+"1", h); err != nil {
+			return err
+		}
+	}
+
+	redStyle, err := file.NewStyle(&excelize.Style{
+		Font: &excelize.Font{Color: "FF0000"},
+	})
+	if err != nil {
+		return err
+	}
+
+	// Row 2: saldo awal
+	if err := file.SetCellValue(sheet, "N2", item.InitialBalance); err != nil {
+		return err
+	}
+	if item.InitialBalance < 0 {
+		if err := file.SetCellStyle(sheet, "N2", "N2", redStyle); err != nil {
+			return err
+		}
+	}
+
+	// Rows 3+: data rows
+	for i, row := range item.Rows {
+		rowNum := i + 3
+		rowStr := fmt.Sprintf("%d", rowNum)
+
+		cells := customerPaymentRowCells(row, i+1)
+		for colIdx, val := range cells {
+			col, _ := excelize.ColumnNumberToName(colIdx + 1)
+			if err := file.SetCellValue(sheet, col+rowStr, val); err != nil {
+				return err
+			}
+		}
+
+		if row.AccountsReceivable < 0 {
+			if err := file.SetCellStyle(sheet, "N"+rowStr, "N"+rowStr, redStyle); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Total row
+	totalRowNum := len(item.Rows) + 3
+	totalRowStr := fmt.Sprintf("%d", totalRowNum)
+
+	totalCells := map[string]interface{}{
+		"A": "Total",
+		"G": formatCPIDInteger(item.Summary.TotalQty),
+		"H": formatCPIDInteger(item.Summary.TotalWeight),
+		"K": item.Summary.TotalFinalAmount,
+		"L": item.Summary.TotalGrandAmount,
+		"M": item.Summary.TotalPayment,
+		"N": item.Summary.TotalAccountsReceivable,
+	}
+	for col, val := range totalCells {
+		if err := file.SetCellValue(sheet, col+totalRowStr, val); err != nil {
+			return err
+		}
+	}
+	if item.Summary.TotalAccountsReceivable < 0 {
+		if err := file.SetCellStyle(sheet, "N"+totalRowStr, "N"+totalRowStr, redStyle); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func setCustomerPaymentAllColumns(file *excelize.File, sheet string) error {
+	for col, width := range cpAllSheetColumnWidths {
+		if err := file.SetColWidth(sheet, col, col, width); err != nil {
+			return err
+		}
+	}
+	return file.SetRowHeight(sheet, 1, 24)
+}
+
+func setCustomerPaymentAllHeaders(file *excelize.File, sheet string) error {
+	borderStyle := []excelize.Border{
+		{Type: "left", Color: "000000", Style: 1},
+		{Type: "top", Color: "000000", Style: 1},
+		{Type: "bottom", Color: "000000", Style: 1},
+		{Type: "right", Color: "000000", Style: 1},
+	}
+	headerStyle, err := file.NewStyle(&excelize.Style{
+		Font: &excelize.Font{Bold: true, Color: "FFFFFF", Family: "Arial", Size: 10},
+		Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"4472C4"}},
+		Alignment: &excelize.Alignment{
+			Horizontal: "center",
+			Vertical:   "center",
+			WrapText:   true,
+		},
+		Border: borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	for i, h := range cpAllSheetHeaders {
+		col, _ := excelize.ColumnNumberToName(i + 1)
+		if err := file.SetCellValue(sheet, col+"1", h); err != nil {
+			return err
+		}
+	}
+
+	lastCol, _ := excelize.ColumnNumberToName(len(cpAllSheetHeaders))
+	return file.SetCellStyle(sheet, "A1", lastCol+"1", headerStyle)
+}
+
+func writeCustomerPaymentAllRows(file *excelize.File, sheet string, items []dto.CustomerPaymentReportItem) error {
+	borderStyle := []excelize.Border{
+		{Type: "left", Color: "000000", Style: 1},
+		{Type: "top", Color: "000000", Style: 1},
+		{Type: "bottom", Color: "000000", Style: 1},
+		{Type: "right", Color: "000000", Style: 1},
+	}
+
+	dataStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Color: "000000", Family: "Arial", Size: 10},
+		Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
+		Border:    borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	totalStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Bold: true, Color: "000000", Family: "Arial", Size: 10},
+		Fill:      excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"E2EFDA"}},
+		Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
+		Border:    borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	redDataStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Color: "FF0000", Family: "Arial", Size: 10},
+		Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
+		Border:    borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	redTotalStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Bold: true, Color: "FF0000", Family: "Arial", Size: 10},
+		Fill:      excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"E2EFDA"}},
+		Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
+		Border:    borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	lastHeaderCol, _ := excelize.ColumnNumberToName(len(cpAllSheetHeaders))
+	currentRow := 2
+
+	for _, item := range items {
+		name := customerPaymentName(item)
+
+		// Saldo awal row
+		saldoStr := fmt.Sprintf("%d", currentRow)
+		if err := file.SetCellValue(sheet, "A"+saldoStr, name); err != nil {
+			return err
+		}
+		if err := file.SetCellValue(sheet, "O"+saldoStr, item.InitialBalance); err != nil {
+			return err
+		}
+		if err := file.SetCellStyle(sheet, "A"+saldoStr, lastHeaderCol+saldoStr, dataStyle); err != nil {
+			return err
+		}
+		if item.InitialBalance < 0 {
+			if err := file.SetCellStyle(sheet, "O"+saldoStr, "O"+saldoStr, redDataStyle); err != nil {
+				return err
+			}
+		}
+		currentRow++
+
+		// Data rows
+		for seq, row := range item.Rows {
+			rowStr := fmt.Sprintf("%d", currentRow)
+			if err := file.SetCellValue(sheet, "A"+rowStr, name); err != nil {
+				return err
+			}
+			cells := customerPaymentRowCells(row, seq+1)
+			for colIdx, val := range cells {
+				col, _ := excelize.ColumnNumberToName(colIdx + 2)
+				if err := file.SetCellValue(sheet, col+rowStr, val); err != nil {
+					return err
+				}
+			}
+			if err := file.SetCellStyle(sheet, "A"+rowStr, lastHeaderCol+rowStr, dataStyle); err != nil {
+				return err
+			}
+			if row.AccountsReceivable < 0 {
+				if err := file.SetCellStyle(sheet, "O"+rowStr, "O"+rowStr, redDataStyle); err != nil {
+					return err
+				}
+			}
+			currentRow++
+		}
+
+		// Total row
+		totalStr := fmt.Sprintf("%d", currentRow)
+		totalCells := map[string]interface{}{
+			"A": name,
+			"B": "Total",
+			"H": formatCPIDInteger(item.Summary.TotalQty),
+			"I": formatCPIDInteger(item.Summary.TotalWeight),
+			"L": item.Summary.TotalFinalAmount,
+			"M": item.Summary.TotalGrandAmount,
+			"N": item.Summary.TotalPayment,
+			"O": item.Summary.TotalAccountsReceivable,
+		}
+		for col, val := range totalCells {
+			if err := file.SetCellValue(sheet, col+totalStr, val); err != nil {
+				return err
+			}
+		}
+		if err := file.SetCellStyle(sheet, "A"+totalStr, lastHeaderCol+totalStr, totalStyle); err != nil {
+			return err
+		}
+		if item.Summary.TotalAccountsReceivable < 0 {
+			if err := file.SetCellStyle(sheet, "O"+totalStr, "O"+totalStr, redTotalStyle); err != nil {
+				return err
+			}
+		}
+		currentRow++
+
+		// Empty separator row
+		currentRow++
+	}
+
+	return nil
+}
+
+// customerPaymentRowCells returns 17 cell values for cols A..Q.
+func customerPaymentRowCells(row dto.CustomerPaymentReportRow, seq int) []interface{} {
+	return []interface{}{
+		seq,
+		formatCPDate(row.TransDate),
+		formatCPOptionalDate(row.DeliveryDate),
+		formatCPAging(row.AgingDay),
+		safeCPText(row.Reference),
+		joinCPStrings(row.VehicleNumbers),
+		formatCPIDInteger(row.Qty),
+		formatCPIDInteger(row.Weight),
+		formatCPAvg(row.AverageWeight),
+		row.UnitPrice,
+		row.FinalPrice,
+		row.TotalPrice,
+		row.PaymentAmount,
+		row.AccountsReceivable,
+		safeCPText(row.Status),
+		joinCPStrings(row.PickupInfo),
+		safeCPText(row.SalesPerson),
+	}
+}
+
+func customerPaymentName(item dto.CustomerPaymentReportItem) string {
+	name := strings.TrimSpace(item.Customer.Name)
+	if name == "" {
+		return "Customer"
+	}
+	return name
+}
+
+func sanitizeCustomerPaymentSheetName(name string) string {
+	replacer := strings.NewReplacer(
+		":", " ", "\\", " ", "/", " ",
+		"?", " ", "*", " ", "[", " ", "]", " ",
+	)
+	sanitized := strings.TrimSpace(replacer.Replace(name))
+	if sanitized == "" {
+		return "Sheet"
+	}
+	runes := []rune(sanitized)
+	if len(runes) > 31 {
+		return string(runes[:31])
+	}
+	return sanitized
+}
+
+var cpIndonesianMonths = [12]string{
+	"Jan", "Feb", "Mar", "Apr", "Mei", "Jun",
+	"Jul", "Agu", "Sep", "Okt", "Nov", "Des",
+}
+
+func formatCPDate(t time.Time) string {
+	if t.IsZero() {
+		return "-"
+	}
+	loc, err := time.LoadLocation("Asia/Jakarta")
+	if err == nil {
+		t = t.In(loc)
+	}
+	return fmt.Sprintf("%02d %s %d", t.Day(), cpIndonesianMonths[t.Month()-1], t.Year())
+}
+
+func formatCPOptionalDate(t *time.Time) string {
+	if t == nil || t.IsZero() {
+		return "-"
+	}
+	return formatCPDate(*t)
+}
+
+func formatCPAging(v *int) string {
+	if v == nil {
+		return "-"
+	}
+	return strconv.Itoa(*v)
+}
+
+func formatCPIDInteger(v float64) string {
+	n := int64(math.Round(v))
+	if n == 0 {
+		return "0"
+	}
+	negative := n < 0
+	abs := n
+	if negative {
+		abs = -n
+	}
+	s := strconv.FormatInt(abs, 10)
+	// insert dots as thousand separators
+	var b strings.Builder
+	start := len(s) % 3
+	if start == 0 {
+		start = 3
+	}
+	b.WriteString(s[:start])
+	for i := start; i < len(s); i += 3 {
+		b.WriteByte('.')
+		b.WriteString(s[i : i+3])
+	}
+	if negative {
+		return "-" + b.String()
+	}
+	return b.String()
+}
+
+
+func formatCPAvg(v float64) string {
+	if v == 0 {
+		return "0"
+	}
+	s := strconv.FormatFloat(v, 'f', 2, 64)
+	return strings.ReplaceAll(s, ".", ",")
+}
+
+func safeCPText(s string) string {
+	t := strings.TrimSpace(s)
+	if t == "" {
+		return "-"
+	}
+	return t
+}
+
+func joinCPStrings(ss []string) string {
+	var parts []string
+	for _, s := range ss {
+		s = strings.TrimSpace(s)
+		if s != "" {
+			parts = append(parts, s)
+		}
+	}
+	if len(parts) == 0 {
+		return "-"
+	}
+	return strings.Join(parts, "\n")
+}

internal/modules/repports/controllers/repport.debt_supplier.export.go

@@ -0,0 +1,452 @@
+package controller
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/xuri/excelize/v2"
+	"gitlab.com/mbugroup/lti-api.git/internal/modules/repports/dto"
+)
+
+func isDebtSupplierExcelExportRequest(c *fiber.Ctx) bool {
+	return strings.EqualFold(strings.TrimSpace(c.Query("export")), "excel")
+}
+
+func isDebtSupplierExcelAllExportRequest(c *fiber.Ctx) bool {
+	return strings.EqualFold(strings.TrimSpace(c.Query("export")), "excel-all")
+}
+
+func exportDebtSupplierExcel(c *fiber.Ctx, items []dto.DebtSupplierDTO) error {
+	content, err := buildDebtSupplierWorkbook(items)
+	if err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "failed to generate excel file")
+	}
+
+	filename := fmt.Sprintf("laporan-hutang-supplier-%s.xlsx", time.Now().Format("2006-01-02-1504"))
+	c.Set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+	c.Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, filename))
+	return c.Status(fiber.StatusOK).Send(content)
+}
+
+func exportDebtSupplierExcelAll(c *fiber.Ctx, items []dto.DebtSupplierDTO) error {
+	content, err := buildDebtSupplierAllWorkbook(items)
+	if err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "failed to generate excel file")
+	}
+
+	filename := fmt.Sprintf("laporan-hutang-supplier-all-%s.xlsx", time.Now().Format("2006-01-02-1504"))
+	c.Set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+	c.Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, filename))
+	return c.Status(fiber.StatusOK).Send(content)
+}
+
+// buildDebtSupplierWorkbook creates a workbook with one sheet per supplier.
+func buildDebtSupplierWorkbook(items []dto.DebtSupplierDTO) ([]byte, error) {
+	file := excelize.NewFile()
+	defer file.Close()
+
+	defaultSheet := file.GetSheetName(file.GetActiveSheetIndex())
+
+	if len(items) == 0 {
+		if err := writeDebtSupplierSheet(file, defaultSheet, dto.DebtSupplierDTO{}); err != nil {
+			return nil, err
+		}
+		buf, err := file.WriteToBuffer()
+		if err != nil {
+			return nil, err
+		}
+		return buf.Bytes(), nil
+	}
+
+	for idx, item := range items {
+		sheetName := sanitizeDebtSupplierSheetName(debtSupplierName(item))
+		if sheetName == "" {
+			sheetName = fmt.Sprintf("Supplier %d", idx+1)
+		}
+
+		if idx == 0 {
+			if defaultSheet != sheetName {
+				if err := file.SetSheetName(defaultSheet, sheetName); err != nil {
+					return nil, err
+				}
+			}
+		} else {
+			if _, err := file.NewSheet(sheetName); err != nil {
+				return nil, err
+			}
+		}
+
+		if err := writeDebtSupplierSheet(file, sheetName, item); err != nil {
+			return nil, err
+		}
+	}
+
+	buf, err := file.WriteToBuffer()
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+// buildDebtSupplierAllWorkbook creates a single-sheet workbook with purchase-supplier styling.
+func buildDebtSupplierAllWorkbook(items []dto.DebtSupplierDTO) ([]byte, error) {
+	file := excelize.NewFile()
+	defer file.Close()
+
+	const sheet = "Rekap Hutang Supplier"
+	defaultSheet := file.GetSheetName(file.GetActiveSheetIndex())
+	if defaultSheet != sheet {
+		if err := file.SetSheetName(defaultSheet, sheet); err != nil {
+			return nil, err
+		}
+	}
+
+	if err := setDebtSupplierAllColumns(file, sheet); err != nil {
+		return nil, err
+	}
+	if err := setDebtSupplierAllHeaders(file, sheet); err != nil {
+		return nil, err
+	}
+	if err := writeDebtSupplierAllRows(file, sheet, items); err != nil {
+		return nil, err
+	}
+	if err := file.SetPanes(sheet, &excelize.Panes{
+		Freeze:      true,
+		YSplit:      1,
+		TopLeftCell: "A2",
+		ActivePane:  "bottomLeft",
+	}); err != nil {
+		return nil, err
+	}
+
+	buf, err := file.WriteToBuffer()
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+var debtSupplierSheetHeaders = []string{
+	"No",
+	"Nomor PR",
+	"Nomor PO",
+	"Tanggal Terima/Bayar",
+	"Tanggal PO",
+	"Aging (Hari)",
+	"Area",
+	"Gudang",
+	"Jatuh Tempo",
+	"Status Jatuh Tempo",
+	"Nominal Pembelian (Rp)",
+	"Pembayaran (Rp)",
+	"Sisa Saldo Hutang (Rp)",
+	"Status",
+	"Nomor Perjalanan",
+}
+
+var debtSupplierAllSheetHeaders = append([]string{"Supplier"}, debtSupplierSheetHeaders...)
+
+var debtSupplierSheetColumnWidths = map[string]float64{
+	"A": 5,
+	"B": 14,
+	"C": 12,
+	"D": 20,
+	"E": 10,
+	"F": 12,
+	"G": 15,
+	"H": 20,
+	"I": 12,
+	"J": 20,
+	"K": 20,
+	"L": 15,
+	"M": 20,
+	"N": 12,
+	"O": 15,
+}
+
+var debtSupplierAllSheetColumnWidths = map[string]float64{
+	"A": 24,
+	"B": 6,
+	"C": 14,
+	"D": 14,
+	"E": 20,
+	"F": 12,
+	"G": 10,
+	"H": 16,
+	"I": 22,
+	"J": 12,
+	"K": 22,
+	"L": 20,
+	"M": 18,
+	"N": 22,
+	"O": 14,
+	"P": 18,
+}
+
+func writeDebtSupplierSheet(file *excelize.File, sheet string, item dto.DebtSupplierDTO) error {
+	for col, width := range debtSupplierSheetColumnWidths {
+		if err := file.SetColWidth(sheet, col, col, width); err != nil {
+			return err
+		}
+	}
+
+	// Row 1: headers
+	for i, h := range debtSupplierSheetHeaders {
+		col, _ := excelize.ColumnNumberToName(i + 1)
+		if err := file.SetCellValue(sheet, col+"1", h); err != nil {
+			return err
+		}
+	}
+
+	// Row 2: saldo awal
+	if err := file.SetCellValue(sheet, "M2", item.InitialBalance); err != nil {
+		return err
+	}
+
+	// Rows 3+: data
+	redStyle, err := file.NewStyle(&excelize.Style{
+		Font: &excelize.Font{Color: "FF0000"},
+	})
+	if err != nil {
+		return err
+	}
+
+	for i, row := range item.Rows {
+		rowNum := i + 3
+		rowStr := fmt.Sprintf("%d", rowNum)
+
+		values := debtSupplierRowCells(row, i+1)
+		for colIdx, val := range values {
+			col, _ := excelize.ColumnNumberToName(colIdx + 1)
+			if err := file.SetCellValue(sheet, col+rowStr, val); err != nil {
+				return err
+			}
+		}
+
+		if row.DebtPrice < 0 {
+			if err := file.SetCellStyle(sheet, "M"+rowStr, "M"+rowStr, redStyle); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Total row
+	totalRowNum := len(item.Rows) + 3
+	totalRowStr := fmt.Sprintf("%d", totalRowNum)
+	totalCells := map[string]interface{}{
+		"A": "Total",
+		"F": item.Total.Aging,
+		"K": item.Total.TotalPrice,
+		"L": item.Total.PaymentPrice,
+		"M": item.Total.DebtPrice,
+	}
+	for col, val := range totalCells {
+		if err := file.SetCellValue(sheet, col+totalRowStr, val); err != nil {
+			return err
+		}
+	}
+	if item.Total.DebtPrice < 0 {
+		if err := file.SetCellStyle(sheet, "M"+totalRowStr, "M"+totalRowStr, redStyle); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func setDebtSupplierAllColumns(file *excelize.File, sheet string) error {
+	for col, width := range debtSupplierAllSheetColumnWidths {
+		if err := file.SetColWidth(sheet, col, col, width); err != nil {
+			return err
+		}
+	}
+	if err := file.SetRowHeight(sheet, 1, 24); err != nil {
+		return err
+	}
+	return nil
+}
+
+func setDebtSupplierAllHeaders(file *excelize.File, sheet string) error {
+	headerStyle, err := file.NewStyle(&excelize.Style{
+		Font: &excelize.Font{Bold: true, Color: "FFFFFF", Family: "Arial", Size: 10},
+		Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"4472C4"}},
+		Alignment: &excelize.Alignment{
+			Horizontal: "center",
+			Vertical:   "center",
+			WrapText:   true,
+		},
+		Border: []excelize.Border{
+			{Type: "left", Color: "000000", Style: 1},
+			{Type: "top", Color: "000000", Style: 1},
+			{Type: "bottom", Color: "000000", Style: 1},
+			{Type: "right", Color: "000000", Style: 1},
+		},
+	})
+	if err != nil {
+		return err
+	}
+
+	for i, h := range debtSupplierAllSheetHeaders {
+		col, _ := excelize.ColumnNumberToName(i + 1)
+		if err := file.SetCellValue(sheet, col+"1", h); err != nil {
+			return err
+		}
+	}
+
+	lastCol, _ := excelize.ColumnNumberToName(len(debtSupplierAllSheetHeaders))
+	return file.SetCellStyle(sheet, "A1", lastCol+"1", headerStyle)
+}
+
+func writeDebtSupplierAllRows(file *excelize.File, sheet string, items []dto.DebtSupplierDTO) error {
+	borderStyle := []excelize.Border{
+		{Type: "left", Color: "000000", Style: 1},
+		{Type: "top", Color: "000000", Style: 1},
+		{Type: "bottom", Color: "000000", Style: 1},
+		{Type: "right", Color: "000000", Style: 1},
+	}
+
+	dataStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Color: "000000", Family: "Arial", Size: 10},
+		Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
+		Border:    borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	totalStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Bold: true, Color: "000000", Family: "Arial", Size: 10},
+		Fill:      excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"E2EFDA"}},
+		Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
+		Border:    borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	lastHeaderCol, _ := excelize.ColumnNumberToName(len(debtSupplierAllSheetHeaders))
+
+	currentRow := 2
+	for _, item := range items {
+		supplierName := debtSupplierName(item)
+
+		// Saldo awal row
+		saldoRowStr := fmt.Sprintf("%d", currentRow)
+		if err := file.SetCellValue(sheet, "A"+saldoRowStr, supplierName); err != nil {
+			return err
+		}
+		if err := file.SetCellValue(sheet, "N"+saldoRowStr, item.InitialBalance); err != nil {
+			return err
+		}
+		if err := file.SetCellStyle(sheet, "A"+saldoRowStr, lastHeaderCol+saldoRowStr, dataStyle); err != nil {
+			return err
+		}
+		currentRow++
+
+		// Data rows
+		for seq, row := range item.Rows {
+			rowStr := fmt.Sprintf("%d", currentRow)
+			if err := file.SetCellValue(sheet, "A"+rowStr, supplierName); err != nil {
+				return err
+			}
+			values := debtSupplierRowCells(row, seq+1)
+			for colIdx, val := range values {
+				col, _ := excelize.ColumnNumberToName(colIdx + 2)
+				if err := file.SetCellValue(sheet, col+rowStr, val); err != nil {
+					return err
+				}
+			}
+			if err := file.SetCellStyle(sheet, "A"+rowStr, lastHeaderCol+rowStr, dataStyle); err != nil {
+				return err
+			}
+			currentRow++
+		}
+
+		// Total row
+		totalRowStr := fmt.Sprintf("%d", currentRow)
+		totalCells := map[string]interface{}{
+			"A": supplierName,
+			"B": "Total",
+			"L": item.Total.TotalPrice,
+			"M": item.Total.PaymentPrice,
+			"N": item.Total.DebtPrice,
+		}
+		for col, val := range totalCells {
+			if err := file.SetCellValue(sheet, col+totalRowStr, val); err != nil {
+				return err
+			}
+		}
+		if err := file.SetCellStyle(sheet, "A"+totalRowStr, lastHeaderCol+totalRowStr, totalStyle); err != nil {
+			return err
+		}
+		currentRow++
+
+		// Empty separator row
+		currentRow++
+	}
+
+	return nil
+}
+
+// debtSupplierRowCells returns cell values for one data row (columns: No, PR, PO, ReceivedDate, PoDate, Aging, Area, Warehouse, DueDate, DueStatus, TotalPrice, PaymentPrice, DebtPrice, Status, TravelNumber).
+func debtSupplierRowCells(row dto.DebtSupplierRowDTO, seq int) []interface{} {
+	areaName := "-"
+	if row.Area != nil && strings.TrimSpace(row.Area.Name) != "" {
+		areaName = row.Area.Name
+	}
+	warehouseName := "-"
+	if row.Warehouse != nil && strings.TrimSpace(row.Warehouse.Name) != "" {
+		warehouseName = row.Warehouse.Name
+	}
+
+	return []interface{}{
+		seq,
+		safeDebtSupplierText(row.PrNumber),
+		safeDebtSupplierText(row.PoNumber),
+		safeDebtSupplierText(row.ReceivedDate),
+		safeDebtSupplierText(row.PoDate),
+		row.Aging,
+		areaName,
+		warehouseName,
+		safeDebtSupplierText(row.DueDate),
+		safeDebtSupplierText(row.DueStatus),
+		row.TotalPrice,
+		row.PaymentPrice,
+		row.DebtPrice,
+		safeDebtSupplierText(row.Status),
+		safeDebtSupplierText(row.TravelNumber),
+	}
+}
+
+func debtSupplierName(item dto.DebtSupplierDTO) string {
+	if item.Supplier != nil && strings.TrimSpace(item.Supplier.Name) != "" {
+		return item.Supplier.Name
+	}
+	return "Supplier"
+}
+
+func sanitizeDebtSupplierSheetName(name string) string {
+	replacer := strings.NewReplacer(
+		":", " ", "\\", " ", "/", " ",
+		"?", " ", "*", " ", "[", " ", "]", " ",
+	)
+	sanitized := strings.TrimSpace(replacer.Replace(name))
+	if sanitized == "" {
+		return "Sheet"
+	}
+	runes := []rune(sanitized)
+	if len(runes) > 31 {
+		return string(runes[:31])
+	}
+	return sanitized
+}
+
+func safeDebtSupplierText(s string) string {
+	t := strings.TrimSpace(s)
+	if t == "" {
+		return "-"
+	}
+	return t
+}

internal/modules/repports/controllers/repport.marketing.export.go

@@ -2,7 +2,6 @@ package controller
 
 import (
 	"fmt"
-	"math"
 	"strconv"
 	"strings"
 	"time"
@@ -50,6 +49,14 @@ func buildMarketingReportWorkbook(items []dto.RepportMarketingItemDTO) ([]byte,
 	if err := setMarketingReportRows(file, items); err != nil {
 		return nil, err
 	}
+	if err := file.SetPanes(marketingReportExportSheetName, &excelize.Panes{
+		Freeze:      true,
+		YSplit:      1,
+		TopLeftCell: "A2",
+		ActivePane:  "bottomLeft",
+	}); err != nil {
+		return nil, err
+	}
 
 	buffer, err := file.WriteToBuffer()
 	if err != nil {
@@ -88,6 +95,10 @@ func setMarketingReportColumns(file *excelize.File) error {
 		}
 	}
 
+	if err := file.SetRowHeight(sheet, 1, 24); err != nil {
+		return err
+	}
+
 	return nil
 }
 
@@ -110,7 +121,6 @@ func setMarketingReportHeaders(file *excelize.File) error {
 		"Bobot Total (Kg)",
 		"Harga Jual (Rp)",
 		"HPP (Rp)",
-		"HPP Amount (Rp)",
 		"Total (Rp)",
 	}
 
@@ -124,7 +134,22 @@ func setMarketingReportHeaders(file *excelize.File) error {
 		}
 	}
 
-	return nil
+	headerStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Bold: true, Color: "1F2937"},
+		Fill:      excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"DCEBFA"}},
+		Alignment: &excelize.Alignment{Horizontal: "center", Vertical: "center"},
+		Border: []excelize.Border{
+			{Type: "left", Color: "D1D5DB", Style: 1},
+			{Type: "top", Color: "D1D5DB", Style: 1},
+			{Type: "bottom", Color: "D1D5DB", Style: 1},
+			{Type: "right", Color: "D1D5DB", Style: 1},
+		},
+	})
+	if err != nil {
+		return err
+	}
+
+	return file.SetCellStyle(sheet, "A1", "Q1", headerStyle)
 }
 
 func setMarketingReportRows(file *excelize.File, items []dto.RepportMarketingItemDTO) error {
@@ -165,16 +190,15 @@ func setMarketingReportRows(file *excelize.File, items []dto.RepportMarketingIte
 			customerName,
 			safeMarketingExportText(item.DoNumber),
 			salesName,
-			safeMarketingExportText(item.VehicleNumber),
+			safeMarketingExportText(formatMarketingVehicleNumber(item.VehicleNumber)),
 			safeMarketingExportText(item.MarketingType),
 			productName,
 			item.Qty,
 			item.AverageWeightKg,
 			item.TotalWeightKg,
-			formatMarketingRupiah(item.SalesPricePerKg),
+			item.SalesPricePerKg,
-			formatMarketingRupiah(item.HppPricePerKg),
+			item.HppPricePerKg,
-			formatMarketingRupiah(item.HppAmount),
+			item.SalesAmount,
-			formatMarketingRupiah(item.SalesAmount),
 		}
 
 		for colIdx, val := range values {
@@ -204,21 +228,87 @@ func setMarketingReportRows(file *excelize.File, items []dto.RepportMarketingIte
 		if err := file.SetCellValue(sheet, "N"+totalRow, summary.TotalWeightKg); err != nil {
 			return err
 		}
-		if err := file.SetCellValue(sheet, "O"+totalRow, formatMarketingRupiah(summary.AverageSalesPrice)); err != nil {
+		if err := file.SetCellValue(sheet, "O"+totalRow, summary.AverageSalesPrice); err != nil {
 			return err
 		}
-		if err := file.SetCellValue(sheet, "P"+totalRow, formatMarketingRupiah(summary.TotalHppPricePerKg)); err != nil {
+		if err := file.SetCellValue(sheet, "P"+totalRow, summary.TotalHppPricePerKg); err != nil {
 			return err
 		}
-		if err := file.SetCellValue(sheet, "Q"+totalRow, formatMarketingRupiah(float64(summary.TotalHppAmount))); err != nil {
+		if err := file.SetCellValue(sheet, "Q"+totalRow, float64(summary.TotalSalesAmount)); err != nil {
-			return err
-		}
-		if err := file.SetCellValue(sheet, "R"+totalRow, formatMarketingRupiah(float64(summary.TotalSalesAmount))); err != nil {
 			return err
 		}
 	}
 
-	return nil
+	if len(items) > 0 {
+		lastDataRow := strconv.Itoa(len(items) + 1)
+
+		dataStyle, err := file.NewStyle(&excelize.Style{
+			Alignment: &excelize.Alignment{Horizontal: "left", Vertical: "center", WrapText: true},
+			Border: []excelize.Border{
+				{Type: "left", Color: "D1D5DB", Style: 1},
+				{Type: "top", Color: "D1D5DB", Style: 1},
+				{Type: "bottom", Color: "D1D5DB", Style: 1},
+				{Type: "right", Color: "D1D5DB", Style: 1},
+			},
+		})
+		if err != nil {
+			return err
+		}
+		if err := file.SetCellStyle(sheet, "A2", "Q"+lastDataRow, dataStyle); err != nil {
+			return err
+		}
+
+		numericStyle, err := file.NewStyle(&excelize.Style{
+			Alignment: &excelize.Alignment{Horizontal: "right", Vertical: "center"},
+			Border: []excelize.Border{
+				{Type: "left", Color: "D1D5DB", Style: 1},
+				{Type: "top", Color: "D1D5DB", Style: 1},
+				{Type: "bottom", Color: "D1D5DB", Style: 1},
+				{Type: "right", Color: "D1D5DB", Style: 1},
+			},
+		})
+		if err != nil {
+			return err
+		}
+		if err := file.SetCellStyle(sheet, "L2", "Q"+lastDataRow, numericStyle); err != nil {
+			return err
+		}
+	}
+
+	totalTextStyle, err := file.NewStyle(&excelize.Style{
+		Font: &excelize.Font{Bold: true, Color: "1F2937"},
+		Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"F3F4F6"}},
+		Alignment: &excelize.Alignment{Horizontal: "left", Vertical: "center"},
+		Border: []excelize.Border{
+			{Type: "left", Color: "D1D5DB", Style: 1},
+			{Type: "top", Color: "D1D5DB", Style: 1},
+			{Type: "bottom", Color: "D1D5DB", Style: 1},
+			{Type: "right", Color: "D1D5DB", Style: 1},
+		},
+	})
+	if err != nil {
+		return err
+	}
+	if err := file.SetCellStyle(sheet, "A"+totalRow, "Q"+totalRow, totalTextStyle); err != nil {
+		return err
+	}
+
+	totalNumericStyle, err := file.NewStyle(&excelize.Style{
+		Font: &excelize.Font{Bold: true, Color: "1F2937"},
+		Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"F3F4F6"}},
+		Alignment: &excelize.Alignment{Horizontal: "right", Vertical: "center"},
+		Border: []excelize.Border{
+			{Type: "left", Color: "D1D5DB", Style: 1},
+			{Type: "top", Color: "D1D5DB", Style: 1},
+			{Type: "bottom", Color: "D1D5DB", Style: 1},
+			{Type: "right", Color: "D1D5DB", Style: 1},
+		},
+	})
+	if err != nil {
+		return err
+	}
+
+	return file.SetCellStyle(sheet, "L"+totalRow, "Q"+totalRow, totalNumericStyle)
 }
 
 func formatMarketingDate(t time.Time) string {
@@ -242,30 +332,3 @@ func safeMarketingExportText(value string) string {
 	return trimmed
 }
 
-// formatMarketingRupiah formats a float64 as Indonesian Rupiah string.
-// e.g. 1000000 → "Rp 1.000.000"
-func formatMarketingRupiah(value float64) string {
-	rounded := int64(math.Round(value))
-
-	negative := rounded < 0
-	abs := rounded
-	if negative {
-		abs = -rounded
-	}
-
-	numStr := strconv.FormatInt(abs, 10)
-	n := len(numStr)
-
-	var b strings.Builder
-	for i, c := range numStr {
-		if i > 0 && (n-i)%3 == 0 {
-			b.WriteByte('.')
-		}
-		b.WriteRune(c)
-	}
-
-	if negative {
-		return "Rp -" + b.String()
-	}
-	return "Rp " + b.String()
-}

internal/modules/repports/controllers/repport.marketing.pdf.go

@@ -56,22 +56,21 @@ type pdfColumn struct {
 var marketingPdfColumns = []pdfColumn{
 	{"No", 6, "C"},
 	{"Tanggal\nJual", 16, "C"},
-	{"Tanggal\nRealisasi", 16, "C"},
+	{"Tanggal\nRealisasi", 20, "C"},
 	{"Aging\n(Hari)", 9, "C"},
 	{"Gudang\nFisik", 20, "L"},
 	{"Pelanggan", 20, "L"},
 	{"No. DO", 18, "L"},
 	{"Sales", 18, "L"},
 	{"No. Polisi", 18, "L"},
-	{"Tipe\nMarketing", 14, "C"},
+	{"Tipe\nMarketing", 16, "C"},
 	{"Produk", 16, "L"},
 	{"Kuantitas", 13, "R"},
-	{"Bobot Rata-Rata\n(Kg)", 13, "R"},
+	{"Bobot\nRata-Rata (Kg)", 18, "R"},
-	{"Bobot Total Berat\n(Kg)", 14, "R"},
+	{"Bobot\nTotal Berat (Kg)", 18, "R"},
 	{"Harga Jual\n(Rp)", 17, "R"},
 	{"HPP\n(Rp)", 17, "R"},
-	{"Total Jual\n(Rp)", 18, "R"},
+	{"Total (Rp)", 18, "R"},
-	{"Total HPP\n(Rp)", 18, "R"},
 }
 
 // ---------------------------------------------------------------------------
@@ -214,7 +213,7 @@ func calcMarketingRowHeight(pdf *fpdf.Fpdf, values []string, lineH float64) floa
 	cols := marketingPdfColumns
 	maxLines := 1
 	for i, col := range cols {
-		if i >= len(values) || i == 10 {
+		if i >= len(values) || i == 9 {
 			continue
 		}
 		usableW := col.width - 2*margin
@@ -238,7 +237,7 @@ func writeMarketingPdfRow(pdf *fpdf.Fpdf, item dto.RepportMarketingItemDTO, valu
 	x := 10.0
 
 	for i, col := range cols {
-		if i == 10 {
+		if i == 9 {
 			drawMarketingTypeBadge(pdf, x, y, col.width, rowH, item.MarketingType)
 			pdf.SetDrawColor(borderR, borderG, borderB)
 			pdf.SetTextColor(40, 40, 40)
@@ -283,8 +282,8 @@ func marketingPdfRowValues(no int, item dto.RepportMarketingItemDTO) []string {
 		customer,
 		safeMarketingExportText(item.DoNumber),
 		sales,
-		safeMarketingExportText(item.VehicleNumber),
+		safeMarketingExportText(formatMarketingVehicleNumber(item.VehicleNumber)),
-		safeMarketingExportText(item.MarketingType), // index 10, overridden by badge
+		safeMarketingExportText(item.MarketingType), // index 9, overridden by badge
 		product,
 		formatMarketingPdfNumber(item.Qty),
 		formatMarketingPdfDecimal(item.AverageWeightKg),
@@ -292,7 +291,6 @@ func marketingPdfRowValues(no int, item dto.RepportMarketingItemDTO) []string {
 		formatMarketingPdfRupiah(item.SalesPricePerKg),
 		formatMarketingPdfRupiah(item.HppPricePerKg),
 		formatMarketingPdfRupiah(item.SalesAmount),
-		formatMarketingPdfRupiah(item.HppAmount),
 	}
 }
 
@@ -306,30 +304,9 @@ func writeMarketingPdfTotal(pdf *fpdf.Fpdf, items []dto.RepportMarketingItemDTO)
 		return
 	}
 
-	rowH := 6.5
-
-	if pdf.GetY()+rowH > marketingPdfPageHeight(pdf)-12 {
-		pdf.AddPage()
-		writeMarketingPdfHeader(pdf)
-	}
-
 	pdf.SetFont("Helvetica", "B", 6)
-	pdf.SetFillColor(220, 230, 245)
-	pdf.SetTextColor(30, 64, 120)
-	pdf.SetDrawColor(borderR, borderG, borderB)
-	pdf.SetLineWidth(0.1)
 
-	y := pdf.GetY()
+	lineH := 5.0
-	x := 10.0
-
-	// merge first 11 cols (No … Tipe Marketing) into "TOTAL" label
-	mergedWidth := 0.0
-	for i := 0; i < 11; i++ {
-		mergedWidth += marketingPdfColumns[i].width
-	}
-	pdf.SetXY(x, y)
-	pdf.CellFormat(mergedWidth, rowH, "TOTAL", "1", 0, "R", true, 0, "")
-	x += mergedWidth
 
 	totals := []string{
 		formatMarketingPdfNumber(float64(summary.TotalQty)),
@@ -338,13 +315,58 @@ func writeMarketingPdfTotal(pdf *fpdf.Fpdf, items []dto.RepportMarketingItemDTO)
 		formatMarketingPdfRupiah(summary.AverageSalesPrice),
 		formatMarketingPdfRupiah(summary.TotalHppPricePerKg),
 		formatMarketingPdfRupiah(float64(summary.TotalSalesAmount)),
-		formatMarketingPdfRupiah(float64(summary.TotalHppAmount)),
 	}
 
+	margin := pdf.GetCellMargin()
+	maxLines := 1
+	for i, val := range totals {
+		col := marketingPdfColumns[11+i]
+		usableW := col.width - 2*margin
+		if usableW <= 0 {
+			continue
+		}
+		lines := pdf.SplitLines([]byte(val), usableW)
+		n := len(lines)
+		if n == 0 {
+			n = 1
+		}
+		if n > maxLines {
+			maxLines = n
+		}
+	}
+	rowH := float64(maxLines) * lineH
+
+	if pdf.GetY()+rowH > marketingPdfPageHeight(pdf)-12 {
+		pdf.AddPage()
+		writeMarketingPdfHeader(pdf)
+		pdf.SetFont("Helvetica", "B", 6)
+	}
+
+	pdf.SetTextColor(30, 64, 120)
+	pdf.SetDrawColor(borderR, borderG, borderB)
+	pdf.SetLineWidth(0.1)
+
+	y := pdf.GetY()
+	x := 10.0
+
+	const totalFillR, totalFillG, totalFillB = 220, 230, 245
+
+	mergedWidth := 0.0
+	for i := range 11 {
+		mergedWidth += marketingPdfColumns[i].width
+	}
+	pdf.SetFillColor(totalFillR, totalFillG, totalFillB)
+	pdf.Rect(x, y, mergedWidth, rowH, "FD")
+	pdf.SetXY(x, y)
+	pdf.MultiCell(mergedWidth, lineH, "TOTAL", "", "R", false)
+	x += mergedWidth
+
 	for i, val := range totals {
 		col := marketingPdfColumns[11+i]
+		pdf.SetFillColor(totalFillR, totalFillG, totalFillB)
+		pdf.Rect(x, y, col.width, rowH, "FD")
 		pdf.SetXY(x, y)
-		pdf.CellFormat(col.width, rowH, val, "1", 0, "R", true, 0, "")
+		pdf.MultiCell(col.width, lineH, val, "", "R", false)
 		x += col.width
 	}
 
@@ -510,6 +532,27 @@ func marketingPdfPageHeight(pdf *fpdf.Fpdf) float64 {
 	return h
 }
 
+// formatMarketingVehicleNumber spaces out Indonesian plate segments: D1234MBU → D 1234 MBU.
+// Returns s unchanged if it doesn't match the [letters][digits][letters] pattern.
+func formatMarketingVehicleNumber(s string) string {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return s
+	}
+	i := 0
+	for i < len(s) && (s[i] >= 'A' && s[i] <= 'Z' || s[i] >= 'a' && s[i] <= 'z') {
+		i++
+	}
+	j := i
+	for j < len(s) && s[j] >= '0' && s[j] <= '9' {
+		j++
+	}
+	if i == 0 || j == i || j == len(s) {
+		return s
+	}
+	return s[:i] + " " + s[i:j] + " " + s[j:]
+}
+
 // formatMarketingPdfThousands inserts period every 3 digits.
 func formatMarketingPdfThousands(v int64) string {
 	negative := v < 0

internal/modules/repports/controllers/repport.purchase_supplier.export.go

@@ -0,0 +1,415 @@
+package controller
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/xuri/excelize/v2"
+	"gitlab.com/mbugroup/lti-api.git/internal/modules/repports/dto"
+)
+
+func isPurchaseSupplierExcelExportRequest(c *fiber.Ctx) bool {
+	return strings.EqualFold(strings.TrimSpace(c.Query("export")), "excel")
+}
+
+func isPurchaseSupplierExcelAllExportRequest(c *fiber.Ctx) bool {
+	return strings.EqualFold(strings.TrimSpace(c.Query("export")), "excel-all")
+}
+
+func exportPurchaseSupplierExcel(c *fiber.Ctx, items []dto.PurchaseSupplierDTO) error {
+	content, err := buildPurchaseSupplierWorkbook(items)
+	if err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "failed to generate excel file")
+	}
+
+	filename := fmt.Sprintf("laporan-pembelian-supplier-%s.xlsx", time.Now().Format("2006-01-02-1504"))
+	c.Set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+	c.Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, filename))
+	return c.Status(fiber.StatusOK).Send(content)
+}
+
+func exportPurchaseSupplierExcelAll(c *fiber.Ctx, items []dto.PurchaseSupplierDTO) error {
+	content, err := buildPurchaseSupplierAllWorkbook(items)
+	if err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "failed to generate excel file")
+	}
+
+	filename := fmt.Sprintf("laporan-pembelian-supplier-all-%s.xlsx", time.Now().Format("2006-01-02-1504"))
+	c.Set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+	c.Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, filename))
+	return c.Status(fiber.StatusOK).Send(content)
+}
+
+// buildPurchaseSupplierWorkbook creates a workbook with one sheet per supplier.
+func buildPurchaseSupplierWorkbook(items []dto.PurchaseSupplierDTO) ([]byte, error) {
+	file := excelize.NewFile()
+	defer file.Close()
+
+	defaultSheet := file.GetSheetName(file.GetActiveSheetIndex())
+
+	if len(items) == 0 {
+		if err := writePurchaseSupplierSheet(file, defaultSheet, dto.PurchaseSupplierDTO{}); err != nil {
+			return nil, err
+		}
+		buf, err := file.WriteToBuffer()
+		if err != nil {
+			return nil, err
+		}
+		return buf.Bytes(), nil
+	}
+
+	for idx, item := range items {
+		sheetName := sanitizePurchaseSupplierSheetName(purchaseSupplierName(item))
+		if sheetName == "" {
+			sheetName = fmt.Sprintf("Supplier %d", idx+1)
+		}
+
+		if idx == 0 {
+			if defaultSheet != sheetName {
+				if err := file.SetSheetName(defaultSheet, sheetName); err != nil {
+					return nil, err
+				}
+			}
+		} else {
+			if _, err := file.NewSheet(sheetName); err != nil {
+				return nil, err
+			}
+		}
+
+		if err := writePurchaseSupplierSheet(file, sheetName, item); err != nil {
+			return nil, err
+		}
+	}
+
+	buf, err := file.WriteToBuffer()
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+// buildPurchaseSupplierAllWorkbook creates a single-sheet workbook with all suppliers.
+func buildPurchaseSupplierAllWorkbook(items []dto.PurchaseSupplierDTO) ([]byte, error) {
+	file := excelize.NewFile()
+	defer file.Close()
+
+	const sheet = "Rekap Pembelian Supplier"
+	defaultSheet := file.GetSheetName(file.GetActiveSheetIndex())
+	if defaultSheet != sheet {
+		if err := file.SetSheetName(defaultSheet, sheet); err != nil {
+			return nil, err
+		}
+	}
+
+	if err := setPurchaseSupplierAllColumns(file, sheet); err != nil {
+		return nil, err
+	}
+	if err := setPurchaseSupplierAllHeaders(file, sheet); err != nil {
+		return nil, err
+	}
+	if err := writePurchaseSupplierAllRows(file, sheet, items); err != nil {
+		return nil, err
+	}
+	if err := file.SetPanes(sheet, &excelize.Panes{
+		Freeze:      true,
+		YSplit:      1,
+		TopLeftCell: "A2",
+		ActivePane:  "bottomLeft",
+	}); err != nil {
+		return nil, err
+	}
+
+	buf, err := file.WriteToBuffer()
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+var purchaseSupplierSheetHeaders = []string{
+	"No",
+	"Tanggal Terima",
+	"Tanggal PO",
+	"No. Referensi",
+	"Nama Produk",
+	"Tujuan",
+	"QTY",
+	"Harga Beli (Rp)",
+	"Value Harga Beli (Rp)",
+	"Transport (Rp)",
+	"Value Transport (Rp)",
+	"Jumlah (Rp)",
+	"Ekspedisi",
+	"Surat Jalan",
+}
+
+var purchaseSupplierAllSheetHeaders = append([]string{"Supplier"}, purchaseSupplierSheetHeaders...)
+
+var purchaseSupplierSheetColumnWidths = map[string]float64{
+	"A": 5,
+	"B": 14,
+	"C": 12,
+	"D": 16,
+	"E": 20,
+	"F": 20,
+	"G": 10,
+	"H": 20,
+	"I": 20,
+	"J": 22,
+	"K": 22,
+	"L": 16,
+	"M": 20,
+	"N": 20,
+}
+
+var purchaseSupplierAllSheetColumnWidths = map[string]float64{
+	"A": 24,
+	"B": 6,
+	"C": 14,
+	"D": 12,
+	"E": 16,
+	"F": 20,
+	"G": 20,
+	"H": 10,
+	"I": 20,
+	"J": 20,
+	"K": 22,
+	"L": 22,
+	"M": 16,
+	"N": 20,
+	"O": 20,
+}
+
+func writePurchaseSupplierSheet(file *excelize.File, sheet string, item dto.PurchaseSupplierDTO) error {
+	for col, width := range purchaseSupplierSheetColumnWidths {
+		if err := file.SetColWidth(sheet, col, col, width); err != nil {
+			return err
+		}
+	}
+
+	for i, h := range purchaseSupplierSheetHeaders {
+		col, _ := excelize.ColumnNumberToName(i + 1)
+		if err := file.SetCellValue(sheet, col+"1", h); err != nil {
+			return err
+		}
+	}
+
+	for i, row := range item.Rows {
+		rowNum := i + 2
+		rowStr := fmt.Sprintf("%d", rowNum)
+
+		values := purchaseSupplierRowCells(row, i+1)
+		for colIdx, val := range values {
+			col, _ := excelize.ColumnNumberToName(colIdx + 1)
+			if err := file.SetCellValue(sheet, col+rowStr, val); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Summary row
+	totalRowNum := len(item.Rows) + 2
+	totalRowStr := fmt.Sprintf("%d", totalRowNum)
+	totalCells := map[string]interface{}{
+		"A": "Total",
+		"G": item.Summary.TotalQty,
+		"H": item.Summary.TotalUnitPrice,
+		"I": item.Summary.TotalPurchaseValue,
+		"J": item.Summary.TotalTransportUnitPrice,
+		"K": item.Summary.TotalTransportValue,
+		"L": item.Summary.TotalAmount,
+	}
+	for col, val := range totalCells {
+		if err := file.SetCellValue(sheet, col+totalRowStr, val); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func setPurchaseSupplierAllColumns(file *excelize.File, sheet string) error {
+	for col, width := range purchaseSupplierAllSheetColumnWidths {
+		if err := file.SetColWidth(sheet, col, col, width); err != nil {
+			return err
+		}
+	}
+	if err := file.SetRowHeight(sheet, 1, 24); err != nil {
+		return err
+	}
+	return nil
+}
+
+func setPurchaseSupplierAllHeaders(file *excelize.File, sheet string) error {
+	headerStyle, err := file.NewStyle(&excelize.Style{
+		Font: &excelize.Font{Bold: true, Color: "FFFFFF", Family: "Arial", Size: 10},
+		Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"4472C4"}},
+		Alignment: &excelize.Alignment{
+			Horizontal: "center",
+			Vertical:   "center",
+			WrapText:   true,
+		},
+		Border: []excelize.Border{
+			{Type: "left", Color: "000000", Style: 1},
+			{Type: "top", Color: "000000", Style: 1},
+			{Type: "bottom", Color: "000000", Style: 1},
+			{Type: "right", Color: "000000", Style: 1},
+		},
+	})
+	if err != nil {
+		return err
+	}
+
+	for i, h := range purchaseSupplierAllSheetHeaders {
+		col, _ := excelize.ColumnNumberToName(i + 1)
+		if err := file.SetCellValue(sheet, col+"1", h); err != nil {
+			return err
+		}
+	}
+
+	lastCol, _ := excelize.ColumnNumberToName(len(purchaseSupplierAllSheetHeaders))
+	return file.SetCellStyle(sheet, "A1", lastCol+"1", headerStyle)
+}
+
+func writePurchaseSupplierAllRows(file *excelize.File, sheet string, items []dto.PurchaseSupplierDTO) error {
+	borderStyle := []excelize.Border{
+		{Type: "left", Color: "000000", Style: 1},
+		{Type: "top", Color: "000000", Style: 1},
+		{Type: "bottom", Color: "000000", Style: 1},
+		{Type: "right", Color: "000000", Style: 1},
+	}
+
+	dataStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Color: "000000", Family: "Arial", Size: 10},
+		Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
+		Border:    borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	totalStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Bold: true, Color: "000000", Family: "Arial", Size: 10},
+		Fill:      excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"E2EFDA"}},
+		Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
+		Border:    borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	lastHeaderCol, _ := excelize.ColumnNumberToName(len(purchaseSupplierAllSheetHeaders))
+
+	currentRow := 2
+	for _, item := range items {
+		supplierName := purchaseSupplierName(item)
+
+		// Data rows
+		for seq, row := range item.Rows {
+			rowStr := fmt.Sprintf("%d", currentRow)
+			if err := file.SetCellValue(sheet, "A"+rowStr, supplierName); err != nil {
+				return err
+			}
+			values := purchaseSupplierRowCells(row, seq+1)
+			for colIdx, val := range values {
+				col, _ := excelize.ColumnNumberToName(colIdx + 2)
+				if err := file.SetCellValue(sheet, col+rowStr, val); err != nil {
+					return err
+				}
+			}
+			if err := file.SetCellStyle(sheet, "A"+rowStr, lastHeaderCol+rowStr, dataStyle); err != nil {
+				return err
+			}
+			currentRow++
+		}
+
+		// Summary row
+		totalRowStr := fmt.Sprintf("%d", currentRow)
+		totalCells := map[string]interface{}{
+			"A": supplierName,
+			"B": "Total",
+			"H": item.Summary.TotalQty,
+			"I": item.Summary.TotalUnitPrice,
+			"J": item.Summary.TotalPurchaseValue,
+			"K": item.Summary.TotalTransportUnitPrice,
+			"L": item.Summary.TotalTransportValue,
+			"M": item.Summary.TotalAmount,
+		}
+		for col, val := range totalCells {
+			if err := file.SetCellValue(sheet, col+totalRowStr, val); err != nil {
+				return err
+			}
+		}
+		if err := file.SetCellStyle(sheet, "A"+totalRowStr, lastHeaderCol+totalRowStr, totalStyle); err != nil {
+			return err
+		}
+		currentRow++
+
+		// Empty separator row
+		currentRow++
+	}
+
+	return nil
+}
+
+// purchaseSupplierRowCells returns cell values for one data row.
+func purchaseSupplierRowCells(row dto.PurchaseSupplierRowDTO, seq int) []interface{} {
+	productName := "-"
+	if row.Product != nil && strings.TrimSpace(row.Product.Name) != "" {
+		productName = row.Product.Name
+	}
+	warehouseName := "-"
+	if row.Warehouse != nil && strings.TrimSpace(row.Warehouse.Name) != "" {
+		warehouseName = row.Warehouse.Name
+	}
+
+	return []interface{}{
+		seq,
+		safePurchaseSupplierText(row.ReceiveDate),
+		safePurchaseSupplierText(row.PoDate),
+		safePurchaseSupplierText(row.PoNumber),
+		productName,
+		warehouseName,
+		row.Qty,
+		row.UnitPrice,
+		row.PurchaseValue,
+		row.TransportUnitPrice,
+		row.TransportValue,
+		row.TotalAmount,
+		safePurchaseSupplierText(row.Expedition),
+		safePurchaseSupplierText(row.DeliveryNumber),
+	}
+}
+
+func purchaseSupplierName(item dto.PurchaseSupplierDTO) string {
+	if item.Supplier != nil && strings.TrimSpace(item.Supplier.Name) != "" {
+		return item.Supplier.Name
+	}
+	return "Supplier"
+}
+
+func sanitizePurchaseSupplierSheetName(name string) string {
+	replacer := strings.NewReplacer(
+		":", " ", "\\", " ", "/", " ",
+		"?", " ", "*", " ", "[", " ", "]", " ",
+	)
+	sanitized := strings.TrimSpace(replacer.Replace(name))
+	if sanitized == "" {
+		return "Sheet"
+	}
+	runes := []rune(sanitized)
+	if len(runes) > 31 {
+		return string(runes[:31])
+	}
+	return sanitized
+}
+
+func safePurchaseSupplierText(s string) string {
+	t := strings.TrimSpace(s)
+	if t == "" {
+		return "-"
+	}
+	return t
+}

internal/modules/repports/dto/repportBalanceMonitoring.dto.go

@@ -0,0 +1,71 @@
+package dto
+
+import (
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	customerDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/customers/dto"
+)
+
+type BalanceMonitoringAyamDTO struct {
+	Ekor    float64 `json:"ekor"`
+	Kg      float64 `json:"kg"`
+	Nominal float64 `json:"nominal"`
+}
+
+type BalanceMonitoringTelurDTO struct {
+	Butir   float64 `json:"butir"`
+	Kg      float64 `json:"kg"`
+	Nominal float64 `json:"nominal"`
+}
+
+type BalanceMonitoringTradingDTO struct {
+	Qty     float64 `json:"qty"`
+	Kg      float64 `json:"kg"`
+	Nominal float64 `json:"nominal"`
+}
+
+type BalanceMonitoringRowDTO struct {
+	Customer         customerDTO.CustomerRelationDTO `json:"customer"`
+	SaldoAwal        float64                         `json:"saldo_awal"`
+	PenjualanAyam    BalanceMonitoringAyamDTO        `json:"penjualan_ayam"`
+	PenjualanTelur   BalanceMonitoringTelurDTO       `json:"penjualan_telur"`
+	PenjualanTrading BalanceMonitoringTradingDTO     `json:"penjualan_trading"`
+	Pembayaran       float64                         `json:"pembayaran"`
+	Aging            int                             `json:"aging"`
+	AgingRataRata    float64                         `json:"aging_rata_rata"`
+	SaldoAkhir       float64                         `json:"saldo_akhir"`
+}
+
+type BalanceMonitoringTotalsDTO struct {
+	SaldoAwal        float64                     `json:"saldo_awal"`
+	PenjualanAyam    BalanceMonitoringAyamDTO    `json:"penjualan_ayam"`
+	PenjualanTelur   BalanceMonitoringTelurDTO   `json:"penjualan_telur"`
+	PenjualanTrading BalanceMonitoringTradingDTO `json:"penjualan_trading"`
+	Pembayaran       float64                     `json:"pembayaran"`
+	Aging            int                         `json:"aging"`
+	AgingRataRata    float64                     `json:"aging_rata_rata"`
+	SaldoAkhir       float64                     `json:"saldo_akhir"`
+}
+
+func ToBalanceMonitoringRowDTO(
+	customer entity.Customer,
+	saldoAwal float64,
+	ayam BalanceMonitoringAyamDTO,
+	telur BalanceMonitoringTelurDTO,
+	trading BalanceMonitoringTradingDTO,
+	pembayaran float64,
+	aging int,
+	agingRataRata float64,
+) BalanceMonitoringRowDTO {
+	saldoAkhir := saldoAwal + pembayaran - (ayam.Nominal + telur.Nominal + trading.Nominal)
+	return BalanceMonitoringRowDTO{
+		Customer:         customerDTO.ToCustomerRelationDTO(customer),
+		SaldoAwal:        saldoAwal,
+		PenjualanAyam:    ayam,
+		PenjualanTelur:   telur,
+		PenjualanTrading: trading,
+		Pembayaran:       pembayaran,
+		Aging:            aging,
+		AgingRataRata:    agingRataRata,
+		SaldoAkhir:       saldoAkhir,
+	}
+}

internal/modules/repports/dto/repportExpense.dto.go

@@ -6,6 +6,7 @@ import (
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	approvalDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/approvals/dto"
 	kandangDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/kandangs/dto"
+	locationDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/locations/dto"
 	nonstockDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/nonstocks/dto"
 	supplierDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/suppliers/dto"
 )
@@ -48,6 +49,7 @@ type RepportExpenseRealisasiDTO struct {
 
 type RepportExpenseListDTO struct {
 	RepportExpenseBaseDTO
+	Location       *locationDTO.LocationRelationDTO `json:"location,omitempty"`
 	Kandang        *kandangDTO.KandangRelationDTO   `json:"kandang,omitempty"`
 	Pengajuan      RepportExpensePengajuanDTO       `json:"pengajuan"`
 	Realisasi      RepportExpenseRealisasiDTO       `json:"realisasi"`
@@ -133,6 +135,15 @@ func ToRepportExpenseListDTO(baseDTO RepportExpenseBaseDTO, ns *entity.ExpenseNo
 		totalRealisasi = ns.Realization.Qty * ns.Realization.Price
 	}
 
+	var location *locationDTO.LocationRelationDTO
+	if ns.Expense != nil && ns.Expense.Location != nil && ns.Expense.Location.Id != 0 {
+		mapped := locationDTO.ToLocationRelationDTO(*ns.Expense.Location)
+		location = &mapped
+	} else if ns.Kandang != nil && ns.Kandang.Location.Id != 0 {
+		mapped := locationDTO.ToLocationRelationDTO(ns.Kandang.Location)
+		location = &mapped
+	}
+
 	// Get kandang data at the main level
 	var kandang *kandangDTO.KandangRelationDTO
 	if ns.Kandang != nil && ns.Kandang.Id != 0 {
@@ -142,6 +153,7 @@ func ToRepportExpenseListDTO(baseDTO RepportExpenseBaseDTO, ns *entity.ExpenseNo
 
 	return RepportExpenseListDTO{
 		RepportExpenseBaseDTO: baseDTO,
+		Location:              location,
 		Kandang:               kandang,
 		Pengajuan:             ToRepportExpensePengajuanDTO(ns),
 		Realisasi:             realisasi,

internal/modules/repports/dto/repportExpenseDepreciation.dto.go

@@ -22,6 +22,10 @@ type ExpenseDepreciationRowDTO struct {
 	DepreciationPercentEffective      float64 `json:"depreciation_percent_effective"`
 	DepreciationValue                 float64 `json:"depreciation_value"`
 	PulletCostDayNTotal               float64 `json:"pullet_cost_day_n_total"`
+	MultiplicationPercentage          float64 `json:"multiplication_percentage"`
+	DayN                              int     `json:"day_n"`
+	ChickinDate                       string  `json:"chickin_date"`
+	TotalValuePulletAfterDepreciation float64 `json:"total_value_pullet_after_depreciation"`
 	Components                        any     `json:"components"`
 }
 

internal/modules/repports/module.go

@@ -40,6 +40,7 @@ func (RepportModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *
 	expenseDepreciationRepository := repportRepo.NewExpenseDepreciationRepository(db)
 	productionResultRepository := repportRepo.NewProductionResultRepository(db)
 	customerPaymentRepository := repportRepo.NewCustomerPaymentRepository(db)
+	balanceMonitoringRepository := repportRepo.NewBalanceMonitoringRepository(db)
 	customerRepository := customerRepo.NewCustomerRepository(db)
 	standardGrowthDetailRepository := productionStandardRepo.NewStandardGrowthDetailRepository(db)
 	productionStandardDetailRepository := productionStandardRepo.NewProductionStandardDetailRepository(db)
@@ -66,6 +67,7 @@ func (RepportModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *
 		hppPerKandangRepository,
 		productionResultRepository,
 		customerPaymentRepository,
+		balanceMonitoringRepository,
 		customerRepository,
 		standardGrowthDetailRepository,
 		productionStandardDetailRepository,

internal/modules/repports/repositories/balance_monitoring.repository.go

@@ -0,0 +1,550 @@
+package repositories
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/repports/validations"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+
+	"gorm.io/gorm"
+)
+
+type BalanceMonitoringCategoryRow struct {
+	CustomerID     uint    `gorm:"column:customer_id"`
+	AyamQty        float64 `gorm:"column:ayam_qty"`
+	AyamKg         float64 `gorm:"column:ayam_kg"`
+	AyamNominal    float64 `gorm:"column:ayam_nominal"`
+	TelurQty       float64 `gorm:"column:telur_qty"`
+	TelurKg        float64 `gorm:"column:telur_kg"`
+	TelurNominal   float64 `gorm:"column:telur_nominal"`
+	TradingQty     float64 `gorm:"column:trading_qty"`
+	TradingKg      float64 `gorm:"column:trading_kg"`
+	TradingNominal float64 `gorm:"column:trading_nominal"`
+}
+
+type BalanceMonitoringAgingRow struct {
+	CustomerID    uint    `gorm:"column:customer_id"`
+	AgingMax      int     `gorm:"column:aging_max"`
+	AgingRataRata float64 `gorm:"column:aging_rata_rata"`
+}
+
+type BalanceMonitoringGrandTotalsRow struct {
+	SaldoAwalLifetime float64 `gorm:"column:saldo_awal_lifetime"`
+	SalesBeforeStart  float64 `gorm:"column:sales_before_start"`
+	PaymentBeforeStart float64 `gorm:"column:payment_before_start"`
+	AyamQty           float64 `gorm:"column:ayam_qty"`
+	AyamKg            float64 `gorm:"column:ayam_kg"`
+	AyamNominal       float64 `gorm:"column:ayam_nominal"`
+	TelurQty          float64 `gorm:"column:telur_qty"`
+	TelurKg           float64 `gorm:"column:telur_kg"`
+	TelurNominal      float64 `gorm:"column:telur_nominal"`
+	TradingQty        float64 `gorm:"column:trading_qty"`
+	TradingKg         float64 `gorm:"column:trading_kg"`
+	TradingNominal    float64 `gorm:"column:trading_nominal"`
+	PaymentInPeriod   float64 `gorm:"column:payment_in_period"`
+	AgingMax          int     `gorm:"column:aging_max"`
+	AgingRataRata     float64 `gorm:"column:aging_rata_rata"`
+}
+
+type BalanceMonitoringRepository interface {
+	GetCustomerIDsForBalanceMonitoring(ctx context.Context, offset, limit int, filters *validation.BalanceMonitoringQuery) ([]uint, int64, error)
+	GetAllFilteredCustomerIDs(ctx context.Context, filters *validation.BalanceMonitoringQuery) ([]uint, error)
+	GetSaldoAwalLifetime(ctx context.Context, customerIDs []uint) (map[uint]float64, error)
+	GetSalesTotalsBeforeDate(ctx context.Context, customerIDs []uint, filters *validation.BalanceMonitoringQuery) (map[uint]float64, error)
+	GetPaymentTotalsBeforeDate(ctx context.Context, customerIDs []uint, filters *validation.BalanceMonitoringQuery) (map[uint]float64, error)
+	GetSalesByCategoryInPeriod(ctx context.Context, customerIDs []uint, filters *validation.BalanceMonitoringQuery) (map[uint]BalanceMonitoringCategoryRow, error)
+	GetPaymentTotalsInPeriod(ctx context.Context, customerIDs []uint, filters *validation.BalanceMonitoringQuery) (map[uint]float64, error)
+	GetAgingPerCustomer(ctx context.Context, customerIDs []uint, filters *validation.BalanceMonitoringQuery) (map[uint]BalanceMonitoringAgingRow, error)
+	GetGrandTotals(ctx context.Context, filters *validation.BalanceMonitoringQuery) (BalanceMonitoringGrandTotalsRow, error)
+}
+
+type balanceMonitoringRepositoryImpl struct {
+	db *gorm.DB
+}
+
+func NewBalanceMonitoringRepository(db *gorm.DB) BalanceMonitoringRepository {
+	return &balanceMonitoringRepositoryImpl{db: db}
+}
+
+func resolveBalanceMonitoringDateColumn(filterBy string) string {
+	switch strings.ToLower(strings.TrimSpace(filterBy)) {
+	case "realized_at":
+		return "mdp.delivery_date"
+	case "sold_at", "":
+		return "m.so_date"
+	default:
+		return "m.so_date"
+	}
+}
+
+func resolveBalanceMonitoringDateRange(filters *validation.BalanceMonitoringQuery) (time.Time, time.Time, error) {
+	var startDate time.Time
+	var endDate time.Time
+	var err error
+
+	if strings.TrimSpace(filters.StartDate) != "" {
+		startDate, err = utils.ParseDateString(filters.StartDate)
+		if err != nil {
+			return time.Time{}, time.Time{}, err
+		}
+	} else {
+		startDate = time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC)
+	}
+
+	if strings.TrimSpace(filters.EndDate) != "" {
+		endDate, err = utils.ParseDateString(filters.EndDate)
+		if err != nil {
+			return time.Time{}, time.Time{}, err
+		}
+	} else {
+		endDate = time.Now()
+	}
+
+	return startDate, endDate, nil
+}
+
+func resolveBalanceMonitoringSortClause(filters *validation.BalanceMonitoringQuery) string {
+	direction := "ASC"
+	if strings.EqualFold(strings.TrimSpace(filters.SortOrder), "desc") {
+		direction = "DESC"
+	}
+	switch strings.ToLower(strings.TrimSpace(filters.SortBy)) {
+	case "customer":
+		return "customers.name " + direction
+	default:
+		return "customers.name ASC"
+	}
+}
+
+func (r *balanceMonitoringRepositoryImpl) baseCustomerQuery(ctx context.Context, filters *validation.BalanceMonitoringQuery) *gorm.DB {
+	db := r.db.WithContext(ctx).
+		Model(&entity.Customer{}).
+		Where("customers.deleted_at IS NULL")
+
+	if len(filters.CustomerIDs) > 0 {
+		db = db.Where("customers.id IN ?", filters.CustomerIDs)
+	}
+
+	if len(filters.SalesIDs) > 0 {
+		db = db.Where("EXISTS (SELECT 1 FROM marketings m WHERE m.customer_id = customers.id AND m.deleted_at IS NULL AND m.sales_person_id IN ?)", filters.SalesIDs)
+	}
+
+	if filters.AllowedAreaIDs != nil || filters.AllowedLocationIDs != nil {
+		scopeSub := r.db.WithContext(ctx).
+			Table("marketings m").
+			Select("1").
+			Joins("JOIN marketing_products mp ON mp.marketing_id = m.id").
+			Joins("JOIN marketing_delivery_products mdp ON mdp.marketing_product_id = mp.id").
+			Joins("JOIN product_warehouses pw ON pw.id = mdp.product_warehouse_id").
+			Joins("JOIN warehouses w ON w.id = pw.warehouse_id").
+			Where("m.customer_id = customers.id").
+			Where("m.deleted_at IS NULL").
+			Where("mdp.delivery_date IS NOT NULL")
+
+		if filters.AllowedAreaIDs != nil {
+			if len(filters.AllowedAreaIDs) == 0 {
+				db = db.Where("1 = 0")
+			} else {
+				scopeSub = scopeSub.Where("w.area_id IN ?", filters.AllowedAreaIDs)
+			}
+		}
+		if filters.AllowedLocationIDs != nil {
+			if len(filters.AllowedLocationIDs) == 0 {
+				db = db.Where("1 = 0")
+			} else {
+				scopeSub = scopeSub.Where("w.location_id IN ?", filters.AllowedLocationIDs)
+			}
+		}
+
+		db = db.Where("EXISTS (?)", scopeSub)
+	}
+
+	return db
+}
+
+func (r *balanceMonitoringRepositoryImpl) GetCustomerIDsForBalanceMonitoring(ctx context.Context, offset, limit int, filters *validation.BalanceMonitoringQuery) ([]uint, int64, error) {
+	var total int64
+	if err := r.baseCustomerQuery(ctx, filters).Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+	if total == 0 {
+		return []uint{}, 0, nil
+	}
+
+	if offset < 0 {
+		offset = 0
+	}
+
+	var customerIDs []uint
+	err := r.baseCustomerQuery(ctx, filters).
+		Order(resolveBalanceMonitoringSortClause(filters)).
+		Limit(limit).
+		Offset(offset).
+		Pluck("customers.id", &customerIDs).
+		Error
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return customerIDs, total, nil
+}
+
+func (r *balanceMonitoringRepositoryImpl) GetAllFilteredCustomerIDs(ctx context.Context, filters *validation.BalanceMonitoringQuery) ([]uint, error) {
+	var customerIDs []uint
+	if err := r.baseCustomerQuery(ctx, filters).Pluck("customers.id", &customerIDs).Error; err != nil {
+		return nil, err
+	}
+	return customerIDs, nil
+}
+
+func (r *balanceMonitoringRepositoryImpl) GetSaldoAwalLifetime(ctx context.Context, customerIDs []uint) (map[uint]float64, error) {
+	if len(customerIDs) == 0 {
+		return map[uint]float64{}, nil
+	}
+
+	type row struct {
+		CustomerID uint    `gorm:"column:customer_id"`
+		Total      float64 `gorm:"column:total"`
+	}
+	rows := make([]row, 0)
+	err := r.db.WithContext(ctx).
+		Model(&entity.Payment{}).
+		Select("party_id AS customer_id, COALESCE(SUM(nominal), 0) AS total").
+		Where("party_type = ?", string(utils.PaymentPartyCustomer)).
+		Where("transaction_type = ?", string(utils.TransactionTypeSaldoAwal)).
+		Where("party_id IN ?", customerIDs).
+		Group("party_id").
+		Scan(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+
+	result := make(map[uint]float64, len(rows))
+	for _, r := range rows {
+		result[r.CustomerID] = r.Total
+	}
+	return result, nil
+}
+
+func (r *balanceMonitoringRepositoryImpl) GetSalesTotalsBeforeDate(ctx context.Context, customerIDs []uint, filters *validation.BalanceMonitoringQuery) (map[uint]float64, error) {
+	if len(customerIDs) == 0 {
+		return map[uint]float64{}, nil
+	}
+
+	startDate, _, err := resolveBalanceMonitoringDateRange(filters)
+	if err != nil {
+		return map[uint]float64{}, nil
+	}
+
+	type row struct {
+		CustomerID uint    `gorm:"column:customer_id"`
+		Total      float64 `gorm:"column:total"`
+	}
+	rows := make([]row, 0)
+
+	var db *gorm.DB
+	if strings.ToLower(strings.TrimSpace(filters.FilterBy)) == "realized_at" {
+		// realized_at: gunakan data DO (mdp.total_price), filter by delivery_date < startDate
+		db = r.db.WithContext(ctx).
+			Table("marketing_delivery_products mdp").
+			Select("m.customer_id AS customer_id, COALESCE(SUM(mdp.total_price), 0) AS total").
+			Joins("INNER JOIN marketing_products mp ON mp.id = mdp.marketing_product_id").
+			Joins("INNER JOIN marketings m ON m.id = mp.marketing_id").
+			Where("m.customer_id IN ?", customerIDs).
+			Where("m.deleted_at IS NULL").
+			Where("mdp.delivery_date IS NOT NULL").
+			Where("DATE(mdp.delivery_date) < ?", startDate)
+	} else {
+		// sold_at: SO-date sebelum startDate DAN approval terbaru sudah DO — gunakan data DO (mdp.total_price)
+		db = r.db.WithContext(ctx).
+			Table("marketing_products mp").
+			Select("m.customer_id AS customer_id, COALESCE(SUM(mdp.total_price), 0) AS total").
+			Joins("INNER JOIN marketings m ON m.id = mp.marketing_id").
+			Joins("INNER JOIN marketing_delivery_products mdp ON mdp.marketing_product_id = mp.id").
+			Where("m.customer_id IN ?", customerIDs).
+			Where("m.deleted_at IS NULL").
+			Where("DATE(m.so_date) < ?", startDate).
+			Where("(SELECT step_number FROM approvals WHERE approvable_type = 'MARKETINGS' AND approvable_id = mp.marketing_id ORDER BY id DESC LIMIT 1) >= ?", uint16(utils.MarketingDeliveryOrder))
+	}
+
+	if len(filters.SalesIDs) > 0 {
+		db = db.Where("m.sales_person_id IN ?", filters.SalesIDs)
+	}
+
+	if err := db.Group("m.customer_id").Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+
+	result := make(map[uint]float64, len(rows))
+	for _, rr := range rows {
+		result[rr.CustomerID] = rr.Total
+	}
+	return result, nil
+}
+
+func (r *balanceMonitoringRepositoryImpl) GetPaymentTotalsBeforeDate(ctx context.Context, customerIDs []uint, filters *validation.BalanceMonitoringQuery) (map[uint]float64, error) {
+	if len(customerIDs) == 0 {
+		return map[uint]float64{}, nil
+	}
+
+	startDate, _, err := resolveBalanceMonitoringDateRange(filters)
+	if err != nil {
+		return map[uint]float64{}, nil
+	}
+
+	type row struct {
+		CustomerID uint    `gorm:"column:customer_id"`
+		Total      float64 `gorm:"column:total"`
+	}
+	rows := make([]row, 0)
+	err = r.db.WithContext(ctx).
+		Model(&entity.Payment{}).
+		Select("party_id AS customer_id, COALESCE(SUM(nominal), 0) AS total").
+		Where("party_type = ?", string(utils.PaymentPartyCustomer)).
+		Where("transaction_type = ?", string(utils.TransactionTypePenjualan)).
+		Where("direction = ?", "IN").
+		Where("party_id IN ?", customerIDs).
+		Where("DATE(payment_date) < ?", startDate).
+		Group("party_id").
+		Scan(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+
+	result := make(map[uint]float64, len(rows))
+	for _, rr := range rows {
+		result[rr.CustomerID] = rr.Total
+	}
+	return result, nil
+}
+
+func (r *balanceMonitoringRepositoryImpl) GetSalesByCategoryInPeriod(ctx context.Context, customerIDs []uint, filters *validation.BalanceMonitoringQuery) (map[uint]BalanceMonitoringCategoryRow, error) {
+	if len(customerIDs) == 0 {
+		return map[uint]BalanceMonitoringCategoryRow{}, nil
+	}
+
+	startDate, endDate, err := resolveBalanceMonitoringDateRange(filters)
+	if err != nil {
+		return map[uint]BalanceMonitoringCategoryRow{}, nil
+	}
+
+	// Gunakan data DO (mdp) bukan SO (mp) agar nominal/qty/kg mencerminkan nilai aktual DO
+	const selectCols = `m.customer_id AS customer_id,
+		COALESCE(SUM(CASE WHEN m.marketing_type IN ('AYAM','AYAM_PULLET') THEN (mdp.usage_qty + mdp.pending_qty) ELSE 0 END), 0) AS ayam_qty,
+		COALESCE(SUM(CASE WHEN m.marketing_type IN ('AYAM','AYAM_PULLET') THEN mdp.total_weight  ELSE 0 END), 0) AS ayam_kg,
+		COALESCE(SUM(CASE WHEN m.marketing_type IN ('AYAM','AYAM_PULLET') THEN mdp.total_price   ELSE 0 END), 0) AS ayam_nominal,
+		COALESCE(SUM(CASE WHEN m.marketing_type = 'TELUR' THEN (mdp.usage_qty + mdp.pending_qty) ELSE 0 END), 0) AS telur_qty,
+		COALESCE(SUM(CASE WHEN m.marketing_type = 'TELUR' THEN mdp.total_weight  ELSE 0 END), 0) AS telur_kg,
+		COALESCE(SUM(CASE WHEN m.marketing_type = 'TELUR' THEN mdp.total_price   ELSE 0 END), 0) AS telur_nominal,
+		COALESCE(SUM(CASE WHEN m.marketing_type = 'TRADING' THEN (mdp.usage_qty + mdp.pending_qty) ELSE 0 END), 0) AS trading_qty,
+		COALESCE(SUM(CASE WHEN m.marketing_type = 'TRADING' THEN mdp.total_weight  ELSE 0 END), 0) AS trading_kg,
+		COALESCE(SUM(CASE WHEN m.marketing_type = 'TRADING' THEN mdp.total_price   ELSE 0 END), 0) AS trading_nominal`
+
+	rows := make([]BalanceMonitoringCategoryRow, 0)
+
+	var db *gorm.DB
+	if strings.ToLower(strings.TrimSpace(filters.FilterBy)) == "realized_at" {
+		// realized_at: FROM mdp langsung, filter by delivery_date in period — data DO
+		db = r.db.WithContext(ctx).
+			Table("marketing_delivery_products mdp").
+			Select(selectCols).
+			Joins("INNER JOIN marketing_products mp ON mp.id = mdp.marketing_product_id").
+			Joins("INNER JOIN marketings m ON m.id = mp.marketing_id").
+			Where("m.customer_id IN ?", customerIDs).
+			Where("m.deleted_at IS NULL").
+			Where("mdp.delivery_date IS NOT NULL").
+			Where("DATE(mdp.delivery_date) >= ?", startDate).
+			Where("DATE(mdp.delivery_date) <= ?", endDate)
+	} else {
+		// sold_at: SO-date dalam period DAN approval terbaru DO — JOIN mdp untuk data DO
+		db = r.db.WithContext(ctx).
+			Table("marketing_products mp").
+			Select(selectCols).
+			Joins("INNER JOIN marketings m ON m.id = mp.marketing_id").
+			Joins("INNER JOIN marketing_delivery_products mdp ON mdp.marketing_product_id = mp.id").
+			Where("m.customer_id IN ?", customerIDs).
+			Where("m.deleted_at IS NULL").
+			Where("DATE(m.so_date) >= ?", startDate).
+			Where("DATE(m.so_date) <= ?", endDate).
+			Where("(SELECT step_number FROM approvals WHERE approvable_type = 'MARKETINGS' AND approvable_id = mp.marketing_id ORDER BY id DESC LIMIT 1) >= ?", uint16(utils.MarketingDeliveryOrder))
+	}
+
+	if len(filters.SalesIDs) > 0 {
+		db = db.Where("m.sales_person_id IN ?", filters.SalesIDs)
+	}
+
+	if err := db.Group("m.customer_id").Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+
+	result := make(map[uint]BalanceMonitoringCategoryRow, len(rows))
+	for _, rr := range rows {
+		result[rr.CustomerID] = rr
+	}
+	return result, nil
+}
+
+func (r *balanceMonitoringRepositoryImpl) GetPaymentTotalsInPeriod(ctx context.Context, customerIDs []uint, filters *validation.BalanceMonitoringQuery) (map[uint]float64, error) {
+	if len(customerIDs) == 0 {
+		return map[uint]float64{}, nil
+	}
+
+	startDate, endDate, err := resolveBalanceMonitoringDateRange(filters)
+	if err != nil {
+		return map[uint]float64{}, nil
+	}
+
+	type row struct {
+		CustomerID uint    `gorm:"column:customer_id"`
+		Total      float64 `gorm:"column:total"`
+	}
+	rows := make([]row, 0)
+	err = r.db.WithContext(ctx).
+		Model(&entity.Payment{}).
+		Select("party_id AS customer_id, COALESCE(SUM(nominal), 0) AS total").
+		Where("party_type = ?", string(utils.PaymentPartyCustomer)).
+		Where("transaction_type = ?", string(utils.TransactionTypePenjualan)).
+		Where("direction = ?", "IN").
+		Where("party_id IN ?", customerIDs).
+		Where("DATE(payment_date) >= ?", startDate).
+		Where("DATE(payment_date) <= ?", endDate).
+		Group("party_id").
+		Scan(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+
+	result := make(map[uint]float64, len(rows))
+	for _, rr := range rows {
+		result[rr.CustomerID] = rr.Total
+	}
+	return result, nil
+}
+
+func (r *balanceMonitoringRepositoryImpl) GetAgingPerCustomer(ctx context.Context, customerIDs []uint, filters *validation.BalanceMonitoringQuery) (map[uint]BalanceMonitoringAgingRow, error) {
+	if len(customerIDs) == 0 {
+		return map[uint]BalanceMonitoringAgingRow{}, nil
+	}
+
+	startDate, endDate, err := resolveBalanceMonitoringDateRange(filters)
+	if err != nil {
+		return map[uint]BalanceMonitoringAgingRow{}, nil
+	}
+
+	dateColumn := resolveBalanceMonitoringDateColumn(filters.FilterBy)
+
+	rows := make([]BalanceMonitoringAgingRow, 0)
+	db := r.db.WithContext(ctx).
+		Table("marketing_delivery_products mdp").
+		Select(`m.customer_id AS customer_id,
+			COALESCE(MAX(GREATEST(CURRENT_DATE - DATE(mdp.delivery_date), 0)), 0) AS aging_max,
+			COALESCE(
+				SUM(mdp.total_price * GREATEST(CURRENT_DATE - DATE(mdp.delivery_date), 0))::numeric
+				/ NULLIF(SUM(mdp.total_price), 0),
+				0
+			)::numeric(15,2) AS aging_rata_rata`).
+		Joins("INNER JOIN marketing_products mp ON mp.id = mdp.marketing_product_id").
+		Joins("INNER JOIN marketings m ON m.id = mp.marketing_id").
+		Where("m.customer_id IN ?", customerIDs).
+		Where("m.deleted_at IS NULL").
+		Where("mdp.delivery_date IS NOT NULL").
+		Where(fmt.Sprintf("DATE(%s) >= ?", dateColumn), startDate).
+		Where(fmt.Sprintf("DATE(%s) <= ?", dateColumn), endDate)
+
+	if len(filters.SalesIDs) > 0 {
+		db = db.Where("m.sales_person_id IN ?", filters.SalesIDs)
+	}
+
+	if err := db.Group("m.customer_id").Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+
+	result := make(map[uint]BalanceMonitoringAgingRow, len(rows))
+	for _, rr := range rows {
+		result[rr.CustomerID] = rr
+	}
+	return result, nil
+}
+
+func (r *balanceMonitoringRepositoryImpl) GetGrandTotals(ctx context.Context, filters *validation.BalanceMonitoringQuery) (BalanceMonitoringGrandTotalsRow, error) {
+	customerIDs, err := r.GetAllFilteredCustomerIDs(ctx, filters)
+	if err != nil {
+		return BalanceMonitoringGrandTotalsRow{}, err
+	}
+	if len(customerIDs) == 0 {
+		return BalanceMonitoringGrandTotalsRow{}, nil
+	}
+
+	saldoAwalLifetimeMap, err := r.GetSaldoAwalLifetime(ctx, customerIDs)
+	if err != nil {
+		return BalanceMonitoringGrandTotalsRow{}, err
+	}
+	salesBeforeMap, err := r.GetSalesTotalsBeforeDate(ctx, customerIDs, filters)
+	if err != nil {
+		return BalanceMonitoringGrandTotalsRow{}, err
+	}
+	paymentBeforeMap, err := r.GetPaymentTotalsBeforeDate(ctx, customerIDs, filters)
+	if err != nil {
+		return BalanceMonitoringGrandTotalsRow{}, err
+	}
+	categoryMap, err := r.GetSalesByCategoryInPeriod(ctx, customerIDs, filters)
+	if err != nil {
+		return BalanceMonitoringGrandTotalsRow{}, err
+	}
+	paymentInPeriodMap, err := r.GetPaymentTotalsInPeriod(ctx, customerIDs, filters)
+	if err != nil {
+		return BalanceMonitoringGrandTotalsRow{}, err
+	}
+	agingMap, err := r.GetAgingPerCustomer(ctx, customerIDs, filters)
+	if err != nil {
+		return BalanceMonitoringGrandTotalsRow{}, err
+	}
+
+	totals := BalanceMonitoringGrandTotalsRow{}
+	for _, total := range saldoAwalLifetimeMap {
+		totals.SaldoAwalLifetime += total
+	}
+	for _, total := range salesBeforeMap {
+		totals.SalesBeforeStart += total
+	}
+	for _, total := range paymentBeforeMap {
+		totals.PaymentBeforeStart += total
+	}
+	for _, cat := range categoryMap {
+		totals.AyamQty += cat.AyamQty
+		totals.AyamKg += cat.AyamKg
+		totals.AyamNominal += cat.AyamNominal
+		totals.TelurQty += cat.TelurQty
+		totals.TelurKg += cat.TelurKg
+		totals.TelurNominal += cat.TelurNominal
+		totals.TradingQty += cat.TradingQty
+		totals.TradingKg += cat.TradingKg
+		totals.TradingNominal += cat.TradingNominal
+	}
+	for _, total := range paymentInPeriodMap {
+		totals.PaymentInPeriod += total
+	}
+
+	for _, aging := range agingMap {
+		totals.AgingMax += aging.AgingMax
+	}
+
+	weightedSum := 0.0
+	weightTotal := 0.0
+	for cid, cat := range categoryMap {
+		nominal := cat.AyamNominal + cat.TelurNominal + cat.TradingNominal
+		if aging, ok := agingMap[cid]; ok && nominal > 0 {
+			weightedSum += nominal * aging.AgingRataRata
+			weightTotal += nominal
+		}
+	}
+	if weightTotal > 0 {
+		totals.AgingRataRata = weightedSum / weightTotal
+	}
+
+	return totals, nil
+}

internal/modules/repports/repositories/customer_payment.repository.go

@@ -2,7 +2,7 @@ package repositories
 
 import (
 	"context"
-
+	"strings"
 	"time"
 
 	"gorm.io/gorm"
@@ -30,7 +30,7 @@ type CustomerPaymentTransaction struct {
 type CustomerPaymentRepository interface {
 	GetCustomerPaymentTransactions(ctx context.Context, customerID *uint) ([]CustomerPaymentTransaction, error)
 	GetInitialBalanceByCustomer(ctx context.Context, customerID uint) (float64, error)
-	GetCustomerIDsWithTransactions(ctx context.Context, limit, offset int, allowedCustomerIDs []uint) ([]uint, int64, error)
+	GetCustomerIDsWithTransactions(ctx context.Context, limit, offset int, allowedCustomerIDs []uint, sortBy, sortOrder string) ([]uint, int64, error)
 }
 
 type customerPaymentRepositoryImpl struct {
@@ -146,21 +146,34 @@ func (r *customerPaymentRepositoryImpl) GetInitialBalanceByCustomer(ctx context.
 	return result.Nominal, nil
 }
 
-func (r *customerPaymentRepositoryImpl) GetCustomerIDsWithTransactions(ctx context.Context, limit, offset int, allowedCustomerIDs []uint) ([]uint, int64, error) {
+func resolveCustomerPaymentSortClause(sortBy, sortOrder string) string {
-	subQuery := r.db.WithContext(ctx).
+	direction := "ASC"
-		Table("(" +
+	if strings.EqualFold(strings.TrimSpace(sortOrder), "desc") {
-			"SELECT DISTINCT c.id as customer_id FROM marketing_delivery_products mdp " +
+		direction = "DESC"
+	}
+	switch strings.ToLower(strings.TrimSpace(sortBy)) {
+	case "customer":
+		return "customer_name " + direction
+	default:
+		return "customer_name ASC"
+	}
+}
+
+func (r *customerPaymentRepositoryImpl) GetCustomerIDsWithTransactions(ctx context.Context, limit, offset int, allowedCustomerIDs []uint, sortBy, sortOrder string) ([]uint, int64, error) {
+	unionSQL := "(" +
+		"SELECT DISTINCT c.id as customer_id, c.name as customer_name FROM marketing_delivery_products mdp " +
 		"INNER JOIN marketing_products mp ON mp.id = mdp.marketing_product_id " +
 		"INNER JOIN marketings m ON m.id = mp.marketing_id " +
 		"INNER JOIN customers c ON c.id = m.customer_id " +
 		"WHERE mdp.delivery_date IS NOT NULL AND m.deleted_at IS NULL AND c.deleted_at IS NULL " +
 		"UNION " +
-			"SELECT DISTINCT c.id as customer_id FROM payments p " +
+		"SELECT DISTINCT c.id as customer_id, c.name as customer_name FROM payments p " +
 		"INNER JOIN customers c ON c.id = p.party_id " +
 		"WHERE p.party_type = 'CUSTOMER' AND p.direction = 'IN' " +
 		"AND p.transaction_type = 'PENJUALAN' AND p.deleted_at IS NULL AND c.deleted_at IS NULL" +
-			") as customer_ids")
+		") as customer_ids"
 
+	subQuery := r.db.WithContext(ctx).Table(unionSQL)
 	if len(allowedCustomerIDs) > 0 {
 		subQuery = subQuery.Where("customer_id IN ?", allowedCustomerIDs)
 	}
@@ -170,28 +183,14 @@ func (r *customerPaymentRepositoryImpl) GetCustomerIDsWithTransactions(ctx conte
 		return nil, 0, err
 	}
 
-	var customerIDs []uint
+	query := r.db.WithContext(ctx).Table(unionSQL).Select("customer_id")
-	query := r.db.WithContext(ctx).
-		Table("(" +
-			"SELECT DISTINCT c.id as customer_id FROM marketing_delivery_products mdp " +
-			"INNER JOIN marketing_products mp ON mp.id = mdp.marketing_product_id " +
-			"INNER JOIN marketings m ON m.id = mp.marketing_id " +
-			"INNER JOIN customers c ON c.id = m.customer_id " +
-			"WHERE mdp.delivery_date IS NOT NULL AND m.deleted_at IS NULL AND c.deleted_at IS NULL " +
-			"UNION " +
-			"SELECT DISTINCT c.id as customer_id FROM payments p " +
-			"INNER JOIN customers c ON c.id = p.party_id " +
-			"WHERE p.party_type = 'CUSTOMER' AND p.direction = 'IN' " +
-			"AND p.transaction_type = 'PENJUALAN' AND p.deleted_at IS NULL AND c.deleted_at IS NULL" +
-			") as customer_ids").
-		Select("customer_id")
-
 	if len(allowedCustomerIDs) > 0 {
 		query = query.Where("customer_id IN ?", allowedCustomerIDs)
 	}
 
+	var customerIDs []uint
 	err := query.
-		Order("customer_id ASC").
+		Order(resolveCustomerPaymentSortClause(sortBy, sortOrder)).
 		Limit(limit).
 		Offset(offset).
 		Pluck("customer_id", &customerIDs).

internal/modules/repports/repositories/debt_supplier.repository.go

@@ -15,13 +15,16 @@ import (
 
 type DebtSupplierRepository interface {
 	GetSuppliersWithPurchases(ctx context.Context, offset, limit int, filters *validation.DebtSupplierQuery) ([]entity.Supplier, int64, error)
+	GetSuppliersWithDebts(ctx context.Context, offset, limit int, filters *validation.DebtSupplierQuery) ([]entity.Supplier, int64, error)
 	GetPurchasesBySuppliers(ctx context.Context, supplierIDs []uint, filters *validation.DebtSupplierQuery) ([]entity.Purchase, error)
+	GetExpensesBySuppliers(ctx context.Context, supplierIDs []uint, filters *validation.DebtSupplierQuery) ([]entity.Expense, error)
 	GetPaymentsBySuppliers(ctx context.Context, supplierIDs []uint, filters *validation.DebtSupplierQuery) ([]entity.Payment, error)
 	GetPaymentTotalsByReferences(ctx context.Context, supplierIDs []uint, references []string) (map[string]float64, error)
 	GetPaymentSummariesByReferences(ctx context.Context, supplierIDs []uint, references []string) (map[string]PaymentReferenceSummary, error)
 	GetInitialBalanceTotals(ctx context.Context, supplierIDs []uint) (map[uint]float64, error)
 	GetPurchaseTotalsBeforeDate(ctx context.Context, supplierIDs []uint, filters *validation.DebtSupplierQuery) (map[uint]float64, error)
 	GetPaymentTotalsBeforeDate(ctx context.Context, supplierIDs []uint, filters *validation.DebtSupplierQuery) (map[uint]float64, error)
+	GetExpenseTotalsBeforeDate(ctx context.Context, supplierIDs []uint, filters *validation.DebtSupplierQuery) (map[uint]float64, error)
 }
 
 type debtSupplierRepositoryImpl struct {
@@ -52,6 +55,19 @@ func (r *debtSupplierRepositoryImpl) latestPurchaseApproval(ctx context.Context)
 		)
 }
 
+func resolveDebtSupplierSortClause(filters *validation.DebtSupplierQuery) string {
+	direction := "ASC"
+	if strings.EqualFold(strings.TrimSpace(filters.SortOrder), "desc") {
+		direction = "DESC"
+	}
+	switch strings.ToLower(strings.TrimSpace(filters.SortBy)) {
+	case "supplier":
+		return "suppliers.name " + direction
+	default:
+		return "suppliers.name ASC"
+	}
+}
+
 func resolveDebtSupplierDateColumn(filterBy string) string {
 	switch strings.ToLower(strings.TrimSpace(filterBy)) {
 	case "po_date":
@@ -129,15 +145,24 @@ func (r *debtSupplierRepositoryImpl) GetSuppliersWithPurchases(ctx context.Conte
 		offset = 0
 	}
 
-	var supplierIDs []uint
+	type supplierIDResult struct {
-	if err := query.
+		ID   uint   `gorm:"column:id"`
-		Select("suppliers.id").
+		Name string `gorm:"column:name"`
-		Order("suppliers.id ASC").
+	}
+	var idResults []supplierIDResult
+	if err := r.baseSupplierQuery(ctx, filters).
+		Select("suppliers.id, suppliers.name").
+		Group("suppliers.id, suppliers.name").
+		Order(resolveDebtSupplierSortClause(filters)).
 		Offset(offset).
 		Limit(limit).
-		Pluck("suppliers.id", &supplierIDs).Error; err != nil {
+		Scan(&idResults).Error; err != nil {
 		return nil, 0, err
 	}
+	supplierIDs := make([]uint, 0, len(idResults))
+	for _, r := range idResults {
+		supplierIDs = append(supplierIDs, r.ID)
+	}
 
 	if len(supplierIDs) == 0 {
 		return []entity.Supplier{}, totalSuppliers, nil
@@ -146,6 +171,7 @@ func (r *debtSupplierRepositoryImpl) GetSuppliersWithPurchases(ctx context.Conte
 	var suppliers []entity.Supplier
 	if err := r.db.WithContext(ctx).
 		Where("id IN ?", supplierIDs).
+		Order(resolveDebtSupplierSortClause(filters)).
 		Find(&suppliers).Error; err != nil {
 		return nil, 0, err
 	}
@@ -467,3 +493,218 @@ func (r *debtSupplierRepositoryImpl) GetPaymentTotalsBeforeDate(ctx context.Cont
 
 	return result, nil
 }
+
+func (r *debtSupplierRepositoryImpl) latestExpenseApproval(ctx context.Context) *gorm.DB {
+	return r.db.WithContext(ctx).
+		Table("approvals AS a").
+		Select("a.approvable_id, a.step_number, a.action").
+		Joins(`
+			JOIN (
+				SELECT approvable_id, MAX(action_at) AS latest_action_at
+				FROM approvals
+				WHERE approvable_type = ?
+				GROUP BY approvable_id
+			) AS la ON la.approvable_id = a.approvable_id AND la.latest_action_at = a.action_at`,
+			string(utils.ApprovalWorkflowExpense),
+		)
+}
+
+func (r *debtSupplierRepositoryImpl) baseExpenseSupplierIDs(ctx context.Context, filters *validation.DebtSupplierQuery) *gorm.DB {
+	db := r.db.WithContext(ctx).
+		Table("expenses").
+		Select("DISTINCT expenses.supplier_id").
+		Joins("JOIN (?) AS la ON la.approvable_id = expenses.id", r.latestExpenseApproval(ctx)).
+		Where("la.step_number >= ?", uint16(utils.ExpenseStepRealisasi)).
+		Where("(la.action IS NULL OR la.action != ?)", string(entity.ApprovalActionRejected)).
+		Where("expenses.deleted_at IS NULL")
+
+	if len(filters.SupplierIDs) > 0 {
+		db = db.Where("expenses.supplier_id IN ?", filters.SupplierIDs)
+	}
+
+	if filters.AllowedLocationIDs != nil {
+		if len(filters.AllowedLocationIDs) == 0 {
+			db = db.Where("1 = 0")
+		} else {
+			db = db.Where("expenses.location_id IN ?", filters.AllowedLocationIDs)
+		}
+	}
+
+	if filters.AllowedAreaIDs != nil {
+		if len(filters.AllowedAreaIDs) == 0 {
+			db = db.Where("1 = 0")
+		} else {
+			db = db.Joins("JOIN locations exp_loc ON exp_loc.id = expenses.location_id").
+				Where("exp_loc.area_id IN ?", filters.AllowedAreaIDs)
+		}
+	}
+
+	if filters.StartDate != "" {
+		if dateFrom, err := utils.ParseDateString(filters.StartDate); err == nil {
+			db = db.Where("DATE(expenses.transaction_date) >= ?", dateFrom)
+		}
+	}
+
+	if filters.EndDate != "" {
+		if dateTo, err := utils.ParseDateString(filters.EndDate); err == nil {
+			db = db.Where("DATE(expenses.transaction_date) <= ?", dateTo)
+		}
+	}
+
+	return db
+}
+
+func (r *debtSupplierRepositoryImpl) GetSuppliersWithDebts(ctx context.Context, offset, limit int, filters *validation.DebtSupplierQuery) ([]entity.Supplier, int64, error) {
+	purchaseSubquery := r.baseSupplierQuery(ctx, filters).
+		Select("suppliers.id")
+
+	expenseSubquery := r.baseExpenseSupplierIDs(ctx, filters)
+
+	db := r.db.WithContext(ctx).
+		Model(&entity.Supplier{}).
+		Where("suppliers.id IN (? UNION ?) AND suppliers.deleted_at IS NULL",
+			purchaseSubquery, expenseSubquery)
+
+	var totalSuppliers int64
+	if err := db.Distinct("suppliers.id").Count(&totalSuppliers).Error; err != nil {
+		return nil, 0, err
+	}
+	if totalSuppliers == 0 {
+		return []entity.Supplier{}, 0, nil
+	}
+
+	if offset < 0 {
+		offset = 0
+	}
+
+	type supplierIDResult struct {
+		ID   uint   `gorm:"column:id"`
+		Name string `gorm:"column:name"`
+	}
+	var idResults []supplierIDResult
+	if err := r.db.WithContext(ctx).
+		Model(&entity.Supplier{}).
+		Where("suppliers.id IN (? UNION ?) AND suppliers.deleted_at IS NULL",
+			purchaseSubquery, expenseSubquery).
+		Select("suppliers.id, suppliers.name").
+		Group("suppliers.id, suppliers.name").
+		Order(resolveDebtSupplierSortClause(filters)).
+		Offset(offset).
+		Limit(limit).
+		Scan(&idResults).Error; err != nil {
+		return nil, 0, err
+	}
+
+	supplierIDs := make([]uint, 0, len(idResults))
+	for _, r := range idResults {
+		supplierIDs = append(supplierIDs, r.ID)
+	}
+	if len(supplierIDs) == 0 {
+		return []entity.Supplier{}, totalSuppliers, nil
+	}
+
+	var suppliers []entity.Supplier
+	if err := r.db.WithContext(ctx).
+		Where("id IN ?", supplierIDs).
+		Order(resolveDebtSupplierSortClause(filters)).
+		Find(&suppliers).Error; err != nil {
+		return nil, 0, err
+	}
+
+	return suppliers, totalSuppliers, nil
+}
+
+func (r *debtSupplierRepositoryImpl) GetExpensesBySuppliers(ctx context.Context, supplierIDs []uint, filters *validation.DebtSupplierQuery) ([]entity.Expense, error) {
+	if len(supplierIDs) == 0 {
+		return []entity.Expense{}, nil
+	}
+
+	db := r.db.WithContext(ctx).
+		Model(&entity.Expense{}).
+		Joins("JOIN (?) AS la ON la.approvable_id = expenses.id", r.latestExpenseApproval(ctx)).
+		Where("expenses.supplier_id IN ?", supplierIDs).
+		Where("la.step_number >= ?", uint16(utils.ExpenseStepRealisasi)).
+		Where("(la.action IS NULL OR la.action != ?)", string(entity.ApprovalActionRejected)).
+		Where("expenses.deleted_at IS NULL")
+
+	if filters.AllowedLocationIDs != nil {
+		if len(filters.AllowedLocationIDs) == 0 {
+			db = db.Where("1 = 0")
+		} else {
+			db = db.Where("expenses.location_id IN ?", filters.AllowedLocationIDs)
+		}
+	}
+
+	if filters.AllowedAreaIDs != nil {
+		if len(filters.AllowedAreaIDs) == 0 {
+			db = db.Where("1 = 0")
+		} else {
+			db = db.Joins("JOIN locations exp_loc ON exp_loc.id = expenses.location_id").
+				Where("exp_loc.area_id IN ?", filters.AllowedAreaIDs)
+		}
+	}
+
+	if filters.StartDate != "" {
+		if dateFrom, err := utils.ParseDateString(filters.StartDate); err == nil {
+			db = db.Where("DATE(expenses.transaction_date) >= ?", dateFrom)
+		}
+	}
+
+	if filters.EndDate != "" {
+		if dateTo, err := utils.ParseDateString(filters.EndDate); err == nil {
+			db = db.Where("DATE(expenses.transaction_date) <= ?", dateTo)
+		}
+	}
+
+	var expenses []entity.Expense
+	if err := db.
+		Preload("Supplier").
+		Preload("Nonstocks").
+		Preload("Location").
+		Preload("Location.Area").
+		Order("expenses.transaction_date ASC, expenses.id ASC").
+		Find(&expenses).Error; err != nil {
+		return nil, err
+	}
+
+	return expenses, nil
+}
+
+func (r *debtSupplierRepositoryImpl) GetExpenseTotalsBeforeDate(ctx context.Context, supplierIDs []uint, filters *validation.DebtSupplierQuery) (map[uint]float64, error) {
+	if len(supplierIDs) == 0 || strings.TrimSpace(filters.StartDate) == "" {
+		return map[uint]float64{}, nil
+	}
+
+	dateFrom, err := utils.ParseDateString(filters.StartDate)
+	if err != nil {
+		return map[uint]float64{}, nil
+	}
+
+	type expenseTotalRow struct {
+		SupplierID uint    `gorm:"column:supplier_id"`
+		Total      float64 `gorm:"column:total"`
+	}
+
+	rows := make([]expenseTotalRow, 0)
+	if err := r.db.WithContext(ctx).
+		Table("expenses").
+		Select("expenses.supplier_id AS supplier_id, SUM(en.qty * en.price) AS total").
+		Joins("JOIN expense_nonstocks en ON en.expense_id = expenses.id").
+		Joins("JOIN (?) AS la ON la.approvable_id = expenses.id", r.latestExpenseApproval(ctx)).
+		Where("expenses.supplier_id IN ?", supplierIDs).
+		Where("la.step_number >= ?", uint16(utils.ExpenseStepRealisasi)).
+		Where("(la.action IS NULL OR la.action != ?)", string(entity.ApprovalActionRejected)).
+		Where("expenses.deleted_at IS NULL").
+		Where("DATE(expenses.transaction_date) < ?", dateFrom).
+		Group("expenses.supplier_id").
+		Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+
+	result := make(map[uint]float64, len(rows))
+	for _, row := range rows {
+		result[row.SupplierID] = row.Total
+	}
+
+	return result, nil
+}

internal/modules/repports/repositories/expense_depreciation.repository.go

@@ -37,10 +37,10 @@ type FarmDepreciationManualInputRow struct {
 	Note           *string
 }
 
-type houseDepreciationPercentRow struct {
+type houseMultiplicationPercentageRow struct {
 	HouseType                string
 	Day                      int
-	DepreciationPercent float64
+	MultiplicationPercentage float64
 }
 
 type ExpenseDepreciationRepository interface {
@@ -48,8 +48,9 @@ type ExpenseDepreciationRepository interface {
 	GetSnapshotsByPeriodAndFarmIDs(ctx context.Context, period time.Time, farmIDs []uint) ([]entity.FarmDepreciationSnapshot, error)
 	UpsertSnapshots(ctx context.Context, rows []entity.FarmDepreciationSnapshot) error
 	DeleteSnapshotsFromDate(ctx context.Context, fromDate time.Time, farmIDs []uint) error
+	DeleteSnapshotsByFarmIDs(ctx context.Context, farmIDs []uint) error
 	GetLatestTransferInputsByFarms(ctx context.Context, period time.Time, farmIDs []uint) ([]FarmDepreciationLatestTransferRow, error)
-	GetDepreciationPercents(ctx context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, error)
+	GetMultiplicationPercentages(ctx context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, error)
 	GetLatestManualInputsByFarms(ctx context.Context, areaIDs, locationIDs, projectFlockIDs []int64) ([]FarmDepreciationManualInputRow, error)
 	UpsertManualInput(ctx context.Context, row *entity.FarmDepreciationManualInput) error
 	DB() *gorm.DB
@@ -159,6 +160,17 @@ func (r *expenseDepreciationRepository) DeleteSnapshotsFromDate(
 	return query.Delete(nil).Error
 }
 
+func (r *expenseDepreciationRepository) DeleteSnapshotsByFarmIDs(ctx context.Context, farmIDs []uint) error {
+	if len(farmIDs) == 0 {
+		return nil
+	}
+
+	return r.db.WithContext(ctx).
+		Table("farm_depreciation_snapshots").
+		Where("project_flock_id IN ?", farmIDs).
+		Delete(nil).Error
+}
+
 func (r *expenseDepreciationRepository) GetLatestTransferInputsByFarms(
 	ctx context.Context,
 	period time.Time,
@@ -228,7 +240,7 @@ ORDER BY ltt.target_project_flock_kandang_id, at.effective_date DESC, at.id DESC
 	return rows, nil
 }
 
-func (r *expenseDepreciationRepository) GetDepreciationPercents(
+func (r *expenseDepreciationRepository) GetMultiplicationPercentages(
 	ctx context.Context,
 	houseTypes []string,
 	maxDay int,
@@ -238,14 +250,14 @@ func (r *expenseDepreciationRepository) GetDepreciationPercents(
 		return result, nil
 	}
 
-	rows := make([]houseDepreciationPercentRow, 0)
+	rows := make([]houseMultiplicationPercentageRow, 0)
-	if err := r.db.WithContext(ctx).
+	if err := r.db.WithContext(ctx).Raw(`
-		Table("house_depreciation_standards").
+		SELECT DISTINCT ON (house_type::text, day)
-		Select("house_type::text AS house_type, day, depreciation_percent").
+			house_type::text AS house_type, day, multiplication_percentage
-		Where("house_type::text IN ?", houseTypes).
+		FROM house_depreciation_standards
-		Where("day <= ?", maxDay).
+		WHERE house_type::text IN ? AND day <= ?
-		Order("house_type ASC, day ASC").
+		ORDER BY house_type, day, effective_date DESC NULLS LAST
-		Scan(&rows).Error; err != nil {
+	`, houseTypes, maxDay).Scan(&rows).Error; err != nil {
 		return nil, err
 	}
 
@@ -253,7 +265,7 @@ func (r *expenseDepreciationRepository) GetDepreciationPercents(
 		if _, exists := result[row.HouseType]; !exists {
 			result[row.HouseType] = make(map[int]float64)
 		}
-		result[row.HouseType][row.Day] = row.DepreciationPercent
+		result[row.HouseType][row.Day] = row.MultiplicationPercentage
 	}
 
 	return result, nil