@tagsamurai/fats-api-services 1.0.0-alpha.246 → 1.0.0-alpha.248

package/api-services.es.js

@@ -1892,6 +1892,123 @@ const RoutineServices = {
   },
   putSetActive: (body) => {
     return API$5.put("/maintenable-asset/set-active", body);
+  },
+  getRoutineTask: (params) => {
+    return API$5.get("/routine-task", { params });
+  },
+  getRoutineTaskOptions: (params) => {
+    return API$5.get("/routine-task/options", { params });
+  },
+  getRoutineSchedule: (params) => {
+    return API$5.get("/routine-schedule", { params });
+  },
+  getRoutineScheduleOptions: (params) => {
+    return API$5.get("/routine-schedule/options", { params });
+  },
+  getRoutineTaskEventLog: (params) => {
+    return API$5.get("/routine-task/event-log", { params });
+  },
+  getRoutineTaskEventLogOptions: (params) => {
+    return API$5.get("/routine-task/event-log/options", { params });
+  },
+  getAssetName: (params) => {
+    return API$5.get("/asset-name", { params });
+  },
+  getAssetNameOptions: (params) => {
+    return API$5.get("/asset-name/options", { params });
+  },
+  postCreateRoutineSchedule: (data) => {
+    return API$5.post("/routine-schedule", data);
+  },
+  postDuplicateRoutineSchedule: (id, data) => {
+    return API$5.post(`/routine-schedule/duplicate/${id}`, data);
+  },
+  putEditRoutineSchedule: (id, data) => {
+    return API$5.put(`/routine-schedule/${id}`, data);
+  },
+  getUserStaff: (params) => {
+    return API$5.get("/user-transaction-role/maintenance-role/staff", { params });
+  },
+  getUserStaffOptions: (params) => {
+    return API$5.get("/user-transaction-role/maintenance-role/staff/options", {
+      params
+    });
+  },
+  getRoutineScheduleDetail: (id) => {
+    return API$5.get(`/routine-schedule/${id}`);
+  },
+  deleteRoutineSchedule: (id) => {
+    return API$5.delete("/routine-schedule/bulk-delete", {
+      params: {
+        id: JSON.stringify(id)
+      }
+    });
+  },
+  putRoutineTaskCancel: (id) => {
+    return API$5.put("/routine-task/cancel", { id });
+  },
+  getMaintainableAsset: (params) => {
+    return API$5.get("/maintenable-asset", { params });
+  },
+  getMaintainableAssetOptions: (params) => {
+    return API$5.get("/maintenable-asset/options", { params });
+  },
+  getMaintenanceHistory: (params) => {
+    return API$5.get("/routine-task/history", { params });
+  },
+  getMaintenanceHistoryOptions: (params) => {
+    return API$5.get("/routine-task/history/options", { params });
+  },
+  getActiveAsset: (id) => {
+    return API$5.get(`/routine-schedule/${id}/assets`);
+  },
+  getActiveAssetOptions: (id, params) => {
+    return API$5.get(`/routine-schedule/${id}/assets/options`, { params });
+  },
+  getRoutineTaskDetail: (id) => {
+    return API$5.get(`/routine-task/${id}/detail`);
+  },
+  getApproverList: (id, approvalRound) => {
+    return API$5.get(`/routine-task/${id}/approval-history`, {
+      params: {
+        approvalRound
+      }
+    });
+  },
+  getReviewerList: (id) => {
+    return API$5.get(`/routine-task/${id}/review-history`);
+  },
+  getMaintainableAssetDetail: (id) => {
+    return API$5.get(`/maintenable-asset/${id}`);
+  },
+  putSetActiveTasks: (id, isActive) => {
+    return API$5.put(`/maintenable-asset/${id}/set-tasks-active`, {
+      isActive
+    });
+  },
+  putAssignStaff: (routineId, staffId) => {
+    return API$5.put(`/routine-task/${routineId}/assign-staff`, {
+      id: staffId
+    });
+  },
+  getServiceCenter: () => {
+    return API$5.get("/service-center/dropdown");
+  },
+  putCompleteRoutineTask: (id, data) => {
+    const headers = { "Content-Type": "multipart/form-data" };
+    return API$5.put(`/routine-task/${id}/completion`, data, { headers });
+  },
+  getApprovalDetail: (id) => {
+    return API$5.get(`/approval/${id}`);
+  },
+  putApprovalApprove: (id, data) => {
+    return API$5.put(`/approval/${id}/approve`, data);
+  },
+  putReviewRoutine: (id, data) => {
+    return API$5.put(`/routine-task/${id}/review`, data);
+  },
+  putUpdateRoutineTask: (id, data) => {
+    return API$5.put(`/routine-task/${id}/handle-overdue`, data);
   }
 };
 const API$4 = createAxiosInstance({

package/api-services.system.js

@@ -1899,6 +1899,123 @@ System.register(["axios"], function(exports, module) {
         },
         putSetActive: (body) => {
           return API$5.put("/maintenable-asset/set-active", body);
+        },
+        getRoutineTask: (params) => {
+          return API$5.get("/routine-task", { params });
+        },
+        getRoutineTaskOptions: (params) => {
+          return API$5.get("/routine-task/options", { params });
+        },
+        getRoutineSchedule: (params) => {
+          return API$5.get("/routine-schedule", { params });
+        },
+        getRoutineScheduleOptions: (params) => {
+          return API$5.get("/routine-schedule/options", { params });
+        },
+        getRoutineTaskEventLog: (params) => {
+          return API$5.get("/routine-task/event-log", { params });
+        },
+        getRoutineTaskEventLogOptions: (params) => {
+          return API$5.get("/routine-task/event-log/options", { params });
+        },
+        getAssetName: (params) => {
+          return API$5.get("/asset-name", { params });
+        },
+        getAssetNameOptions: (params) => {
+          return API$5.get("/asset-name/options", { params });
+        },
+        postCreateRoutineSchedule: (data) => {
+          return API$5.post("/routine-schedule", data);
+        },
+        postDuplicateRoutineSchedule: (id, data) => {
+          return API$5.post(`/routine-schedule/duplicate/${id}`, data);
+        },
+        putEditRoutineSchedule: (id, data) => {
+          return API$5.put(`/routine-schedule/${id}`, data);
+        },
+        getUserStaff: (params) => {
+          return API$5.get("/user-transaction-role/maintenance-role/staff", { params });
+        },
+        getUserStaffOptions: (params) => {
+          return API$5.get("/user-transaction-role/maintenance-role/staff/options", {
+            params
+          });
+        },
+        getRoutineScheduleDetail: (id) => {
+          return API$5.get(`/routine-schedule/${id}`);
+        },
+        deleteRoutineSchedule: (id) => {
+          return API$5.delete("/routine-schedule/bulk-delete", {
+            params: {
+              id: JSON.stringify(id)
+            }
+          });
+        },
+        putRoutineTaskCancel: (id) => {
+          return API$5.put("/routine-task/cancel", { id });
+        },
+        getMaintainableAsset: (params) => {
+          return API$5.get("/maintenable-asset", { params });
+        },
+        getMaintainableAssetOptions: (params) => {
+          return API$5.get("/maintenable-asset/options", { params });
+        },
+        getMaintenanceHistory: (params) => {
+          return API$5.get("/routine-task/history", { params });
+        },
+        getMaintenanceHistoryOptions: (params) => {
+          return API$5.get("/routine-task/history/options", { params });
+        },
+        getActiveAsset: (id) => {
+          return API$5.get(`/routine-schedule/${id}/assets`);
+        },
+        getActiveAssetOptions: (id, params) => {
+          return API$5.get(`/routine-schedule/${id}/assets/options`, { params });
+        },
+        getRoutineTaskDetail: (id) => {
+          return API$5.get(`/routine-task/${id}/detail`);
+        },
+        getApproverList: (id, approvalRound) => {
+          return API$5.get(`/routine-task/${id}/approval-history`, {
+            params: {
+              approvalRound
+            }
+          });
+        },
+        getReviewerList: (id) => {
+          return API$5.get(`/routine-task/${id}/review-history`);
+        },
+        getMaintainableAssetDetail: (id) => {
+          return API$5.get(`/maintenable-asset/${id}`);
+        },
+        putSetActiveTasks: (id, isActive) => {
+          return API$5.put(`/maintenable-asset/${id}/set-tasks-active`, {
+            isActive
+          });
+        },
+        putAssignStaff: (routineId, staffId) => {
+          return API$5.put(`/routine-task/${routineId}/assign-staff`, {
+            id: staffId
+          });
+        },
+        getServiceCenter: () => {
+          return API$5.get("/service-center/dropdown");
+        },
+        putCompleteRoutineTask: (id, data) => {
+          const headers = { "Content-Type": "multipart/form-data" };
+          return API$5.put(`/routine-task/${id}/completion`, data, { headers });
+        },
+        getApprovalDetail: (id) => {
+          return API$5.get(`/approval/${id}`);
+        },
+        putApprovalApprove: (id, data) => {
+          return API$5.put(`/approval/${id}/approve`, data);
+        },
+        putReviewRoutine: (id, data) => {
+          return API$5.put(`/routine-task/${id}/review`, data);
+        },
+        putUpdateRoutineTask: (id, data) => {
+          return API$5.put(`/routine-task/${id}/handle-overdue`, data);
         }
       });
       const API$4 = createAxiosInstance({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tagsamurai/fats-api-services",
-  "version": "1.0.0-alpha.246",
+  "version": "1.0.0-alpha.248",
   "author": "developer.tagsamurai",
   "description": "Fixed Asset Tag Samurai Services Library",
   "module": "./api-services.es.js",

package/src/dto/maintenanceRoutine.dto.d.ts

@@ -10,3 +10,52 @@ export interface SetActiveRoutineDto {
     isActive: boolean;
     id: (string | undefined)[];
 }
+export interface PostCreateScheduleDTO {
+    taskName: string;
+    nextSchedule: Date | string | number;
+    frequency: {
+        label: string;
+        customValue: number;
+        customUnit: string;
+    };
+    duration: number;
+    maintenanceIndicator: string;
+    assetNames: {
+        _id: string;
+        group: string;
+    }[];
+    staff?: string[];
+}
+export interface PutEditScheduleDTO {
+    taskName: string;
+    nextSchedule: Date | string;
+    frequency: {
+        label: string;
+        customValue: number;
+        customUnit: string;
+    };
+    duration: number;
+    maintenanceIndicator: string;
+    staff?: string[];
+}
+export interface PutCompleteRoutineTaskDTO {
+    notes?: string;
+    maintenanceIndicator: string;
+    serviceCenterId?: string;
+    totalAdditionalCost?: {
+        currency: string;
+        value: number;
+    };
+    maintenanceImage?: File;
+    paymentProof?: File;
+    serialNumber: string;
+}
+export interface PutUpdateRoutineTaskDTO {
+    action: string;
+    duration?: number;
+    notes?: string;
+}
+export interface PutRoutineApprovalDTO {
+    isApproved: boolean;
+    notes?: string;
+}

package/src/services/oldMaintenanceRoutine.service.d.ts

@@ -1,11 +1,45 @@
 import { AxiosResponse } from 'axios';
 import { GetAssetMaintenanceOptionBoolean, GetAssetMaintenanceOptionFilter } from '../dto/assetDetail.dto';
-import { AssetMaintenanceFilterParams, SetActiveRoutineDto } from '../dto/maintenanceRoutine.dto';
-import { FetchListResponse, FetchOptionResponse } from '../types/fetchResponse.type';
-import { MaintenanceType } from '../types/maintenanceRoutine.type';
+import { AssetMaintenanceFilterParams, PostCreateScheduleDTO, PutCompleteRoutineTaskDTO, PutEditScheduleDTO, PutRoutineApprovalDTO, PutUpdateRoutineTaskDTO, SetActiveRoutineDto } from '../dto/maintenanceRoutine.dto';
+import { FetchListResponse, FetchOptionResponse, QueryParams } from '../types/fetchResponse.type';
+import { AssetNameResponse, LoadingFilters, MaintainableAssetDetailResponse, MaintenanceType, RoutineApprovalResponse, RoutineScheduleDetailResponse, RoutineScheduleResponse, RoutineTaskDetailResponse, RoutineTaskResponse, ScheduleActiveAssetResponse } from '../types/maintenanceRoutine.type';
 declare const RoutineServices: {
     getMaintenance: (assetId?: string, params?: AssetMaintenanceFilterParams) => Promise<AxiosResponse<FetchListResponse<MaintenanceType>>>;
     getMaintenanceOption: (assetId?: string, params?: GetAssetMaintenanceOptionBoolean) => Promise<AxiosResponse<FetchOptionResponse<GetAssetMaintenanceOptionFilter>>>;
     putSetActive: (body: SetActiveRoutineDto) => Promise<AxiosResponse>;
+    getRoutineTask: (params: QueryParams) => Promise<AxiosResponse<RoutineTaskResponse>>;
+    getRoutineTaskOptions: (params: LoadingFilters) => Promise<AxiosResponse>;
+    getRoutineSchedule: (params: QueryParams) => Promise<AxiosResponse<RoutineScheduleResponse>>;
+    getRoutineScheduleOptions: (params: LoadingFilters) => Promise<AxiosResponse>;
+    getRoutineTaskEventLog: (params: QueryParams) => Promise<AxiosResponse>;
+    getRoutineTaskEventLogOptions: (params: LoadingFilters) => Promise<AxiosResponse>;
+    getAssetName: (params: QueryParams) => Promise<AxiosResponse<AssetNameResponse>>;
+    getAssetNameOptions: (params: LoadingFilters) => Promise<AxiosResponse>;
+    postCreateRoutineSchedule: (data: PostCreateScheduleDTO) => Promise<AxiosResponse>;
+    postDuplicateRoutineSchedule: (id: string, data: PostCreateScheduleDTO) => Promise<AxiosResponse>;
+    putEditRoutineSchedule: (id: string, data: PutEditScheduleDTO) => Promise<AxiosResponse>;
+    getUserStaff: (params: QueryParams) => Promise<AxiosResponse>;
+    getUserStaffOptions: (params: QueryParams) => Promise<AxiosResponse>;
+    getRoutineScheduleDetail: (id: string) => Promise<AxiosResponse<RoutineScheduleDetailResponse>>;
+    deleteRoutineSchedule: (id: string[]) => Promise<AxiosResponse>;
+    putRoutineTaskCancel: (id: string[]) => Promise<AxiosResponse>;
+    getMaintainableAsset: (params: QueryParams) => Promise<AxiosResponse>;
+    getMaintainableAssetOptions: (params: LoadingFilters) => Promise<AxiosResponse>;
+    getMaintenanceHistory: (params: QueryParams) => Promise<AxiosResponse>;
+    getMaintenanceHistoryOptions: (params: LoadingFilters) => Promise<AxiosResponse>;
+    getActiveAsset: (id: string) => Promise<AxiosResponse<ScheduleActiveAssetResponse>>;
+    getActiveAssetOptions: (id: string, params: LoadingFilters) => Promise<AxiosResponse>;
+    getRoutineTaskDetail: (id: string) => Promise<AxiosResponse<RoutineTaskDetailResponse>>;
+    getApproverList: (id: string, approvalRound: number) => Promise<AxiosResponse>;
+    getReviewerList: (id: string) => Promise<AxiosResponse>;
+    getMaintainableAssetDetail: (id: string) => Promise<AxiosResponse<MaintainableAssetDetailResponse>>;
+    putSetActiveTasks: (id: string, isActive: boolean) => Promise<AxiosResponse>;
+    putAssignStaff: (routineId: string, staffId: string[]) => Promise<AxiosResponse>;
+    getServiceCenter: () => Promise<AxiosResponse>;
+    putCompleteRoutineTask: (id: string, data: PutCompleteRoutineTaskDTO) => Promise<AxiosResponse>;
+    getApprovalDetail: (id: string) => Promise<AxiosResponse<RoutineApprovalResponse>>;
+    putApprovalApprove: (id: string, data: PutRoutineApprovalDTO) => Promise<AxiosResponse>;
+    putReviewRoutine: (id: string, data: PutRoutineApprovalDTO) => Promise<AxiosResponse>;
+    putUpdateRoutineTask: (id: string, data: PutUpdateRoutineTaskDTO) => Promise<AxiosResponse>;
 };
 export default RoutineServices;

package/src/types/maintenanceRoutine.type.d.ts

@@ -8,3 +8,427 @@ export type MaintenanceType = {
     nextSchedule?: Date;
     assetSchedule?: string;
 };
+type CommonResponse = {
+    status: number;
+    message: string;
+};
+type DataResponse<T> = CommonResponse & {
+    data: {
+        data: T[];
+        totalRecords: number;
+    };
+};
+type AssetName = {
+    _id: string;
+    totalAssets: number;
+    name: {
+        _id: string;
+        name: string;
+        key: number;
+    };
+    group: {
+        _id: string;
+        name: string;
+        key: number;
+        fullPath: string;
+    };
+};
+export type RoutineTaskResponse = DataResponse<RoutineTask>;
+export type RoutineScheduleResponse = DataResponse<RoutineSchedule>;
+export type AssetNameResponse = DataResponse<AssetName>;
+export type RoutineScheduleDetailResponse = CommonResponse & {
+    data: RoutineScheduleDetail;
+};
+export type ScheduleActiveAssetResponse = DataResponse<ScheduleActiveAsset>;
+export type RoutineTaskDetailResponse = CommonResponse & {
+    data: RoutineTaskDetail;
+};
+export type MaintainableAssetDetailResponse = CommonResponse & {
+    data: MaintainableAssetDetail;
+};
+export type RoutineApprovalResponse = CommonResponse & {
+    data: RoutineApproval;
+};
+export type RoutineTaskStatus = 'On Schedule' | 'Waiting for Assignment' | 'Under Maintenance' | 'Waiting for Review' | 'Waiting for Approval' | 'Overdue';
+export type RoutineTaskTransactionLog = {
+    _id: string;
+    type: string;
+    transaction: string;
+    transactionId: string;
+    action: string;
+    userId: string;
+    userFullName: string;
+    detail: {
+        notes?: string;
+    };
+    createdAt: Date | string;
+    updatedAt: Date | string;
+};
+export type RoutineTask = {
+    _id: string;
+    assetName: {
+        _id: string;
+        nameWithSequence: string;
+        name: string;
+        key: number;
+    };
+    assetBrand: {
+        _id: string;
+        name: string;
+        key: number;
+    };
+    assetModel: {
+        _id: string;
+        name: string;
+        key: number;
+    };
+    assetGroup: {
+        _id: string;
+        name: string;
+        key: number;
+    };
+    assetImageSmall?: string;
+    assetImageMedium?: string;
+    assetImageBig?: string;
+    taskName: string;
+    status: RoutineTaskStatus;
+    updatedAt: Date | string;
+    isManager: boolean;
+    isStaff: boolean;
+    isMonitoring: boolean;
+    asset: string;
+};
+export type RoutineTaskDetail = {
+    request: {
+        _id: string;
+        assetName: {
+            _id: string;
+            nameWithSequence: string;
+            name: string;
+            key: number;
+        };
+        assetBrand: {
+            _id: string;
+            name: string;
+            key: number;
+        };
+        assetModel: {
+            _id: string;
+            name: string;
+            key: number;
+        };
+        assetGroup: {
+            _id: string;
+            name: string;
+            key: number;
+        };
+        status: MaintenanceHistoryStatus | RoutineTaskStatus | 'Finished Approval' | 'Need Approval';
+        schedule: string;
+        taskName: string;
+        maintenanceIndicator: MaintenanceIndicator[];
+        staff: [
+            {
+                _id: string;
+                fullName: string;
+                key: number;
+            }
+        ];
+        asset: string;
+        assetQr: boolean;
+        assetRfid: boolean;
+        createdAt: Date | string;
+        updatedAt: Date | string;
+        additionalCost: {
+            currency: string;
+            totalPrice: number;
+            paymentProof: string;
+        };
+        maintenanceImageBig: string;
+        maintenanceImageMedium: string;
+        maintenanceImageSmall: string;
+        notes: string;
+        serviceCenterId: string;
+        serviceCenterName: string;
+        duration: number;
+        assetCategory: {
+            _id: string;
+            name: string;
+            key: number;
+        };
+        warrantyEndDate: Date | string;
+        assetStatus: string;
+        assetId: string;
+        isManager: boolean;
+        isStaff: boolean;
+        tagReported?: {
+            rfid: boolean;
+            qr: boolean;
+        };
+        approvalRound: number;
+    };
+    logs: RoutineTaskTransactionLog[];
+};
+export type RoutineSchedule = {
+    _id: string;
+    taskName: string;
+    assetName: {
+        _id: string;
+        name: string;
+        key: number;
+    };
+    assetGroup: {
+        _id: string;
+        name: string;
+        key: number;
+    };
+    frequency: {
+        label: string;
+    };
+    nextSchedule: Date | string;
+    modifiedBy: {
+        _id: string;
+        fullName: string;
+        key: number;
+    };
+    maintainableAssets: number;
+    activeAssets: number;
+    updatedAt: Date | string;
+};
+export type RoutineScheduleDetail = {
+    assetName: {
+        _id: string;
+        name: string;
+        key: number;
+    };
+    assetGroup: {
+        _id: string;
+        name: string;
+        key: number;
+        fullPath: string;
+    };
+    frequency: {
+        label: string;
+    };
+    createdBy: {
+        _id: string;
+        fullName: string;
+        key: number;
+    };
+    modifiedBy: {
+        _id: string;
+        fullName: string;
+        key: number;
+    };
+    _id: string;
+    taskName: string;
+    nextSchedule: Date | string;
+    duration: number;
+    maintenanceIndicator: MaintenanceIndicator[];
+    staff: {
+        _id: string;
+        fullName: string;
+        key: number;
+    }[];
+    createdAt: Date | string;
+    updatedAt: Date | string;
+};
+export type EventLog = {
+    createdAt: Date | string;
+    action: string;
+    nameWithSequence: string;
+    task: string;
+    group: string;
+    modifiedBy: string;
+};
+export type Staff = {
+    _id: string;
+    user: {
+        _id: string;
+        fullName: string;
+        key: number;
+    };
+    group: {
+        _id: string;
+        name: string;
+        key: number;
+    };
+    profilePictureSmall: string;
+    profilePictureMedium: string;
+    profilePictureBig: string;
+    employeeId: string;
+    email: string;
+    phoneNumber: string;
+    position: string;
+    division: string;
+};
+export type IndicatorType = 'Selection' | 'Single Value' | 'Range Value';
+export type DataType = 'Text' | 'Number';
+export type MaintenanceIndicator = {
+    _id?: string;
+    name: string;
+    indicatorType: IndicatorType;
+    dataType: DataType;
+    isMandatory: boolean;
+    isHaveStandardValue: boolean;
+    options?: (string | undefined)[];
+    /**
+     * Stringified array [standard1, standard2]
+     */
+    standard?: string;
+    measurement: string;
+    standardType?: 'Single Value' | 'Range Value';
+    standardValue?: string | number;
+    minStandardValue?: string | number;
+    maxStandardValue?: string | number;
+    optionsKey?: (string | number)[];
+    isSingleText: boolean;
+    isSingleNumber: boolean;
+    isRangeNumber: boolean;
+    isSelection: boolean;
+    value?: string | number;
+    minValue?: number;
+    maxValue?: number;
+    standardLabel?: string;
+};
+type ScheduleActiveAsset = {
+    _id: string;
+    assetName: {
+        _id: string;
+        name: string;
+        nameWithSequence: string;
+        key: number;
+    };
+    assetBrand: {
+        _id: string;
+        name: string;
+        key: number;
+    };
+    assetModel: {
+        _id: string;
+        name: string;
+        key: number;
+    };
+    isActive: boolean;
+    isActiveStr: string;
+    updatedAt: Date | string;
+    imageSmall: string;
+    imageMedium: string;
+    imageBig: string;
+};
+export type MaintenanceHistoryStatus = 'Completed' | 'Canceled' | 'Reported Damaged' | 'Stopped';
+export type MaintainableAssetDetail = {
+    detail: {
+        name: {
+            _id: string;
+            nameWithSequence: string;
+            name: string;
+            key: number;
+            aliasCode: string;
+        };
+        qr: boolean;
+        rfid: boolean;
+        group: {
+            _id: string;
+            name: string;
+            fullPath: string;
+            key: number;
+        };
+        _id: string;
+        assetId: string;
+        imageSmall: string;
+        imageBig: string;
+        imageMedium: string;
+    };
+    allTask: number;
+    activeTask: number;
+    tasks: {
+        frequency: {
+            label: string;
+        };
+        _id: string;
+        schedule: string;
+        task: string;
+        taskName: string;
+        isActive: boolean;
+        nextSchedule: Date | string;
+        maintenanceIndicator: MaintenanceIndicator[];
+    }[];
+};
+export type RoutineApproval = {
+    _id: string;
+    isApproved: boolean | null;
+    notes: string | null;
+    routine: {
+        _id: string;
+        assetName: {
+            _id: string;
+            nameWithSequence: string;
+            name: string;
+            key: number;
+        };
+        assetBrand: {
+            _id: string;
+            name: string;
+            key: number;
+        };
+        assetModel: {
+            _id: string;
+            name: string;
+            key: number;
+        };
+        assetGroup: {
+            _id: string;
+            name: string;
+            key: number;
+        };
+        status: string;
+        taskName: string;
+        maintenanceIndicator: MaintenanceIndicator[];
+        createdAt: Date | string;
+        updatedAt: Date | string;
+        additionalCost: {
+            currency?: string | null;
+            totalPrice: number | null;
+            paymentProof?: string | null;
+        };
+        serviceCenterId?: string | null;
+        serviceCenterName?: string | null;
+        assetImageBig?: string | null;
+        assetImageMedium?: string | null;
+        assetImageSmall?: string | null;
+        maintenanceImageBig?: string | null;
+        maintenanceImageMedium?: string | null;
+        maintenanceImageSmall?: string | null;
+        assetAliasCode?: string | null;
+        assetId: string;
+        assetCategory: {
+            _id: string;
+            name: string;
+            fullPath: string;
+            key: number;
+        };
+        warrantyEndDate?: Date | string | null;
+        assetStatus: string;
+        asset: string;
+    };
+};
+export type LoadingFilters = {
+    assetGroupOptions?: boolean;
+    assetGroupOption?: boolean;
+    assetNameOption?: boolean;
+    assetNameOptions?: boolean;
+    assetBrandOption?: boolean;
+    assetModelOption?: boolean;
+    actionOptions?: boolean;
+    taskNameOptions?: boolean;
+    modifiedByOptions?: boolean;
+    nameOptions?: boolean;
+    brandOptions?: boolean;
+    modelOptions?: boolean;
+    assetBrandOptions?: boolean;
+    assetModelOptions?: boolean;
+    groupOptions?: boolean;
+    positionOptions?: boolean;
+    divisionOptions?: boolean;
+};
+export {};

package/src/types/notification.type.d.ts

@@ -6,7 +6,7 @@ export type NotificationItemType = {
     isManager?: boolean;
     isRead: boolean;
     isReadOnly: boolean;
-    module: 'Borrow' | 'Assignment' | 'Transfer' | 'Disposal' | 'Audit' | 'Maintenance Routine' | 'Repair Ticketing' | 'Tracking' | 'TAG' | 'General Asset';
+    module: 'Borrow' | 'Assignment' | 'Transfer' | 'Disposal' | 'Audit' | 'Maintenance Routine' | 'Damage' | 'Missing' | 'Repair Ticketing' | 'Tracking' | 'TAG' | 'General Asset';
     severity: string;
     type: string;
     data: {