npm_microservice 1.0.36 → 1.0.39

package/dist/services/hr/ScheduleAutomationService.js

@@ -0,0 +1,461 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// src/config.js
+var require_config = __commonJS({
+  "src/config.js"(exports2, module2) {
+    require("dotenv").config({ quiet: true, override: true });
+    var Redis = require("ioredis");
+    var redis = new Redis({
+      host: process.env.REDIS_HOST || "128.199.195.180",
+      port: process.env.REDIS_PORT || 6379,
+      password: process.env.REDIS_PASSWORD || "WZyB5Z7BRRgvrzuGzRwB"
+    });
+    var baseUrl = process.env.API_MICROSERVICE_URL;
+    var configRouteService = {
+      BASE_URL: baseUrl,
+      Finance: {
+        InvoicesService: `${baseUrl}/finance/invoices`,
+        InvoicesCancelService: `${baseUrl}/finance/invoice_detail_cancel`,
+        InvoicesDetailService: `${baseUrl}/finance/invoices-detail`,
+        InvoicesLogsAssignService: `${baseUrl}/finance/invoices-logs-assign`,
+        PaymentService: `${baseUrl}/finance/payments`,
+        PaymentRequestService: `${baseUrl}/finance/payments-request`,
+        VouchersService: `${baseUrl}/finance/vouchers`,
+        VouchersCategoryService: `${baseUrl}/finance/vouchers-category`,
+        WalletsService: `${baseUrl}/finance/wallets`,
+        WalletTransactionService: `${baseUrl}/finance/wallet-transaction`
+      },
+      CallCenter: {
+        CategoryService: `${baseUrl}/call-center/ticket-categories`,
+        TicketService: `${baseUrl}/call-center/ticket`,
+        TicketActivityService: `${baseUrl}/call-center/ticket-activities`,
+        TicketTemplateService: `${baseUrl}/call-center/ticket-template`,
+        TicketTopicService: `${baseUrl}/call-center/ticket-topics`,
+        CallService: `${baseUrl}/call-center/calls`
+      },
+      Inventory: {
+        InventoryService: `${baseUrl}/inventory/inventory-products`,
+        LogService: `${baseUrl}/inventory/logs`,
+        ProductService: `${baseUrl}/inventory/products`,
+        ProductShipmentService: `${baseUrl}/inventory/products_shipment`,
+        StoreService: `${baseUrl}/inventory/stores`,
+        SupplierService: `${baseUrl}/inventory/supplier`,
+        TransactionService: `${baseUrl}/inventory/transaction`,
+        TransactionDetailService: `${baseUrl}/inventory/transaction_detail`
+      },
+      App: {
+        CategoryService: `${baseUrl}/app/category`,
+        NewService: `${baseUrl}/app/news`,
+        BannerService: `${baseUrl}/app/banner`,
+        AppTestService: `${baseUrl}/app/test`,
+        RecommendedCourseService: `${baseUrl}/app/recommended_level`,
+        SettingAppService: `${baseUrl}/app/setting`,
+        TargetAppService: `${baseUrl}/app/target`
+      },
+      Course: {
+        CategoryService: `${baseUrl}/course/category`,
+        CourseService: `${baseUrl}/course/course`,
+        CourseLessonService: `${baseUrl}/course/course_schedule`,
+        StudentService: `${baseUrl}/course/students`
+      },
+      Asset: {
+        AllocationDetailService: `${baseUrl}/asset/asset-allocation-detail`,
+        BroadcastService: `${baseUrl}/asset/broadcast`,
+        EntityAssetService: `${baseUrl}/asset/entity-asset`,
+        SubAssetService: `${baseUrl}/asset/sub-asset`
+      },
+      Test: {
+        TestService: `${baseUrl}/tests/tests`
+      },
+      Pm: {
+        NoteService: `${baseUrl}/pm/notes`,
+        TaskService: `${baseUrl}/pm/tasks`
+      },
+      Crm: {
+        ContactService: `${baseUrl}/crm/contacts`,
+        AccountsService: `${baseUrl}/crm/accounts`,
+        CalendarContactService: `${baseUrl}/crm/calendar-contact`,
+        CalendarsService: `${baseUrl}/crm/calendars`,
+        CampaignService: `${baseUrl}/crm/campaigns`,
+        CompanyService: `${baseUrl}/crm/company`,
+        ContactDocumentService: `${baseUrl}/crm/contact-document`,
+        ContactToCampaignService: `${baseUrl}/crm/contacts-campaign`,
+        DeviceService: `${baseUrl}/crm/devices`,
+        LeadsService: `${baseUrl}/crm/leads`,
+        NotificationService: `${baseUrl}/crm/notifications`,
+        NotificationContactService: `${baseUrl}/crm/notification-to-contact`,
+        OpportunitiesService: `${baseUrl}/crm/opportunities`,
+        SegmentsService: `${baseUrl}/crm/segments`
+      },
+      Notification: {
+        AppService: `${baseUrl}/notification/type/app`,
+        MailService: `${baseUrl}/notification/type/mail`,
+        SmsService: `${baseUrl}/notification/type/sms`,
+        ZnsService: `${baseUrl}/notification/type/zns`,
+        NotificationContactService: `${baseUrl}/notification/notification_contact`,
+        NotificationEmployeeService: `${baseUrl}/notification/notification_employee`,
+        NotificationService: `${baseUrl}/notification`,
+        TemplateService: `${baseUrl}/notification/template`
+      },
+      Org: {
+        BranchService: `${baseUrl}/org/branch`,
+        BranchRequestService: `${baseUrl}/org/branch_request`,
+        BranchToMacsService: `${baseUrl}/org/branch_to_mac`,
+        BrandService: `${baseUrl}/org/brand`,
+        CitiesService: `${baseUrl}/org/city`,
+        LegalEntityService: `${baseUrl}/org/legal_entities`
+      },
+      Lms: {
+        AlbumService: `${baseUrl}/lms/album`,
+        AlbumCategoryService: `${baseUrl}/lms/cate_album`,
+        AlbumFileService: `${baseUrl}/lms/album_file`,
+        ClassesService: `${baseUrl}/lms/classes`,
+        ClassScheduleService: `${baseUrl}/lms/class-schedules`,
+        CourseLessonService: `${baseUrl}/lms/course-lessons`,
+        CoursePriceService: `${baseUrl}/lms/course-prices`,
+        CourseProductService: `${baseUrl}/lms/course-product`,
+        CourseService: `${baseUrl}/lms/courses`,
+        DocumentService: `${baseUrl}/lms/documents`,
+        DocumentCategoryService: `${baseUrl}/lms/document-categories`,
+        LicenseService: `${baseUrl}/lms/license`,
+        PracticeResultService: `${baseUrl}/lms/practices-result`,
+        PracticeService: `${baseUrl}/lms/practices`,
+        StudentAgainService: `${baseUrl}/lms/students-agains`,
+        StudentDocumentService: `${baseUrl}/lms/students-documents`,
+        StudentExamTimeService: `${baseUrl}/lms/student-exam-time`,
+        StudentReviewService: `${baseUrl}/lms/students-reviews`,
+        StudentService: `${baseUrl}/lms/students`,
+        StudentScoreService: `${baseUrl}/lms/students-scores`,
+        StudentSettingReviewService: `${baseUrl}/lms/setting-reviews`,
+        StudentTrackingService: `${baseUrl}/lms/students-tracking`,
+        StudentTrialService: `${baseUrl}/lms/students-trial`
+      },
+      Hr: {
+        ConfigurationsService: `${baseUrl}/hr/configurations`,
+        GroupService: `${baseUrl}/hr/groups`,
+        AllowanceService: `${baseUrl}/hr/allowance`,
+        LeaveService: `${baseUrl}/hr/leave`,
+        AnnualLeaveService: `${baseUrl}/hr/annual_leave`,
+        EmployeeLeaveService: `${baseUrl}/hr/employee_leave`,
+        EmployeeService: `${baseUrl}/hr/employees`,
+        DepartmentService: `${baseUrl}/hr/departments`,
+        DeviceService: `${baseUrl}/hr/device`,
+        DocumentService: `${baseUrl}/hr/documents`,
+        DocumentExtendService: `${baseUrl}/hr/document_extend`,
+        EmployeeExtendService: `${baseUrl}/hr/employees/extend`,
+        EmployeeExtendTempService: `${baseUrl}/hr/employees/extend/temp`,
+        EmployeeNotificationService: `${baseUrl}/hr/notification-employee`,
+        EmployeeQuitService: `${baseUrl}/hr/employee_quit`,
+        EmployeeShiftService: `${baseUrl}/hr/employee_shift`,
+        HolidayService: `${baseUrl}/hr/holidays`,
+        PositionService: `${baseUrl}/hr/positions`,
+        ResignationService: `${baseUrl}/hr/resignations`,
+        SalaryService: `${baseUrl}/hr/employee_salary`,
+        ScheduleService: `${baseUrl}/hr/schedule`,
+        ScheduleOnlineService: `${baseUrl}/hr/schedule_online`,
+        EmployeeAttrTypeService: `${baseUrl}/hr/setting/employee_attr_type`,
+        ReasonTypeService: `${baseUrl}/hr/setting/reason_type`,
+        CategoryService: `${baseUrl}/hr/setting/category`,
+        JobTitleService: `${baseUrl}/hr/setting/job_title`,
+        ShiftService: `${baseUrl}/hr/setting/shifts`,
+        ShiftsCustomerCareService: `${baseUrl}/hr/setting/shifts-customer-care`,
+        SettingProfileService: `${baseUrl}/hr/setting/profile`,
+        SettingCompensationService: `${baseUrl}/hr/setting/compensation`,
+        SettingDocumentService: `${baseUrl}/hr/setting_document`,
+        SettingShiftsService: `${baseUrl}/hr/setting-shifts`,
+        TicketService: `${baseUrl}/hr/ticket`,
+        TicketExtendService: `${baseUrl}/hr/ticket/extend`,
+        TicketTypeService: `${baseUrl}/hr/ticket-type`,
+        TrackingConfirmService: `${baseUrl}/hr/tracking_confirm`,
+        TrackingService: `${baseUrl}/hr/tracking`,
+        TrackingErrorService: `${baseUrl}/hr/tracking-error`,
+        ScheduleDateService: `${baseUrl}/hr/schedule_date`,
+        SalaryTypeService: `${baseUrl}/hr/salary-type`,
+        ScheduleAutomationService: `${baseUrl}/hr/schedule_automation`,
+        OffsetLeaveService: `${baseUrl}/hr/offset_leave`,
+        EmployeeContractService: `${baseUrl}/hr/employee_contract`
+      },
+      Support: {
+        CommentService: `${baseUrl}/support/comment`
+      },
+      Authorization: {
+        RoleService: `${baseUrl}/authorization/roles`,
+        PermissionService: `${baseUrl}/authorization/permissions`,
+        EmployeePermissionService: `${baseUrl}/authorization/employee/permission`,
+        EmployeeService: `${baseUrl}/authorization/employee/services`,
+        EmployeeDetailService: `${baseUrl}/authorization/employee/detail`
+      }
+    };
+    module2.exports = {
+      AUTHENTICATOR_PUBLIC_KEY: process.env.AUTHENTICATOR_PUBLIC_KEY || "",
+      API_MICROSERVICE_URL: process.env.API_MICROSERVICE_URL || "",
+      API_MICROSERVICE_TOKEN: process.env.API_MICROSERVICE_TOKEN || "",
+      CONFIG_ROUTER_SERVICE: configRouteService,
+      CONFIG_REDIS: redis
+    };
+  }
+});
+
+// src/services/CacheService.js
+var require_CacheService = __commonJS({
+  "src/services/CacheService.js"(exports2, module2) {
+    var qs = require("qs");
+    var CacheService = class {
+      isCache = false;
+      // bật/tắt cache mặc định
+      service = null;
+      // nhớ gán ở subclass
+      module = null;
+      // module
+      configService = "microservice";
+      // module
+      timeCache = 3600;
+      // cache 60p
+      redis = null;
+      buildCacheKeyUrl(path, params = {}) {
+        const q = qs.stringify(params, { arrayFormat: "brackets", encode: true });
+        const full = `${path}${q ? "?" + q : ""}`;
+        return `${this.configService}.${this.service || "unknown"}.${this.module || "unknown"}.urls:${full}`;
+      }
+      // Lấy cache theo id
+      async getCacheByKey(key) {
+        const data = await this.redis.get(key);
+        return data ? JSON.parse(data) : null;
+      }
+      // Lấy cache theo id
+      async getCacheById(id) {
+        if (!this.isCache || !this.redis) return null;
+        const key = `${this.configService}.${this.service || "unknown"}.${this.module || "unknown"}.id:${id}`;
+        const data = await this.redis.get(key);
+        return data ? JSON.parse(data) : null;
+      }
+      // Lấy cache theo nhiều ids
+      async getCacheByIds(ids = []) {
+        const validIds = (ids || []).filter(
+          (id) => id !== null && id !== void 0 && id !== ""
+        );
+        if (!this.isCache || !this.redis || !validIds.length) return [];
+        const keys = validIds.map(
+          (id) => `${this.configService}.${this.service || "unknown"}.${this.module || "unknown"}.id:${id}`
+        );
+        const results = await this.redis.mget(keys);
+        return results.map((r) => r ? JSON.parse(r) : null).filter(Boolean);
+      }
+      // Set cache
+      async setCache(key, value, ttl = this.timeCache) {
+        if (!this.isCache || !this.redis) return;
+        await this.redis.set(key, JSON.stringify(value), "EX", ttl);
+      }
+      // Ví dụ set cache theo id
+      async setCacheById(id, value, ttl) {
+        const key = `${this.configService}.${this.service || "unknown"}.${this.module || "unknown"}.id:${id}`;
+        await this.setCache(key, value, ttl);
+      }
+      async deleteById(id) {
+        const key = `${this.configService}.${this.service || "unknown"}.${this.module || "unknown"}.id:${id}`;
+        await this.deleteCache(key);
+      }
+      async deleteByIds(ids = []) {
+        if (!this.isCache || !this.redis) return;
+        const keys = ids.map(
+          (id) => `${this.configService}.${this.service || "unknown"}.${this.module || "unknown"}.id:${id}`
+        );
+        if (keys.length) {
+          await this.redis.del(...keys);
+        }
+      }
+      // Xóa cache theo key
+      async deleteCache(key) {
+        if (!this.isCache || !this.redis) return;
+        await this.redis.del(key);
+      }
+    };
+    module2.exports = CacheService;
+  }
+});
+
+// src/services/BaseService.js
+var require_BaseService = __commonJS({
+  "src/services/BaseService.js"(exports2, module2) {
+    var axios = require("axios");
+    var qs = require("qs");
+    var { API_MICROSERVICE_TOKEN, CONFIG_REDIS } = require_config();
+    var CacheService = require_CacheService();
+    var BaseService2 = class extends CacheService {
+      baseUrl = "";
+      headers = {};
+      constructor(baseUrl = "", defaultHeaders = {}) {
+        super(baseUrl, defaultHeaders);
+        this.baseUrl = baseUrl;
+        this.setHeader(defaultHeaders);
+        this.redis = CONFIG_REDIS;
+        this.http = axios.create({
+          baseURL: this.baseUrl,
+          headers: this.headers,
+          paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "brackets", encode: true })
+        });
+      }
+      /**
+       * Set header cho request
+       * - headers: object { Authorization: "Bearer x" }
+       * - string: "Bearer x"
+       * - không truyền: dùng token từ ENV
+       */
+      setHeader(headers = {}) {
+        let Authorization = `Bearer ${API_MICROSERVICE_TOKEN}`;
+        if (typeof headers === "string") {
+          Authorization = headers;
+        } else if (headers && headers.Authorization) {
+          Authorization = headers.Authorization;
+        }
+        this.headers = {
+          ...this.headers || {},
+          Authorization
+        };
+        return this;
+      }
+      async request(method, url, options = {}, cacheOption = {}) {
+        var _a, _b;
+        const isGet = method.toLowerCase() === "get";
+        const enableCache = cacheOption.isCache ?? false;
+        if (isGet && enableCache) {
+          let cacheKey = (cacheOption == null ? void 0 : cacheOption.cacheKey) ?? this.buildCacheKeyUrl(url, options.params);
+          const cached = await this.getCacheByKey(cacheKey);
+          if (cached) return cached;
+        }
+        try {
+          if (isGet) {
+            console.log(`[HTTP GET] ${this.buildGET(url, options.params || {})}`);
+          }
+          const startTime = Date.now();
+          const res = await this.http.request({
+            method,
+            url,
+            headers: this.headers,
+            ...options
+          });
+          const data = res.data;
+          if (isGet && enableCache) {
+            let cacheKey = cacheOption.cacheKey ?? this.buildCacheKeyUrl(url, options.params);
+            const ttl = cacheOption.timeCache || this.timeCache;
+            await this.setCache(cacheKey, data, ttl);
+            console.log(`[CACHE SET] ${cacheKey} - TTL ${ttl}s`);
+          }
+          const duration = (Date.now() - startTime) / 1e3;
+          if (duration > 5) {
+            console.log(
+              `[SLOW ${method.toUpperCase()}] ${url} - ${duration.toFixed(2)}s`
+            );
+            if (options.params) console.log("Query:", options.params);
+            if (options.data) console.log("Body:", options.data);
+          }
+          return data;
+        } catch (error) {
+          const safeError = {
+            statusCode: ((_a = error.response) == null ? void 0 : _a.status) || 500,
+            ...(_b = error.response) == null ? void 0 : _b.data
+          };
+          if (safeError.statusCode === 404) {
+            const q = qs.stringify(options.params || {}, {
+              arrayFormat: "brackets",
+              encode: true
+            });
+            return {
+              statusCode: 404,
+              status: "error",
+              message: `[HTTP ${method.toUpperCase()}] ${url}${q ? "?" + q : ""} not found`
+            };
+          }
+          console.error(`[${method.toUpperCase()}] ${url} failed:`, safeError);
+          return { error: true, ...safeError };
+        }
+      }
+      buildGET(url, params = {}) {
+        const queryString = qs.stringify(params, {
+          arrayFormat: "brackets",
+          encode: true
+        });
+        return `${url}${queryString ? "?" + queryString : ""}`;
+      }
+      async all(query = {}, cacheOption = {}) {
+        let { filter = {} } = query;
+        const useCache = this.isCache && filter && filter._id && Object.keys(filter).length === 1;
+        if (useCache) {
+          let ids = Array.isArray(filter._id) ? filter._id : [filter._id];
+          return this.details(ids);
+        }
+        if (query.order_by && Array.isArray(query.order_by)) {
+          query.order_by = query.order_by.slice(0, 2);
+          if (query.order_by[1] && !["asc", "desc"].includes(query.order_by[1])) {
+            query.order_by[1] = "asc";
+          }
+        }
+        return this.request("get", this.baseUrl, { params: query }, cacheOption);
+      }
+      async details(ids = [], options = {}, cacheOption = {}) {
+        const enableCache = cacheOption.isCache ?? this.isCache;
+        let dataCache = [];
+        if (enableCache) {
+          dataCache = await this.getCacheByIds(ids);
+          const cachedIds = dataCache.filter((item) => item && Object.keys(item).length > 0).map((item) => item._id);
+          ids = ids.filter((id) => !cachedIds.includes(id));
+        }
+        if (ids.length === 0) return dataCache;
+        let params = { params: { filter: { _id: ids }, limit: ids.length } };
+        const datas = await this.request("get", this.baseUrl, params, cacheOption);
+        const rows = [...dataCache];
+        if (enableCache && Array.isArray(datas) && datas.length) {
+          for (const item of datas) {
+            if (item && item._id) {
+              await this.setCacheById(item._id, item, this.timeCache);
+              rows.push(item);
+            }
+          }
+        }
+        return rows;
+      }
+      async detail(id, cacheOption = {}) {
+        const enableCache = cacheOption.isCache ?? this.isCache;
+        if (enableCache) {
+          let data = await this.getCacheById(id);
+          if (data) return data;
+        }
+        let url = `${this.baseUrl}/${id}`;
+        return this.request("get", url, {}, cacheOption);
+      }
+      async create(data) {
+        return this.request("post", this.baseUrl, { data });
+      }
+      async update(id, data) {
+        let response = this.request("put", `${this.baseUrl}/${id}`, { data });
+        if (response && (response == null ? void 0 : response.status) == "success" && this.isCache) {
+          this.deleteById(id);
+        }
+        return response;
+      }
+      async delete(id) {
+        let response = this.request("delete", `${this.baseUrl}/${id}`);
+        if (response && (response == null ? void 0 : response.status) == "success" && this.isCache) {
+          this.deleteById(id);
+        }
+        return response;
+      }
+    };
+    module2.exports = BaseService2;
+  }
+});
+
+// src/services/hr/ScheduleAutomationService.js
+var BaseService = require_BaseService();
+var { CONFIG_ROUTER_SERVICE } = require_config();
+var ScheduleAutomationService = class extends BaseService {
+  constructor() {
+    super(CONFIG_ROUTER_SERVICE.Hr.ScheduleAutomationService);
+    this.service = "Hr.ScheduleAutomationService";
+    this.isCache = false;
+  }
+};
+module.exports = ScheduleAutomationService;