autosync_backend2 1.2.56 → 1.2.63

package/dist/index.d.ts

@@ -1141,9 +1141,9 @@ export declare const app: Elysia<"", {
                         oldId?: number | null | undefined;
                         description?: string | null | undefined;
                         quantity?: number | undefined;
+                        order?: number | undefined;
                         shelfNumber?: string | null | undefined;
                         isOrdered?: boolean | undefined;
-                        order?: number | undefined;
                         productId: string;
                         warehouseId: string;
                         safetyStock: number;
@@ -1160,12 +1160,12 @@ export declare const app: Elysia<"", {
                             oldId: number | null;
                             description: string | null;
                             quantity: number;
+                            order: number;
                             productId: string;
                             warehouseId: string;
                             safetyStock: number;
                             shelfNumber: string | null;
                             isOrdered: boolean;
-                            order: number;
                         };
                         401: "Токен олдсонгүй";
                         403: "Хандах эрхгүй байна.";
@@ -1189,9 +1189,9 @@ export declare const app: Elysia<"", {
                             oldId?: number | null | undefined;
                             description?: string | null | undefined;
                             quantity?: number | undefined;
+                            order?: number | undefined;
                             shelfNumber?: string | null | undefined;
                             isOrdered?: boolean | undefined;
-                            order?: number | undefined;
                             productId: string;
                             warehouseId: string;
                             safetyStock: number;
@@ -1412,12 +1412,12 @@ export declare const app: Elysia<"", {
                             deletedAt?: string | null | undefined;
                             oldId?: number | null | undefined;
                             description?: string | null | undefined;
+                            order?: number | undefined;
                             productId?: string | undefined;
                             warehouseId?: string | undefined;
                             safetyStock?: number | undefined;
                             shelfNumber?: string | null | undefined;
                             isOrdered?: boolean | undefined;
-                            order?: number | undefined;
                         };
                         params: {
                             id: string;
@@ -3088,23 +3088,65 @@ export declare const app: Elysia<"", {
                             totalCount: number;
                             totalPage: number;
                             result: Omit<{
+                                invoice: {
+                                    companyId: string;
+                                    billingPlanId: string;
+                                    periodStart: string;
+                                    periodEnd: string;
+                                    carCount: number;
+                                    basePrice: number;
+                                    status: "PENDING" | "PAID" | "OVERDUE" | "CANCELLED";
+                                    issuedAt: string;
+                                    paidAt: string | null;
+                                    dueAt: string;
+                                    note: string | null;
+                                    id: string;
+                                    createdAt: string;
+                                    updatedAt: string;
+                                    deletedAt: string | null;
+                                    oldId: number | null;
+                                };
+                                billingPlan: {
+                                    companyId: string;
+                                    billingPeriod: "MONTHLY" | "ANNUAL" | "YEARLY";
+                                    basePrice: number;
+                                    maxCarCount: number | null;
+                                    active: boolean;
+                                    note: string | null;
+                                    id: string;
+                                    createdAt: string;
+                                    updatedAt: string;
+                                    deletedAt: string | null;
+                                    oldId: number | null;
+                                } | null;
+                                company: {
+                                    name: string;
+                                    regNumber: string;
+                                    phone: string;
+                                    email: string;
+                                    serviceName: string;
+                                    logoUrl: string;
+                                    province: string | null;
+                                    district: string | null;
+                                    khoroo: string | null;
+                                    street: string | null;
+                                    socialUrls: string[] | null;
+                                    ceoName: string | null;
+                                    webUrl: string | null;
+                                    googleMapUrl: string | null;
+                                    isContract: boolean;
+                                    isNoat: boolean;
+                                    isNexus: boolean;
+                                    isActive: boolean;
+                                    branchCount: number;
+                                    type: "AutoService" | "MiningFleet" | "UrbanTransportFleet" | "Long-haul/Logistics" | "Emergency/Medical/Police" | "CorporateFleet";
+                                    id: string;
+                                    createdAt: string;
+                                    updatedAt: string;
+                                    deletedAt: string | null;
+                                    oldId: number | null;
+                                } | null;
                                 totalCount: number;
-                                companyId: string;
-                                billingPlanId: string;
-                                periodStart: string;
-                                periodEnd: string;
-                                carCount: number;
-                                basePrice: number;
-                                status: "PENDING" | "PAID" | "OVERDUE" | "CANCELLED";
-                                issuedAt: string;
-                                paidAt: string | null;
-                                dueAt: string;
-                                note: string | null;
-                                id: string;
-                                createdAt: string;
-                                updatedAt: string;
-                                deletedAt: string | null;
-                                oldId: number | null;
                             }, "totalCount">[];
                         };
                         401: "Токен олдсонгүй";
@@ -3168,59 +3210,6 @@ export declare const app: Elysia<"", {
                     };
                 };
             };
-        } & {
-            invoice: {
-                post: {
-                    body: {
-                        oldId?: number | null | undefined;
-                        note?: string | null | undefined;
-                        status?: "PENDING" | "PAID" | "OVERDUE" | "CANCELLED" | undefined;
-                        paidAt?: string | null | undefined;
-                        companyId: string;
-                        basePrice: number;
-                        billingPlanId: string;
-                        periodStart: string;
-                        periodEnd: string;
-                        carCount: number;
-                        issuedAt: string;
-                        dueAt: string;
-                    };
-                    params: {};
-                    query: {};
-                    headers: {};
-                    response: {
-                        200: {
-                            id: string;
-                            createdAt: string;
-                            updatedAt: string;
-                            companyId: string;
-                            deletedAt: string | null;
-                            oldId: number | null;
-                            basePrice: number;
-                            note: string | null;
-                            billingPlanId: string;
-                            periodStart: string;
-                            periodEnd: string;
-                            carCount: number;
-                            status: "PENDING" | "PAID" | "OVERDUE" | "CANCELLED";
-                            issuedAt: string;
-                            paidAt: string | null;
-                            dueAt: string;
-                        };
-                        401: "Токен олдсонгүй";
-                        403: "Хандах эрхгүй байна." | "Төлбөрийн баримт үүсгэх эрхгүй байна.";
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
         } & {
             invoice: {
                 ":id": {
@@ -10484,17 +10473,43 @@ export declare const app: Elysia<"", {
                                     totalCount: number;
                                     totalPage: number;
                                     result: Omit<{
+                                        product: {
+                                            pmPlanId: string;
+                                            productKindId: string;
+                                            uomId: string;
+                                            quantity: number | null;
+                                            pmQuantity: string | null;
+                                            id: string;
+                                            createdAt: string;
+                                            updatedAt: string;
+                                            deletedAt: string | null;
+                                            oldId: number | null;
+                                        };
+                                        productKind: {
+                                            productCategoryId: string;
+                                            name: string;
+                                            description: string | null;
+                                            id: string;
+                                            createdAt: string;
+                                            updatedAt: string;
+                                            deletedAt: string | null;
+                                            oldId: number | null;
+                                        } | null;
+                                        uom: {
+                                            uomCategoryId: string;
+                                            code: string | null;
+                                            name: string;
+                                            description: string | null;
+                                            symbol: string | null;
+                                            isBaseUnit: boolean;
+                                            baseFactor: number | null;
+                                            id: string;
+                                            createdAt: string;
+                                            updatedAt: string;
+                                            deletedAt: string | null;
+                                            oldId: number | null;
+                                        } | null;
                                         totalCount: number;
-                                        pmPlanId: string;
-                                        productKindId: string;
-                                        uomId: string;
-                                        quantity: number | null;
-                                        pmQuantity: string;
-                                        id: string;
-                                        createdAt: string;
-                                        updatedAt: string;
-                                        deletedAt: string | null;
-                                        oldId: number | null;
                                     }, "totalCount">[];
                                 };
                                 401: "Токен олдсонгүй";
@@ -10516,10 +10531,10 @@ export declare const app: Elysia<"", {
                             body: {
                                 oldId?: number | null | undefined;
                                 quantity?: number | null | undefined;
+                                pmQuantity?: string | null | undefined;
                                 uomId: string;
                                 productKindId: string;
                                 pmPlanId: string;
-                                pmQuantity: string;
                             };
                             params: {};
                             query: unknown;
@@ -10545,10 +10560,10 @@ export declare const app: Elysia<"", {
                                 body: {
                                     oldId?: number | null | undefined;
                                     quantity?: number | null | undefined;
+                                    pmQuantity?: string | null | undefined;
                                     uomId: string;
                                     productKindId: string;
                                     pmPlanId: string;
-                                    pmQuantity: string;
                                 }[];
                                 params: {};
                                 query: unknown;
@@ -10564,7 +10579,7 @@ export declare const app: Elysia<"", {
                                         uomId: string;
                                         productKindId: string;
                                         pmPlanId: string;
-                                        pmQuantity: string;
+                                        pmQuantity: string | null;
                                     }[];
                                     400: "Бүтээгдэхүүний мэдээлэл оруулах мэдээлэл байхгүй байна.";
                                     401: "Токен олдсонгүй";
@@ -10591,7 +10606,7 @@ export declare const app: Elysia<"", {
                                     uomId?: string | undefined;
                                     productKindId?: string | undefined;
                                     pmPlanId?: string | undefined;
-                                    pmQuantity?: string | undefined;
+                                    pmQuantity?: string | null | undefined;
                                 };
                                 params: {
                                     id: string;
@@ -10687,22 +10702,17 @@ export declare const app: Elysia<"", {
                 plan: {
                     post: {
                         body: {
-                            oldId?: number | null | undefined;
-                            description?: string | null | undefined;
-                            dateStart?: Date | null | undefined;
-                            dateEnd?: Date | null | undefined;
-                            name: string;
-                            companyId: string;
+                            machineId: string;
+                            pmTemplateId: string;
                         };
                         params: {};
                         query: unknown;
                         headers: unknown;
                         response: {
-                            200: {
-                                id: string;
-                            };
+                            400: "Ажилтны мэдээлэл шаардлагатай." | "Машины төрөл хэрэглэгчийн машин төрөлтэй тэнцүү байхгүй.";
                             401: "Токен олдсонгүй";
                             403: "Хандах эрхгүй байна.";
+                            404: "Pm Template олдсонгүй." | "Машин олдсонгүй.";
                             422: {
                                 type: "validation";
                                 on: string;
@@ -10917,6 +10927,34 @@ export declare const app: Elysia<"", {
                         query: unknown;
                         headers: unknown;
                         response: {
+                            200: {
+                                companyId: string | null;
+                                machineKindId: string;
+                                customerId: string | null;
+                                name: string | null;
+                                assetCode: string | null;
+                                vin: string | null;
+                                licensePlate: string | null;
+                                color: string | null;
+                                engineCc: string | null;
+                                cylinder: string | null;
+                                gasType: string | null;
+                                transmissionType: string | null;
+                                vehicleType: string | null;
+                                yearManufacture: number | null;
+                                yearImport: number | null;
+                                steering: string | null;
+                                engineCode: string | null;
+                                transmissionCode: string | null;
+                                driveTrain: string | null;
+                                km: number;
+                                customData: unknown;
+                                id: string;
+                                createdAt: string;
+                                updatedAt: string;
+                                deletedAt: string | null;
+                                oldId: number | null;
+                            };
                             401: "Токен олдсонгүй";
                             422: {
                                 type: "validation";
@@ -11200,6 +11238,301 @@ export declare const app: Elysia<"", {
                 };
             };
         };
+    } & {
+        fleet: {
+            "work-order": {};
+        } & {
+            "work-order": {
+                task: {};
+            } & {
+                task: {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: {
+                            pagination: {
+                                size: number;
+                                page: number;
+                            };
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                totalCount: number;
+                                totalPage: number;
+                                result: Omit<{
+                                    totalCount: number;
+                                    workOrderId: string;
+                                    templateId: string;
+                                    serviceKindId: string;
+                                    description: string | null;
+                                    manHour: number | null;
+                                    state: "IN_PROGRESS" | "COMPLETED" | "OPEN" | "CLOSED";
+                                    id: string;
+                                    createdAt: string;
+                                    updatedAt: string;
+                                    deletedAt: string | null;
+                                    oldId: number | null;
+                                }, "totalCount">[];
+                            };
+                            401: "Токен олдсонгүй";
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                        };
+                    };
+                };
+            } & {
+                task: {
+                    post: {
+                        body: {
+                            description?: string | undefined;
+                            state?: "IN_PROGRESS" | "COMPLETED" | "OPEN" | "CLOSED" | undefined;
+                            manHour?: number | undefined;
+                            serviceKindId: string;
+                            templateId: string;
+                            workOrderId: string;
+                        };
+                        params: {};
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                id: string;
+                                createdAt: string;
+                                updatedAt: string;
+                                deletedAt: string | null;
+                                oldId: number | null;
+                                description: string | null;
+                                serviceKindId: string;
+                                state: "IN_PROGRESS" | "COMPLETED" | "OPEN" | "CLOSED";
+                                templateId: string;
+                                workOrderId: string;
+                                manHour: number | null;
+                            };
+                            401: "Токен олдсонгүй";
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                        };
+                    };
+                };
+            } & {
+                task: {
+                    ":id": {
+                        put: {
+                            body: {
+                                oldId?: number | null | undefined;
+                                description?: string | null | undefined;
+                                serviceKindId?: string | undefined;
+                                state?: "IN_PROGRESS" | "COMPLETED" | "OPEN" | "CLOSED" | undefined;
+                                templateId?: string | undefined;
+                                workOrderId?: string | undefined;
+                                manHour?: number | null | undefined;
+                            };
+                            params: {
+                                id: string;
+                            };
+                            query: unknown;
+                            headers: unknown;
+                            response: {
+                                401: "Токен олдсонгүй";
+                                422: {
+                                    type: "validation";
+                                    on: string;
+                                    summary?: string;
+                                    message?: string;
+                                    found?: unknown;
+                                    property?: string;
+                                    expected?: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                task: {
+                    ":id": {
+                        delete: {
+                            body: unknown;
+                            params: {
+                                id: string;
+                            };
+                            query: unknown;
+                            headers: unknown;
+                            response: {
+                                401: "Токен олдсонгүй";
+                                422: {
+                                    type: "validation";
+                                    on: string;
+                                    summary?: string;
+                                    message?: string;
+                                    found?: unknown;
+                                    property?: string;
+                                    expected?: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            "work-order": {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        pagination: {
+                            size: number;
+                            page: number;
+                        };
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            totalCount: number;
+                            totalPage: number;
+                            result: Omit<{
+                                totalCount: number;
+                                machineId: string;
+                                sourceType: string | null;
+                                type: "CORRECTIVE" | "PREVENTIVE";
+                                piority: "CRITICAL" | "HIGH" | "MEDIUM" | "LOW" | "PLANNED";
+                                state: "IN_PROGRESS" | "COMPLETED" | "OPEN" | "CLOSED";
+                                dateClosed: Date | null;
+                                id: string;
+                                createdAt: string;
+                                updatedAt: string;
+                                deletedAt: string | null;
+                                oldId: number | null;
+                            }, "totalCount">[];
+                        };
+                        401: "Токен олдсонгүй";
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        } & {
+            "work-order": {
+                post: {
+                    body: {
+                        oldId?: number | null | undefined;
+                        state?: "IN_PROGRESS" | "COMPLETED" | "OPEN" | "CLOSED" | undefined;
+                        sourceType?: string | null | undefined;
+                        dateClosed?: Date | null | undefined;
+                        type: "CORRECTIVE" | "PREVENTIVE";
+                        machineId: string;
+                        piority: "CRITICAL" | "HIGH" | "MEDIUM" | "LOW" | "PLANNED";
+                    };
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: {
+                            type: "CORRECTIVE" | "PREVENTIVE";
+                            id: string;
+                            createdAt: string;
+                            updatedAt: string;
+                            deletedAt: string | null;
+                            oldId: number | null;
+                            state: "IN_PROGRESS" | "COMPLETED" | "OPEN" | "CLOSED";
+                            machineId: string;
+                            piority: "CRITICAL" | "HIGH" | "MEDIUM" | "LOW" | "PLANNED";
+                            sourceType: string | null;
+                            dateClosed: Date | null;
+                        };
+                        401: "Токен олдсонгүй";
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        } & {
+            "work-order": {
+                ":id": {
+                    put: {
+                        body: {
+                            type?: "CORRECTIVE" | "PREVENTIVE" | undefined;
+                            oldId?: number | null | undefined;
+                            state?: "IN_PROGRESS" | "COMPLETED" | "OPEN" | "CLOSED" | undefined;
+                            machineId?: string | undefined;
+                            piority?: "CRITICAL" | "HIGH" | "MEDIUM" | "LOW" | "PLANNED" | undefined;
+                            sourceType?: string | null | undefined;
+                            dateClosed?: Date | null | undefined;
+                        };
+                        params: {
+                            id: string;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            401: "Токен олдсонгүй";
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            "work-order": {
+                ":id": {
+                    delete: {
+                        body: unknown;
+                        params: {
+                            id: string;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            401: "Токен олдсонгүй";
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     api: {

package/dist/index.js

@@ -142638,6 +142638,12 @@ function drizzle(...params) {
 // src/lib/db/schema/index.ts
 var exports_schema = {};
 __export(exports_schema, {
+  workOrderTypeEnum: () => workOrderTypeEnum,
+  workOrderTaskTable: () => workOrderTaskTable,
+  workOrderTable: () => workOrderTable,
+  workOrderStateEnum: () => workOrderStateEnum,
+  workOrderSchema: () => workOrderSchema,
+  workOrderPiorityEnum: () => workOrderPiorityEnum,
   weekDayEnum: () => weekDayEnum,
   warehouseWarehouseTable: () => warehouseWarehouseTable,
   warehouseTransferTable: () => warehouseTransferTable,
@@ -143446,7 +143452,7 @@ var pmPlanMachineTable = pmSchema.table("plan_machine", {
   pmTemplateId: uuid5().notNull(),
   machineId: uuid5().notNull(),
   employeeCreatedId: uuid5().notNull(),
-  userCreatedId: uuid5().notNull(),
+  userCreatedId: text().notNull(),
   note: text()
 });
 var pmPlanProductTable = pmSchema.table("plan_product", {
@@ -143455,7 +143461,7 @@ var pmPlanProductTable = pmSchema.table("plan_product", {
   productKindId: uuid5().notNull(),
   uomId: uuid5().notNull(),
   quantity: numeric({ mode: "number" }),
-  pmQuantity: uuid5().notNull()
+  pmQuantity: uuid5()
 });
 var maintenanceServiceSchema = pgSchema("maintenance_service");
 var maintenanceServiceRecordTable = maintenanceServiceSchema.table("record", {
@@ -143476,6 +143482,42 @@ var maintenanceServiceRecordProductTable = maintenanceServiceSchema.table("recor
   uomId: uuid5().notNull(),
   quantity: numeric({ mode: "number" })
 });
+var workOrderSchema = pgSchema("work_order");
+var workOrderTypeEnum = workOrderSchema.enum("type", [
+  "CORRECTIVE",
+  "PREVENTIVE"
+]);
+var workOrderPiorityEnum = workOrderSchema.enum("piority", [
+  "CRITICAL",
+  "HIGH",
+  "MEDIUM",
+  "LOW",
+  "PLANNED"
+]);
+var workOrderStateEnum = workOrderSchema.enum("state", [
+  "OPEN",
+  "IN_PROGRESS",
+  "COMPLETED",
+  "CLOSED"
+]);
+var workOrderTable = workOrderSchema.table("order", {
+  ...base_schema_helper_default,
+  machineId: uuid5().notNull(),
+  sourceType: varchar(),
+  type: workOrderTypeEnum().notNull(),
+  piority: workOrderPiorityEnum().notNull(),
+  state: workOrderStateEnum().notNull().default("OPEN"),
+  dateClosed: timestamp({ withTimezone: true })
+});
+var workOrderTaskTable = workOrderSchema.table("task", {
+  ...base_schema_helper_default,
+  workOrderId: uuid5().notNull(),
+  templateId: uuid5().notNull(),
+  serviceKindId: uuid5().notNull(),
+  description: text(),
+  manHour: numeric({ mode: "number" }),
+  state: workOrderStateEnum().notNull().default("OPEN")
+});
 // src/lib/db/schema/techdoc.schema.ts
 var techdocSchema = pgSchema("techdoc");
 var techdocVehicleKindEnum = pgEnum("vehicle_kind_enum", [
@@ -147596,20 +147638,14 @@ var CompanyInvoiceLogic;
     }).where(and(eq(companyInvoiceTable.status, "PENDING"), lte(sql3`${companyInvoiceTable.dueAt}`, now))).returning();
     return result;
   };
-  CompanyInvoiceLogic.create = async (body, user2) => {
-    if (user2.kind !== "ADMIN" && user2.companyId !== body.companyId) {
-      return status("Forbidden", "\u0422\u04E9\u043B\u0431\u04E9\u0440\u0438\u0439\u043D \u0431\u0430\u0440\u0438\u043C\u0442 \u04AF\u04AF\u0441\u0433\u044D\u0445 \u044D\u0440\u0445\u0433\u04AF\u0439 \u0431\u0430\u0439\u043D\u0430.");
-    }
-    const [invoice] = await db_default.insert(companyInvoiceTable).values(body).returning();
-    return invoice;
-  };
   CompanyInvoiceLogic.select = async (query, user2) => {
     const filter = and(eq(companyInvoiceTable.companyId, query.companyId ?? "").if(query.companyId && user2.kind === "ADMIN"), eq(companyInvoiceTable.companyId, user2.companyId).if(user2.kind !== "ADMIN"), eq(companyInvoiceTable.status, query.status).if(query.status !== undefined), eq(companyInvoiceTable.billingPlanId, query.billingPlanId).if(query.billingPlanId), softDeletedFilter(companyInvoiceTable));
-    const columns = getTableColumns(companyInvoiceTable);
     const baseQuery = db_default.select({
-      ...columns,
+      invoice: companyInvoiceTable,
+      billingPlan: companyBillingPlanTable,
+      company: companyCompanyTable,
       totalCount: totalCountSql
-    }).from(companyInvoiceTable).where(filter).$dynamic();
+    }).from(companyInvoiceTable).leftJoin(companyBillingPlanTable, eq(companyInvoiceTable.billingPlanId, companyBillingPlanTable.id)).leftJoin(companyCompanyTable, eq(companyInvoiceTable.companyId, companyCompanyTable.id)).where(filter).$dynamic();
     const result = await pagination_helper_default(baseQuery, query.pagination);
     return getPaginationContent(result, query.pagination.size);
   };
@@ -147636,7 +147672,11 @@ var CompanyInvoiceModel;
   const createSchema = createInsertSchema2(companyInvoiceTable);
   const updateSchema = createUpdateSchema(companyInvoiceTable);
   const selectSchema = createSelectSchema(companyInvoiceTable);
-  CompanyInvoiceModel.create = OmitBaseSchema(createSchema);
+  CompanyInvoiceModel.create = t.Omit(OmitBaseSchema(createSchema), [
+    "periodEnd",
+    "issuedAt",
+    "dueAt"
+  ]);
   CompanyInvoiceModel.update = OmitBaseSchema(updateSchema);
   CompanyInvoiceModel.select = t.Composite([
     t.Partial(selectSchema),
@@ -147797,9 +147837,6 @@ var invoiceRoutes = new Elysia({
 }).post("/generate", async ({ body, user: user2 }) => await logic_default5.generate(body, user2), {
   body: model_default6.generate,
   userKind: "ADMIN"
-}).post("/", async ({ body, user: user2 }) => await logic_default5.create(body, user2), {
-  body: model_default6.create,
-  userKind: "ADMIN"
 }).guard({
   params: IdSchema
 }).put("/:id", async ({ params: { id }, body, user: user2 }) => await logic_default5.update(id, body, user2), {
@@ -155498,7 +155535,7 @@ var inspection_default2 = inspectionRoutes2;
 var MachineLogic;
 ((MachineLogic) => {
   MachineLogic.select = async (query, user2) => {
-    const filter = and(or(isNull2(companyMachineTable.companyId), eq(companyMachineTable.companyId, user2.companyId).if(user2.kind !== "ADMIN")), eq(companyMachineTable.id, query.id).if(query.id), softDeletedFilter(companyMachineTable));
+    const filter = and(eq(companyMachineTable.companyId, user2.companyId).if(user2.kind !== "ADMIN"), eq(companyMachineTable.id, query.id).if(query.id), softDeletedFilter(companyMachineTable));
     const columns = getTableColumns(companyMachineTable);
     const baseQuery = db_default.select({
       ...columns,
@@ -155514,9 +155551,10 @@ var MachineLogic;
     });
   };
   MachineLogic.update = async (id, body, user2) => {
-    await db_default.update(companyMachineTable).set({
+    const [result] = await db_default.update(companyMachineTable).set({
       ...body
-    }).where(and(eq(companyMachineTable.id, id), eq(companyMachineTable.companyId, user2.companyId).if(user2.kind !== "ADMIN")));
+    }).where(and(eq(companyMachineTable.id, id), eq(companyMachineTable.companyId, user2.companyId).if(user2.kind !== "ADMIN"))).returning();
+    return result;
   };
   MachineLogic.remove = async (id, user2) => {
     await db_default.update(companyMachineTable).set({
@@ -155680,13 +155718,47 @@ var PmPlanLogic;
     return getPaginationContent(result, query.pagination.size);
   };
   PmPlanLogic.create = async (body, user2) => {
-    const [result] = await db_default.insert(pmPlanTable).values({
-      ...body,
-      companyId: user2.companyId
-    }).returning({
-      id: pmPlanTable.id
+    if (!user2.employeeId) {
+      return status("Bad Request", "\u0410\u0436\u0438\u043B\u0442\u043D\u044B \u043C\u044D\u0434\u044D\u044D\u043B\u044D\u043B \u0448\u0430\u0430\u0440\u0434\u043B\u0430\u0433\u0430\u0442\u0430\u0439.");
+    }
+    const [[template], [machine]] = await Promise.all([
+      db_default.select().from(pmTemplateTable).where(eq(pmTemplateTable.id, body.pmTemplateId)).limit(1),
+      db_default.select().from(companyMachineTable).where(eq(companyMachineTable.id, body.machineId)).limit(1)
+    ]);
+    if (!template) {
+      return status("Not Found", "Pm Template \u043E\u043B\u0434\u0441\u043E\u043D\u0433\u04AF\u0439.");
+    }
+    if (!machine) {
+      return status("Not Found", "\u041C\u0430\u0448\u0438\u043D \u043E\u043B\u0434\u0441\u043E\u043D\u0433\u04AF\u0439.");
+    }
+    if (template.machineKindId !== machine.machineKindId) {
+      return status("Bad Request", "\u041C\u0430\u0448\u0438\u043D\u044B \u0442\u04E9\u0440\u04E9\u043B \u0445\u044D\u0440\u044D\u0433\u043B\u044D\u0433\u0447\u0438\u0439\u043D \u043C\u0430\u0448\u0438\u043D \u0442\u04E9\u0440\u04E9\u043B\u0442\u044D\u0439 \u0442\u044D\u043D\u0446\u04AF\u04AF \u0431\u0430\u0439\u0445\u0433\u04AF\u0439.");
+    }
+    const products = await db_default.select().from(pmTemplateProductTable).where(eq(pmTemplateProductTable.pmTemplateId, template.id));
+    return db_default.transaction(async (db2) => {
+      const [plan] = await db2.insert(pmPlanTable).values({
+        companyId: user2.companyId,
+        name: template.name,
+        description: template.description
+      }).returning({
+        id: pmPlanTable.id
+      });
+      await db2.insert(pmPlanMachineTable).values({
+        pmPlanId: plan.id,
+        pmTemplateId: template.id,
+        machineId: machine.id,
+        employeeCreatedId: user2.employeeId,
+        userCreatedId: user2.id
+      });
+      if (products.length > 0) {
+        await db2.insert(pmPlanProductTable).values(products.map((product) => ({
+          pmPlanId: plan.id,
+          productKindId: product.productKindId,
+          uomId: product.uomId,
+          quantity: product.quantity
+        })));
+      }
     });
-    return result;
   };
   PmPlanLogic.update = async (id, body, user2) => {
     await db_default.update(pmPlanTable).set({
@@ -155783,16 +155855,30 @@ var machineRoutes2 = new Elysia({
 }).delete("/:id", async ({ params: { id } }) => logic_default41.remove(id));
 var machine_default2 = machineRoutes2;
 
+// src/routes/fleet/pm/plan/model.ts
+var PmPlanModel;
+((PmPlanModel) => {
+  const updateSchema = createUpdateSchema(pmPlanTable);
+  PmPlanModel.create = t.Object({
+    pmTemplateId: t.String({ format: "uuid" }),
+    machineId: t.String({ format: "uuid" })
+  });
+  PmPlanModel.update = OmitBaseSchema(updateSchema);
+  PmPlanModel.select = t.Composite([PaginationSchema]);
+})(PmPlanModel ||= {});
+var model_default41 = PmPlanModel;
+
 // src/routes/fleet/pm/plan/product/logic.ts
 var PmPlanProductLogic;
 ((PmPlanProductLogic) => {
   PmPlanProductLogic.select = async (query) => {
     const filter = and(eq(pmPlanProductTable.pmPlanId, query.pmPlanId), softDeletedFilter(pmPlanProductTable));
-    const columns = getTableColumns(pmPlanProductTable);
     const baseQuery = db_default.select({
-      ...columns,
+      product: pmPlanProductTable,
+      productKind: techdocProductKindTable,
+      uom: uomTable,
       totalCount: totalCountSql
-    }).from(pmPlanProductTable).where(filter).$dynamic();
+    }).from(pmPlanProductTable).leftJoin(techdocProductKindTable, eq(techdocProductKindTable.id, pmPlanProductTable.productKindId)).leftJoin(uomTable, eq(uomTable.id, pmPlanProductTable.uomId)).where(filter).$dynamic();
     const result = await pagination_helper_default(baseQuery, query.pagination);
     return getPaginationContent(result, query.pagination.size);
   };
@@ -155836,7 +155922,7 @@ var PmPlanProductModel;
   ]);
   PmPlanProductModel.createMany = t.Array(OmitBaseSchema(createSchema));
 })(PmPlanProductModel ||= {});
-var model_default41 = PmPlanProductModel;
+var model_default42 = PmPlanProductModel;
 
 // src/routes/fleet/pm/plan/product/index.ts
 var productRoutes5 = new Elysia({
@@ -155845,29 +155931,18 @@ var productRoutes5 = new Elysia({
 }).use(better_auth_default).guard({
   auth: true
 }).get("/", async ({ query }) => logic_default42.select(query), {
-  query: model_default41.select
+  query: model_default42.select
 }).post("/", async ({ body }) => logic_default42.create(body), {
-  body: model_default41.create
+  body: model_default42.create
 }).post("/many", async ({ body }) => logic_default42.createMany(body), {
-  body: model_default41.createMany
+  body: model_default42.createMany
 }).guard({
   params: IdSchema
 }).put("/:id", async ({ body, params: { id } }) => logic_default42.update(id, body), {
-  body: model_default41.update
+  body: model_default42.update
 }).delete("/:id", async ({ params: { id } }) => logic_default42.remove(id));
 var product_default5 = productRoutes5;
 
-// src/routes/fleet/pm/plan/model.ts
-var PmPlanModel;
-((PmPlanModel) => {
-  const createSchema = createInsertSchema2(pmPlanTable);
-  const updateSchema = createUpdateSchema(pmPlanTable);
-  PmPlanModel.create = OmitBaseSchema(createSchema);
-  PmPlanModel.update = OmitBaseSchema(updateSchema);
-  PmPlanModel.select = t.Composite([PaginationSchema]);
-})(PmPlanModel ||= {});
-var model_default42 = PmPlanModel;
-
 // src/routes/fleet/pm/plan/index.ts
 var planRoutes = new Elysia({
   prefix: "/plan",
@@ -155875,13 +155950,13 @@ var planRoutes = new Elysia({
 }).use(better_auth_default).use(machine_default2).use(product_default5).guard({
   userKind: "COMPANY_ADMIN"
 }).get("/", async ({ query, user: user2 }) => logic_default40.select(query, user2), {
-  query: model_default42.select
+  query: model_default41.select
 }).post("/", async ({ body, user: user2 }) => logic_default40.create(body, user2), {
-  body: model_default42.create
+  body: model_default41.create
 }).guard({
   params: IdSchema
 }).put("/:id", async ({ body, params: { id }, user: user2 }) => logic_default40.update(id, body, user2), {
-  body: model_default42.update
+  body: model_default41.update
 }).delete("/:id", async ({ params: { id }, user: user2 }) => logic_default40.remove(id, user2));
 var plan_default = planRoutes;
 
@@ -156018,8 +156093,127 @@ var pmRoutes = new Elysia({
 }).use(template_default2).use(plan_default);
 var pm_default = pmRoutes;
 
+// src/routes/fleet/work-order/logic.ts
+var WorkOrderLogic;
+((WorkOrderLogic) => {
+  WorkOrderLogic.select = async (query) => {
+    const filter = softDeletedFilter(workOrderTable);
+    const columns = getTableColumns(workOrderTable);
+    const baseQuery = db_default.select({
+      ...columns,
+      totalCount: totalCountSql
+    }).from(workOrderTable).where(filter).$dynamic();
+    const result = await pagination_helper_default(baseQuery, query.pagination);
+    return getPaginationContent(result, query.pagination.size);
+  };
+  WorkOrderLogic.create = async (body) => {
+    const [result] = await db_default.insert(workOrderTable).values(body).returning();
+    return result;
+  };
+  WorkOrderLogic.update = async (id, body) => {
+    await db_default.update(workOrderTable).set(body).where(eq(workOrderTable.id, id));
+  };
+  WorkOrderLogic.remove = async (id) => {
+    await db_default.update(workOrderTable).set({
+      deletedAt: nowSql_helper_default
+    }).where(eq(workOrderTable.id, id));
+  };
+})(WorkOrderLogic ||= {});
+var logic_default45 = WorkOrderLogic;
+
+// src/routes/fleet/work-order/model.ts
+var WorkOrderModel;
+((WorkOrderModel) => {
+  const createSchema = createInsertSchema2(workOrderTable);
+  const updateSchema = createUpdateSchema(workOrderTable);
+  WorkOrderModel.create = OmitBaseSchema(createSchema);
+  WorkOrderModel.update = OmitBaseSchema(updateSchema);
+  WorkOrderModel.select = t.Composite([PaginationSchema]);
+})(WorkOrderModel ||= {});
+var model_default45 = WorkOrderModel;
+
+// src/routes/fleet/work-order/task/logic.ts
+var WorkOrderTaskLogic;
+((WorkOrderTaskLogic) => {
+  WorkOrderTaskLogic.select = async (query, user2) => {
+    const filter = softDeletedFilter(workOrderTaskTable);
+    const columns = getTableColumns(workOrderTaskTable);
+    const baseQuery = db_default.select({
+      ...columns,
+      totalCount: totalCountSql
+    }).from(workOrderTaskTable).where(filter).$dynamic();
+    const result = await pagination_helper_default(baseQuery, query.pagination);
+    return getPaginationContent(result, query.pagination.size);
+  };
+  WorkOrderTaskLogic.create = async (body, user2) => {
+    const [result] = await db_default.insert(workOrderTaskTable).values({
+      ...body,
+      state: body.state ?? "OPEN"
+    }).returning();
+    return result;
+  };
+  WorkOrderTaskLogic.update = async (id, body, user2) => {
+    await db_default.update(workOrderTaskTable).set({
+      ...body
+    }).where(eq(workOrderTaskTable.id, id));
+  };
+  WorkOrderTaskLogic.remove = async (id, user2) => {
+    await db_default.update(workOrderTaskTable).set({
+      deletedAt: nowSql_helper_default
+    }).where(eq(workOrderTaskTable.id, id));
+  };
+})(WorkOrderTaskLogic ||= {});
+var logic_default46 = WorkOrderTaskLogic;
+
+// src/routes/fleet/work-order/task/model.ts
+var WorkOrderTaskModel;
+((WorkOrderTaskModel) => {
+  const updateSchema = createUpdateSchema(workOrderTaskTable);
+  WorkOrderTaskModel.create = t.Object({
+    workOrderId: t.String({ format: "uuid" }),
+    templateId: t.String({ format: "uuid" }),
+    serviceKindId: t.String({ format: "uuid" }),
+    description: t.Optional(t.String()),
+    manHour: t.Optional(t.Number()),
+    state: t.Optional(StringEnum(["OPEN", "IN_PROGRESS", "COMPLETED", "CLOSED"]))
+  });
+  WorkOrderTaskModel.update = OmitBaseSchema(updateSchema);
+  WorkOrderTaskModel.select = t.Composite([PaginationSchema]);
+})(WorkOrderTaskModel ||= {});
+var model_default46 = WorkOrderTaskModel;
+
+// src/routes/fleet/work-order/task/index.ts
+var workOrderTaskRoutes = new Elysia({
+  prefix: "/task",
+  tags: ["WorkOrderTask"]
+}).use(better_auth_default).guard({ auth: true }).get("/", async ({ query, user: user2 }) => logic_default46.select(query, user2), {
+  query: model_default46.select
+}).post("/", async ({ body, user: user2 }) => logic_default46.create(body, user2), {
+  body: model_default46.create
+}).guard({
+  params: IdSchema
+}).put("/:id", async ({ body, params: { id }, user: user2 }) => logic_default46.update(id, body, user2), {
+  body: model_default46.update
+}).delete("/:id", async ({ params: { id }, user: user2 }) => logic_default46.remove(id, user2));
+var task_default = workOrderTaskRoutes;
+
+// src/routes/fleet/work-order/index.ts
+var workOrderRoutes = new Elysia({
+  prefix: "/work-order",
+  tags: ["WorkOrder"]
+}).use(better_auth_default).use(task_default).guard({ auth: true }).get("/", async ({ query }) => logic_default45.select(query), {
+  query: model_default45.select
+}).post("/", async ({ body }) => logic_default45.create(body), {
+  body: model_default45.create
+}).guard({
+  params: IdSchema
+}).put("/:id", async ({ body, params: { id } }) => logic_default45.update(id, body), {
+  body: model_default45.update
+}).delete("/:id", async ({ params: { id } }) => logic_default45.remove(id));
+var work_order_default = workOrderRoutes;
+
 // src/routes/fleet/index.ts
-var fleetRoutes = new Elysia({ prefix: "/fleet" }).use(inspection_default2).use(pm_default).use(machine_default).use(ms_default);
+var fleetRoutes = new Elysia({ prefix: "/fleet" }).use(inspection_default2).use(pm_default).use(machine_default).use(ms_default).use(work_order_default);
 var fleet_default = fleetRoutes;
 
 // src/routes/uom/category/logic.ts
@@ -156053,7 +156247,7 @@ var UomCategoryLogic;
     }).where(and(eq(uomCategoryTable.id, id)));
   };
 })(UomCategoryLogic ||= {});
-var logic_default45 = UomCategoryLogic;
+var logic_default47 = UomCategoryLogic;
 
 // src/routes/uom/category/model.ts
 var UomCategoryModel;
@@ -156064,7 +156258,7 @@ var UomCategoryModel;
   UomCategoryModel.update = OmitBaseSchema(updateSchema);
   UomCategoryModel.select = t.Composite([PaginationSchema]);
 })(UomCategoryModel ||= {});
-var model_default45 = UomCategoryModel;
+var model_default47 = UomCategoryModel;
 
 // src/routes/uom/category/index.ts
 var categoryRoutes = new Elysia({
@@ -156072,15 +156266,15 @@ var categoryRoutes = new Elysia({
   tags: ["UomCategory"]
 }).use(better_auth_default).guard({
   auth: true
-}).get("/", async ({ query }) => logic_default45.select(query), {
-  query: model_default45.select
-}).post("/", async ({ body }) => logic_default45.create(body), {
-  body: model_default45.create
+}).get("/", async ({ query }) => logic_default47.select(query), {
+  query: model_default47.select
+}).post("/", async ({ body }) => logic_default47.create(body), {
+  body: model_default47.create
 }).guard({
   params: IdSchema
-}).put("/:id", async ({ body, params: { id } }) => logic_default45.update(id, body), {
-  body: model_default45.update
-}).delete("/:id", async ({ params: { id } }) => logic_default45.remove(id));
+}).put("/:id", async ({ body, params: { id } }) => logic_default47.update(id, body), {
+  body: model_default47.update
+}).delete("/:id", async ({ params: { id } }) => logic_default47.remove(id));
 var category_default = categoryRoutes;
 
 // src/routes/uom/conversion/logic.ts
@@ -156114,7 +156308,7 @@ var UomConversionLogic;
     }).where(and(eq(uomConversionTable.id, id)));
   };
 })(UomConversionLogic ||= {});
-var logic_default46 = UomConversionLogic;
+var logic_default48 = UomConversionLogic;
 
 // src/routes/uom/conversion/model.ts
 var UomConversionModel;
@@ -156131,7 +156325,7 @@ var UomConversionModel;
     })
   ]);
 })(UomConversionModel ||= {});
-var model_default46 = UomConversionModel;
+var model_default48 = UomConversionModel;
 
 // src/routes/uom/conversion/index.ts
 var conversionRoutes = new Elysia({
@@ -156139,15 +156333,15 @@ var conversionRoutes = new Elysia({
   tags: ["UomConversion"]
 }).use(better_auth_default).guard({
   auth: true
-}).get("/", async ({ query }) => logic_default46.select(query), {
-  query: model_default46.select
-}).post("/", async ({ body }) => logic_default46.create(body), {
-  body: model_default46.create
+}).get("/", async ({ query }) => logic_default48.select(query), {
+  query: model_default48.select
+}).post("/", async ({ body }) => logic_default48.create(body), {
+  body: model_default48.create
 }).guard({
   params: IdSchema
-}).put("/:id", async ({ body, params: { id } }) => logic_default46.update(id, body), {
-  body: model_default46.update
-}).delete("/:id", async ({ params: { id } }) => logic_default46.remove(id));
+}).put("/:id", async ({ body, params: { id } }) => logic_default48.update(id, body), {
+  body: model_default48.update
+}).delete("/:id", async ({ params: { id } }) => logic_default48.remove(id));
 var conversion_default = conversionRoutes;
 
 // src/routes/uom/logic.ts
@@ -156181,7 +156375,7 @@ var UomLogic;
     }).where(and(eq(uomTable.id, id)));
   };
 })(UomLogic ||= {});
-var logic_default47 = UomLogic;
+var logic_default49 = UomLogic;
 
 // src/routes/uom/model.ts
 var UomModel;
@@ -156197,7 +156391,7 @@ var UomModel;
     })
   ]);
 })(UomModel ||= {});
-var model_default47 = UomModel;
+var model_default49 = UomModel;
 
 // src/routes/uom/index.ts
 var uomSchemaRoutes = new Elysia({
@@ -156205,15 +156399,15 @@ var uomSchemaRoutes = new Elysia({
 }).use(better_auth_default).use(category_default).use(conversion_default).guard({
   userKind: "ADMIN",
   tags: ["Uom"]
-}).get("/", async ({ query }) => logic_default47.select(query), {
-  query: model_default47.select
-}).post("/", async ({ body }) => logic_default47.create(body), {
-  body: model_default47.create
+}).get("/", async ({ query }) => logic_default49.select(query), {
+  query: model_default49.select
+}).post("/", async ({ body }) => logic_default49.create(body), {
+  body: model_default49.create
 }).guard({
   params: IdSchema
-}).put("/:id", async ({ body, params: { id } }) => logic_default47.update(id, body), {
-  body: model_default47.update
-}).delete("/:id", async ({ params: { id } }) => logic_default47.remove(id));
+}).put("/:id", async ({ body, params: { id } }) => logic_default49.update(id, body), {
+  body: model_default49.update
+}).delete("/:id", async ({ params: { id } }) => logic_default49.remove(id));
 var uom_default = uomSchemaRoutes;
 
 // src/routes/index.ts

package/package.json

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