autosync_backend2 1.2.18 → 1.2.19

package/dist/index.d.ts

@@ -6411,6 +6411,70 @@ export declare const app: Elysia<"", {
                     };
                 };
             };
+        } & {
+            inspection: {
+                admin: {
+                    get: {
+                        body: {};
+                        params: {};
+                        query: {
+                            companyId?: string | undefined;
+                            pagination: {
+                                size: number;
+                                page: number;
+                            };
+                        };
+                        headers: {};
+                        response: {
+                            200: {
+                                totalCount: number;
+                                totalPage: number;
+                                result: {
+                                    company: {
+                                        id: string;
+                                        name: string;
+                                        serviceName: string;
+                                        logoUrl: string;
+                                    } | null;
+                                    vehicle: {
+                                        licensePlate: string | null;
+                                        vin: string | null;
+                                        model: string | null;
+                                    };
+                                    employee: {
+                                        firstname: string;
+                                        lastname: string;
+                                    } | null;
+                                    inspection: {
+                                        inspection: {
+                                            type: string;
+                                            values: {
+                                                description: string;
+                                                question: string;
+                                                answer: string;
+                                            }[];
+                                        }[] | null;
+                                        createdAt: string;
+                                        expireAt: Date;
+                                        status: "CREATED" | "APPROVED" | "CANCELLED";
+                                    };
+                                    totalCount: number;
+                                }[];
+                            };
+                            401: "Session not found";
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                        };
+                    };
+                };
+            };
         } & {
             inspection: {
                 ":id": {
@@ -7369,6 +7433,177 @@ export declare const app: Elysia<"", {
             product: {};
         };
     };
+} & {
+    api: {
+        fleet: {
+            inspection: {
+                "field-group": {};
+            } & {
+                "field-group": {
+                    get: {
+                        body: {};
+                        params: {};
+                        query: {
+                            name?: string | undefined;
+                            code?: string | undefined;
+                            pagination: {
+                                size: number;
+                                page: number;
+                            };
+                        };
+                        headers: {};
+                        response: {
+                            200: {
+                                totalCount: number;
+                                totalPage: number;
+                                result: {
+                                    totalCount: number;
+                                    code: string | null;
+                                    name: string;
+                                    description: string | null;
+                                    id: string;
+                                    createdAt: string;
+                                    updatedAt: string;
+                                    deletedAt: string | null;
+                                    oldId: number | null;
+                                }[];
+                            };
+                            401: "Session not found";
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                        };
+                    };
+                };
+            } & {
+                "field-group": {
+                    post: {
+                        body: {
+                            code?: string | null | undefined;
+                            oldId?: number | null | undefined;
+                            description?: string | null | undefined;
+                            name: string;
+                        };
+                        params: {};
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                        };
+                    };
+                };
+            } & {
+                "field-group": {
+                    ":id": {
+                        put: {
+                            body: {
+                                name?: string | undefined;
+                                code?: string | null | undefined;
+                                oldId?: number | null | undefined;
+                                description?: string | null | undefined;
+                            };
+                            params: {
+                                id: string;
+                            };
+                            query: unknown;
+                            headers: unknown;
+                            response: {
+                                422: {
+                                    type: "validation";
+                                    on: string;
+                                    summary?: string;
+                                    message?: string;
+                                    found?: unknown;
+                                    property?: string;
+                                    expected?: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                "field-group": {
+                    ":id": {
+                        delete: {
+                            body: unknown;
+                            params: {
+                                id: string;
+                            };
+                            query: unknown;
+                            headers: unknown;
+                            response: {
+                                422: {
+                                    type: "validation";
+                                    on: string;
+                                    summary?: string;
+                                    message?: string;
+                                    found?: unknown;
+                                    property?: string;
+                                    expected?: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                "field-group": {
+                    ":id": {
+                        field: {
+                            get: {
+                                body: unknown;
+                                params: {
+                                    id: string;
+                                };
+                                query: unknown;
+                                headers: unknown;
+                                response: {
+                                    200: {
+                                        groupId: string;
+                                        code: string | null;
+                                        description: string | null;
+                                        version: string | null;
+                                        isActive: boolean;
+                                        metadata: unknown;
+                                        required: boolean;
+                                        fieldGroup: string | null;
+                                        sortIndex: number | null;
+                                        id: string;
+                                        createdAt: string;
+                                        updatedAt: string;
+                                        deletedAt: string | null;
+                                        oldId: number | null;
+                                    }[];
+                                    422: {
+                                        type: "validation";
+                                        on: string;
+                                        summary?: string;
+                                        message?: string;
+                                        found?: unknown;
+                                        property?: string;
+                                        expected?: string;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
 }, {
     derive: {};
     resolve: {};

package/dist/index.js

@@ -150110,7 +150110,12 @@ var CrmVehicleLogic;
       yearImport: new Date(atutData.imported_date).getFullYear(),
       engineCode: atutData.engine_model_name
     };
-    const [result] = await tdb.insert(crmVehicleTable).values(insertData).returning();
+    const [result] = await tdb.insert(crmVehicleTable).values(insertData).onConflictDoUpdate({
+      target: crmVehicleTable.vin,
+      set: {
+        licensePlate: insertData.licensePlate
+      }
+    }).returning();
     return result;
   };
   CrmVehicleLogic.select = async (query, user2) => {
@@ -152138,6 +152143,41 @@ var CrmInspectionLogic;
     }).from(crmInspectionTable).where(eq(crmInspectionTable.licensePlate, licensePlate)).leftJoin(companyCompanyTable, eq(companyCompanyTable.id, crmInspectionTable.companyId)).leftJoin(crmVehicleTable, eq(crmVehicleTable.id, crmInspectionTable.vehicleId)).leftJoin(techdocVehicleKindTable, eq(techdocVehicleKindTable.id, crmVehicleTable.vehicleKindId)).leftJoin(companyEmployeeTable, eq(companyEmployeeTable.id, crmInspectionTable.employeeId)).orderBy(desc(crmInspectionTable.createdAt));
     return inspections;
   };
+  CrmInspectionLogic.selectAdmin = async (query) => {
+    const baseQuery = db_default.select({
+      company: {
+        id: companyCompanyTable.id,
+        name: companyCompanyTable.name,
+        serviceName: companyCompanyTable.serviceName,
+        logoUrl: companyCompanyTable.logoUrl
+      },
+      vehicle: {
+        licensePlate: crmVehicleTable.licensePlate,
+        vin: crmVehicleTable.vin,
+        model: techdocVehicleKindTable.name
+      },
+      employee: {
+        firstname: companyEmployeeTable.firstname,
+        lastname: companyEmployeeTable.lastname
+      },
+      inspection: {
+        inspection: crmInspectionTable.inspection,
+        createdAt: crmInspectionTable.createdAt,
+        expireAt: crmInspectionTable.expireAt,
+        status: crmInspectionTable.status
+      },
+      totalCount: totalCountSql
+    }).from(crmInspectionTable).where(eq(crmInspectionTable.companyId, query.companyId).if(query.companyId)).leftJoin(companyCompanyTable, eq(companyCompanyTable.id, crmInspectionTable.companyId)).leftJoin(crmVehicleTable, eq(crmVehicleTable.id, crmInspectionTable.vehicleId)).leftJoin(techdocVehicleKindTable, eq(techdocVehicleKindTable.id, crmVehicleTable.vehicleKindId)).leftJoin(companyEmployeeTable, eq(companyEmployeeTable.id, crmInspectionTable.employeeId)).orderBy(desc(crmInspectionTable.createdAt)).$dynamic();
+    const result = await pagination_helper_default(baseQuery, query.pagination);
+    const content = {
+      totalCount: result[0]?.totalCount ?? 0,
+      totalPage: result.length === 0 ? 0 : Math.ceil(result[0].totalCount / query.pagination.size)
+    };
+    return {
+      result,
+      ...content
+    };
+  };
 })(CrmInspectionLogic ||= {});
 var logic_default17 = CrmInspectionLogic;
 
@@ -152170,6 +152210,12 @@ var CrmInspectionModel;
   CrmInspectionModel.selectUbCab = t.Object({
     licensePlate: t.String()
   });
+  CrmInspectionModel.selectAdmin = t.Composite([
+    t.Partial(t.Object({
+      companyId: t.String({ format: "uuid" })
+    })),
+    PaginationSchema
+  ]);
 })(CrmInspectionModel ||= {});
 var model_default13 = CrmInspectionModel;
 
@@ -152184,6 +152230,9 @@ var inspectionRoutes = new Elysia({
   query: model_default13.select
 }).post("/", async ({ body, user: user2 }) => logic_default17.create(body, user2), {
   body: model_default13.create
+}).get("/admin", async ({ query }) => logic_default17.selectAdmin(query), {
+  query: model_default13.selectAdmin,
+  userKind: "ADMIN"
 }).guard({
   params: IdSchema
 }).get("/:id", async ({ params: { id }, user: user2 }) => logic_default17.getById(id, user2)).post("/:id", async ({ params: { id }, user: user2 }) => logic_default17.approve(id, user2)).put("/:id", async ({ params: { id }, user: user2 }) => logic_default17.cancel(id, user2)).post("/:id/service-order", async ({ params: { id }, user: user2 }) => logic_default17.createCpOrder(id, user2));
@@ -153832,10 +153881,110 @@ var warehouseSchemaRoutes = new Elysia({
 }).use(product_default3).use(warehouse_default).use(item_default3);
 var warehouse_default2 = warehouseSchemaRoutes;
 
+// src/routes/fleet/inspection/field/logic.ts
+var InspectionFieldLogic;
+((InspectionFieldLogic) => {
+  InspectionFieldLogic.select = async (groupId) => {
+    const result = await db_default.select().from(inspectionFieldTable).where(eq(inspectionFieldTable.groupId, groupId));
+    return result;
+  };
+  InspectionFieldLogic.create = async (body) => {
+    await db_default.insert(inspectionFieldTable).values(body);
+  };
+  InspectionFieldLogic.update = async (id, body) => {
+    await db_default.update(inspectionFieldTable).set(body).where(eq(inspectionFieldTable.id, id));
+  };
+  InspectionFieldLogic.remove = async (id) => {
+    await db_default.update(inspectionFieldTable).set({
+      deletedAt: sql3`now()`
+    }).where(eq(inspectionFieldTable.id, id));
+  };
+})(InspectionFieldLogic ||= {});
+var logic_default25 = InspectionFieldLogic;
+
+// src/routes/fleet/inspection/fieldGroup/logic.ts
+var InspectionFieldGroupLogic;
+((InspectionFieldGroupLogic) => {
+  InspectionFieldGroupLogic.select = async (query) => {
+    const filter = and(softDeletedFilter(inspectionFieldGroupTable), ilike(inspectionFieldGroupTable.name, `%${query.name}%`).if(query.name), ilike(inspectionFieldGroupTable.code, `%${query.code}%`).if(query.code));
+    const columns = getTableColumns(inspectionFieldGroupTable);
+    const baseQuery = db_default.select({
+      ...columns,
+      totalCount: totalCountSql
+    }).from(inspectionFieldGroupTable).where(filter).$dynamic();
+    const result = await pagination_helper_default(baseQuery, query.pagination);
+    const content = {
+      totalCount: result[0]?.totalCount ?? 0,
+      totalPage: result.length === 0 ? 0 : Math.ceil(result[0].totalCount / query.pagination.size)
+    };
+    return {
+      result,
+      ...content
+    };
+  };
+  InspectionFieldGroupLogic.create = async (body) => {
+    await db_default.insert(inspectionFieldGroupTable).values(body);
+  };
+  InspectionFieldGroupLogic.update = async (id, body) => {
+    await db_default.update(inspectionFieldGroupTable).set(body).where(eq(inspectionFieldGroupTable.id, id));
+  };
+  InspectionFieldGroupLogic.remove = async (id) => {
+    await db_default.update(inspectionFieldGroupTable).set({
+      deletedAt: sql3`now`
+    }).where(eq(inspectionFieldGroupTable.id, id));
+  };
+})(InspectionFieldGroupLogic ||= {});
+var logic_default26 = InspectionFieldGroupLogic;
+
+// src/routes/fleet/inspection/fieldGroup/model.ts
+var InspectionFieldGroupModel;
+((InspectionFieldGroupModel) => {
+  const createSchema = createInsertSchema(inspectionFieldGroupTable);
+  const updateSchema = createUpdateSchema(inspectionFieldGroupTable);
+  InspectionFieldGroupModel.create = OmitBaseSchema(createSchema);
+  InspectionFieldGroupModel.update = OmitBaseSchema(updateSchema);
+  InspectionFieldGroupModel.select = t.Composite([
+    t.Partial(t.Object({
+      name: t.String(),
+      code: t.String()
+    })),
+    PaginationSchema
+  ]);
+})(InspectionFieldGroupModel ||= {});
+var model_default25 = InspectionFieldGroupModel;
+
+// src/routes/fleet/inspection/fieldGroup/index.ts
+var fieldGroupRoutes = new Elysia({
+  prefix: "/field-group"
+}).use(better_auth_default).guard({
+  userKind: "ADMIN"
+}).get("/", async ({ query }) => logic_default26.select(query), {
+  query: model_default25.select,
+  userKind: undefined,
+  auth: true
+}).post("/", async ({ body }) => logic_default26.create(body), {
+  body: model_default25.create
+}).guard({
+  params: IdSchema
+}).put("/:id", async ({ body, params: { id } }) => logic_default26.update(id, body), {
+  body: model_default25.update
+}).delete("/:id", async ({ params: { id } }) => logic_default26.remove(id)).get("/:id/field", async ({ params: { id } }) => logic_default25.select(id));
+var fieldGroup_default = fieldGroupRoutes;
+
+// src/routes/fleet/inspection/index.ts
+var inspectionRoutes2 = new Elysia({
+  prefix: "/inspection"
+}).use(fieldGroup_default);
+var inspection_default2 = inspectionRoutes2;
+
+// src/routes/fleet/index.ts
+var fleetRoutes = new Elysia({ prefix: "/fleet" }).use(inspection_default2);
+var fleet_default = fleetRoutes;
+
 // src/routes/index.ts
 var router2 = new Elysia({
   prefix: "/api"
-}).use(imageRoutes).use(warehouse_default2).use(company_default2).use(permission_default2).use(user_default2).use(crm_default).use(techdoc_default);
+}).use(imageRoutes).use(warehouse_default2).use(company_default2).use(permission_default2).use(user_default2).use(crm_default).use(techdoc_default).use(fleet_default);
 var routes_default = router2;
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autosync_backend2",
-  "version": "1.2.18",
+  "version": "1.2.19",
   "module": "src/index.ts",
   "type": "module",
   "main": "dist/index.js",