cc-core-cli 1.0.0

package/template/src/core/core.service.ts

@@ -0,0 +1,715 @@
+import * as _ from "lodash";
+
+import {
+  Inject,
+  Injectable,
+  OnModuleInit,
+} from "@nestjs/common";
+import { ModuleRef } from "@nestjs/core";
+
+
+import { CUSTOM_MODULES } from "src/modules/modules";
+
+import {
+  ActivityLogService,
+  ApiKeyService,
+  AttachmentService,
+  CommentDataService,
+  CustomFunctionService,
+  AddressService,
+  CountryService,
+  ProvinceService,
+  DistrictService,
+  SubdistrictService,
+  TimeZoneService,
+  DeployDestinationService,
+  DeployPackageService,
+  DeployLogService,
+  ExecutionLogService,
+  ImportExportService,
+  ImportExportLogService,
+  LanguageService,
+  MailSettingService,
+  MailLogService,
+  MapLocationService,
+  ReportReportService,
+  ReasonMasterService,
+  ReasonOptionService,
+  ReasonDataService,
+  ScheduleActionService,
+  ScheduleLogService,
+  SFTPSettingService,
+  SftpLogService,
+  SmsService,
+  SmsLogService,
+  TemplateService,
+  TranslateService,
+  NotificationLogService,
+  ShortlyUrlService,
+  LayoutShareWidgetService,
+  SearchResultDto,
+  UserService,
+  UserRoleService,
+  UserRolePermissonService,
+  UserFilterService,
+  VersionDataService,
+  WidgetService,
+  IBaseModuleSettingService,
+  NotificationSubscriptionService,
+  NotificationMessageService,
+  NotificationMessageQueueService,
+} from 'cc-core-lib/core'
+
+const SPECIFY_CUSTOM_MODULES =
+  process.env.CUSTOM_MODULES === "" || process.env.CUSTOM_MODULES === undefined
+    ? []
+    : process.env.CUSTOM_MODULES.split(",");
+
+const RUN_CUSTOM_MODULES =
+  SPECIFY_CUSTOM_MODULES.length === 0
+    ? CUSTOM_MODULES
+    : CUSTOM_MODULES.filter(c =>
+      SPECIFY_CUSTOM_MODULES.includes(c.module.name)
+    );
+
+const CUSTOM_SERVICES = _.reduce(
+  RUN_CUSTOM_MODULES,
+  (r, v) => {
+    const moduleName = _.snakeCase(
+      `${v.module.name.slice(0, 2).toLowerCase()}${v.module.name.slice(2)}`
+    )
+      .toLowerCase()
+      .replace("_module", "");
+    for (const service of v.services || []) {
+      const serviceName = `${service.name
+        .slice(0, 2)
+        .toLowerCase()}${service.name.slice(2)}`;
+      let key = `${moduleName}_${_.snakeCase(serviceName)
+        .toLowerCase()
+        .replace("_service", "")
+        .replace(`${moduleName}_`, "")}`;
+      if (key === "sellers_seller_user") {
+        key = "sellers_user";
+      }
+      r[key] = service;
+    }
+    return r;
+  },
+  {}
+);
+
+const CUSTOM_LOG_SERVICES = _.reduce(
+  RUN_CUSTOM_MODULES,
+  (r, v) => {
+    const moduleName = _.snakeCase(
+      `${v.module.name.slice(0, 2).toLowerCase()}${v.module.name.slice(2)}`
+    )
+      .toLowerCase()
+      .replace("_module", "");
+    for (const service of v.services || []) {
+      const serviceName = _.snakeCase(
+        `${service.name.slice(0, 2).toLowerCase()}${service.name.slice(2)}`
+      )
+        .toLowerCase()
+        .replace("_service", "")
+        .replace(`${moduleName}_`, "");
+      if (serviceName === "log") {
+        const key = `${moduleName}_${serviceName}`;
+        r[key] = service;
+      }
+    }
+    return r;
+  },
+  {}
+);
+
+const CUSTOM_SETTING_SERVICES = _.reduce(
+  RUN_CUSTOM_MODULES,
+  (r, v) => {
+    const moduleName = _.snakeCase(
+      `${v.module.name.slice(0, 2).toLowerCase()}${v.module.name.slice(2)}`
+    )
+      .toLowerCase()
+      .replace("_module", "");
+    for (const service of v.services || []) {
+      const serviceName = _.snakeCase(
+        `${service.name.slice(0, 2).toLowerCase()}${service.name.slice(2)}`
+      )
+        .toLowerCase()
+        .replace("_service", "")
+        .replace(`${moduleName}_`, "");
+      if (serviceName === "setting") {
+        const key = `${moduleName}_${serviceName}`;
+        r[key] = service;
+      }
+    }
+    return r;
+  },
+  {}
+);
+
+@Injectable()
+export class CoreService implements OnModuleInit {
+  @Inject(ActivityLogService)
+  private readonly _activityLogService: ActivityLogService;
+  @Inject(AddressService) private readonly _addressService: AddressService;
+  @Inject(ApiKeyService) private readonly _apiKeyService: ApiKeyService;
+  @Inject(AttachmentService)
+  private readonly _attachmentService: AttachmentService;
+  @Inject(CommentDataService)
+  private readonly _commentDataService: CommentDataService;
+  @Inject(CountryService) private readonly _countryService: CountryService;
+  @Inject(CustomFunctionService)
+  private readonly _customFunctionService: CustomFunctionService;
+  @Inject(DeployDestinationService)
+  private readonly _deployDestinationService: DeployDestinationService;
+  @Inject(DeployLogService)
+  private readonly _deployLogService: DeployLogService;
+  @Inject(DeployPackageService)
+  private readonly _deployPackageService: DeployPackageService;
+  @Inject(DistrictService) private readonly _districtService: DistrictService;
+  @Inject(ExecutionLogService)
+  private readonly _executionLogService: ExecutionLogService;
+  @Inject(ImportExportService)
+  private readonly _importExportService: ImportExportService;
+  @Inject(ImportExportLogService)
+  private readonly _importExportLogService: ImportExportLogService;
+  @Inject(LanguageService)
+  private readonly _languageService: LanguageService;
+  @Inject(LayoutShareWidgetService)
+  private readonly _layoutShareWidgetService: LayoutShareWidgetService;
+  @Inject(MailSettingService)
+  private readonly _mailService: MailSettingService;
+  @Inject(MailLogService)
+  private readonly _mailLogService: MailLogService;
+  @Inject(MapLocationService)
+  private readonly _mapLocationService: MapLocationService;
+  @Inject(NotificationSubscriptionService)
+  private readonly _notificationSubscriptionService: NotificationSubscriptionService;
+  @Inject(NotificationMessageService)
+  private readonly _notificationMessageService: NotificationMessageService;
+  @Inject(NotificationMessageQueueService)
+  private readonly _notificationMessageQueueService: NotificationMessageQueueService;
+  @Inject(NotificationLogService)
+  private readonly _notificationLogService: NotificationLogService;
+  @Inject(ProvinceService) private readonly _provinceService: ProvinceService;
+  @Inject(ReportReportService)
+  private readonly _reportReportService: ReportReportService;
+  @Inject(ReasonDataService)
+  private readonly _reasonDataService: ReasonDataService;
+  @Inject(ReasonMasterService)
+  private readonly _reasonMasterService: ReasonMasterService;
+  @Inject(ReasonOptionService)
+  private readonly _reasonOptionService: ReasonOptionService;
+  @Inject(ScheduleActionService)
+  private readonly _scheduleActionService: ScheduleActionService;
+  @Inject(ScheduleLogService)
+  private readonly _scheduleLogService: ScheduleLogService;
+  @Inject(SFTPSettingService)
+  private readonly _sftpService: SFTPSettingService;
+  @Inject(SftpLogService)
+  private readonly _sftpLogService: SftpLogService;
+  @Inject(ShortlyUrlService)
+  private readonly _shortlyUrlService: ShortlyUrlService;
+  @Inject(SmsService)
+  private readonly _smsService: SmsService;
+  @Inject(SmsLogService)
+  private readonly _smsLogService: SmsLogService;
+  @Inject(SubdistrictService)
+  private readonly _subdistrictService: SubdistrictService;
+  @Inject(TemplateService)
+  private readonly _templateService: TemplateService;
+  @Inject(TimeZoneService) private readonly _timeZoneService: TimeZoneService;
+  @Inject(TranslateService)
+  private readonly _translateService: TranslateService;
+  @Inject(UserFilterService)
+  private readonly _userFilterService: UserFilterService;
+  @Inject(UserRoleService)
+  private readonly _userRoleService: UserRoleService;
+  @Inject(UserRolePermissonService)
+  private readonly _userRolePermissonService: UserRolePermissonService;
+  @Inject(UserService)
+  private readonly _userService: UserService;
+  @Inject(VersionDataService)
+  private readonly _versionDataService: VersionDataService;
+  @Inject(WidgetService)
+  private readonly _widgetService: WidgetService;
+
+  private services: any = {};
+
+  constructor(private moduleRef: ModuleRef) { }
+
+  async onModuleInit() {
+    // console.log(CUSTOM_SERVICES);
+    for (const key of Object.keys(CUSTOM_SERVICES)) {
+      this.services[key] = await this.moduleRef.get(CUSTOM_SERVICES[key], {
+        strict: false
+      });
+    }
+  }
+
+  private async _getService(entityName: string): Promise<any> {
+    switch (entityName) {
+      case "activity_log":
+        return this._activityLogService;
+      case "address":
+        return this._addressService;
+      case "api_key":
+        return this._apiKeyService;
+      case "attachment":
+        return this._attachmentService;
+      case "comment_data":
+        return this._commentDataService;
+      case "country":
+        return this._countryService;
+      case "custom_function":
+        return this._customFunctionService;
+      case "deploy_destination":
+        return this._deployDestinationService;
+      case "deploy_package":
+        return this._deployPackageService;
+      case "deploy_log":
+        return this._deployLogService;
+      case "district":
+        return this._districtService;
+      case "execution_log":
+        return this._executionLogService;
+      case "import_export":
+        return this._importExportService;
+      case "import_export_log":
+        return this._importExportLogService;
+      case "language":
+        return this._languageService;
+      case "layout_share_widget":
+        return this._layoutShareWidgetService;
+      case "mail_setting":
+        return this._mailService;
+      case "mail_log":
+        return this._mailLogService;
+      case "map_location":
+        return this._mapLocationService;
+      case "notification_subscription":
+        return this._notificationSubscriptionService;
+      case "notification_message":
+        return this._notificationMessageService;
+      case "notification_message_queue":
+        return this._notificationMessageQueueService;
+      case "notification_log":
+        return this._notificationLogService;
+      case "province":
+        return this._provinceService;
+      case "report_report":
+        return this._reportReportService;
+      case "reason_data":
+        return this._reasonDataService;
+      case "reason_master":
+        return this._reasonMasterService;
+      case "reason_option":
+        return this._reasonOptionService;
+      case "schedule_action":
+        return this._scheduleActionService;
+      case "schedule_log":
+        return this._scheduleLogService;
+      case "sftp_setting":
+        return this._sftpService;
+      case "sftp_log":
+        return this._sftpLogService;
+      case "shortly_url":
+        return this._shortlyUrlService;
+      case "sms":
+        return this._smsService;
+      case "sms_log":
+        return this._smsLogService;
+      case "subdistrict":
+        return this._subdistrictService;
+      case "template":
+        return this._templateService;
+      case "time_zone":
+        return this._timeZoneService;
+      case "translate":
+        return this._translateService;
+      case "user":
+        return this._userService;
+      case "user_role":
+        return this._userRoleService;
+      case "user_role_permission":
+        return this._userRolePermissonService;
+      case "user_filter":
+        return this._userFilterService;
+      case "version_data":
+        return this._versionDataService;
+      case "widget":
+        return this._widgetService;
+
+      default:
+        const customService = this.services[entityName];
+        if (_.isEmpty(customService)) {
+          throw new Error(`Invalid entity ${entityName}.`);
+        }
+        return customService;
+    }
+  }
+
+  public async init(entityName: string): Promise<string> {
+    const service = await this._getService(entityName);
+    return service.init();
+  }
+
+  public async search(
+    entityName: string,
+    keywords: string,
+    filters?: any,
+    page: number = 1,
+    pageSize: number = 10,
+    sort: string = "",
+    noTranslate?: boolean,
+    fields?: Array<string>
+  ): Promise<SearchResultDto> {
+    const service = await this._getService(entityName);
+    return service.search(
+      keywords,
+      filters,
+      page,
+      pageSize,
+      sort,
+      noTranslate,
+      fields
+    );
+  }
+
+  public async searchIds(
+    entityName: string,
+    keywords: string,
+    filters?: any,
+    page?: number,
+    pagesize?: number,
+    sort?: Object
+  ): Promise<Array<string>> {
+    const service = await this._getService(entityName);
+    return service.searchIds(keywords, filters, page, pagesize, sort);
+  }
+
+  public async searchWithLayout(
+    entityName: string,
+    layoutCode: string,
+    keywords: string,
+    filters?: any,
+    page?: number,
+    pageSize?: number,
+    sort?: any,
+    isDetail?: boolean
+  ): Promise<SearchResultDto> {
+    const service = await this._getService(entityName);
+    return service.searchWithLayout(
+      layoutCode,
+      keywords,
+      filters,
+      page,
+      pageSize,
+      sort,
+      isDetail
+    );
+  }
+
+  public async find(
+    entityName: string,
+    keywords: string,
+    filters?: any,
+    sort: string = "",
+    noTranslate?: boolean,
+    fields?: Array<string>
+  ): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.find(keywords, filters, sort, noTranslate, fields);
+  }
+
+  public async findWithLayout(
+    entityName: string,
+    layoutCode: string,
+    keywords: string,
+    filters?: any,
+    sort?: Object
+  ): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.findWithLayout(layoutCode, keywords, filters, sort);
+  }
+
+  public async findOne(
+    entityName: string,
+    id: string,
+    fields?: Array<string>
+  ): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.findOne(id, fields);
+  }
+
+  public async findOneWithLayout(
+    entityName: string,
+    layoutCode: string,
+    id: string
+  ): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.findOneWithLayout(layoutCode, id);
+  }
+
+  public async count(
+    entityName: string,
+    filters?: any,
+    keywords?: string
+  ): Promise<number> {
+    const service = await this._getService(entityName);
+    return service.count(filters, keywords);
+  }
+
+  public async aggregate(entityName: string, query: string): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.aggregate(query);
+  }
+
+  public async create(entityName: string, data: any): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.create(data);
+  }
+
+  public async update(entityName: string, id: string, data: any): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.update(id, data);
+  }
+
+  public async delete(entityName: string, id: string): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.delete(id);
+  }
+
+  public async deleteMany(entityName: string, filter: any): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.deleteMany(filter);
+  }
+
+  public async bulkCreate(entityName: string, data: any[]): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.bulkCreate(data);
+  }
+
+  public async bulkUpdate(entityName: string, data: any[]): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.bulkUpdate(data);
+  }
+
+  public async bulkDelete(entityName: string, ids: string[]): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.bulkDelete(ids);
+  }
+
+  public async prepareGenerateData(
+    entityName: string,
+    data?: any
+  ): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.prepareGenerateData(data);
+  }
+
+  public async generateData(entityName: string, data?: any): Promise<boolean> {
+    const service = await this._getService(entityName);
+    return service.generateData(data);
+  }
+
+  public async progressGenerateData(
+    entityName: string,
+    ref_id: string
+  ): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.progressGenerateData(ref_id);
+  }
+
+  public async approve(
+    entityName: string,
+    id: string,
+    data: any
+  ): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.approve(id, data);
+  }
+
+  public async workflowActions(entityName: string, id: string): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.workflowActions(id);
+  }
+
+  public async executeWorkflowAction(
+    entityName: string,
+    id: string,
+    body: any
+  ): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.executeWorkflowAction(id, body);
+  }
+
+  public async dataWithLocale(
+    entityName: string,
+    layout: string,
+    id: string,
+    locale: string
+  ): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.dataWithLocale(layout, id, locale);
+  }
+
+  public async findWithLocale(
+    entityName: string,
+    locale: string,
+    keywords: string,
+    filters?: any,
+    sort?: Object
+  ): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.findWithLocale(locale, keywords, filters, sort);
+  }
+
+  public async setDataLocale(
+    entityName: string,
+    id: string,
+    locale: string,
+    data: any
+  ): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.setDataLocale(id, locale, data);
+  }
+
+  public async exampleOutputMapping(
+    entityName: string,
+    data: any
+  ): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.exampleOutputMapping(data);
+  }
+
+  public async searchText(entityName: string, data: any): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.searchText(data);
+  }
+}
+
+@Injectable()
+export class CoreLogService implements OnModuleInit {
+  @Inject(ActivityLogService)
+  private readonly _activityLogService: ActivityLogService;
+  @Inject(DeployLogService)
+  private readonly _deployLogService: DeployLogService;
+  @Inject(ExecutionLogService)
+  private readonly _executionLogService: ExecutionLogService;
+  @Inject(ImportExportLogService)
+  private readonly _importExportLogService: ImportExportLogService;
+  @Inject(MailLogService)
+  private readonly _mailLogService: MailLogService;
+  @Inject(NotificationLogService)
+  private readonly _notificationLogService: NotificationLogService;
+  @Inject(ScheduleLogService)
+  private readonly _scheduleLogService: ScheduleLogService;
+  @Inject(SftpLogService)
+  private readonly _sftpLogService: SftpLogService;
+  @Inject(SmsLogService)
+  private readonly _smsLogService: SmsLogService;
+
+  private services: any = {};
+
+  constructor(private moduleRef: ModuleRef) { }
+
+  private _getService(entityName: string): any {
+    switch (entityName) {
+      case "deploy_log":
+        return this._deployLogService;
+      case "schedule_log":
+        return this._scheduleLogService;
+      case "activity_log":
+        return this._activityLogService;
+      case "import_export_log":
+        return this._importExportLogService;
+      case "sftp_log":
+        return this._sftpLogService;
+      case "mail_log":
+        return this._mailLogService;
+      case "sms_log":
+        return this._smsLogService;
+      case "execution_log":
+        return this._executionLogService;
+      case "notification_log":
+        return this._notificationLogService;
+      default:
+        const customService = this.services[entityName];
+        if (_.isEmpty(customService)) {
+          throw new Error(`Invalid entity ${entityName}.`);
+        }
+        return customService;
+    }
+  }
+
+  async onModuleInit() {
+    // console.log(CUSTOM_LOG_SERVICES);
+    for (const key of Object.keys(CUSTOM_LOG_SERVICES)) {
+      this.services[key] = await this.moduleRef.get(CUSTOM_LOG_SERVICES[key], {
+        strict: false
+      });
+    }
+  }
+
+  public async purgeLog(entityName: string, setting: any) {
+    const service = await this._getService(entityName);
+    return service.purgeLog(setting);
+  }
+}
+
+@Injectable()
+export class CoreSettingService implements OnModuleInit {
+  private services: any = {};
+
+  constructor(private moduleRef: ModuleRef) { }
+
+  private _getService(entityName: string): IBaseModuleSettingService {
+    switch (entityName) {
+      default:
+        const customService = this.services[entityName];
+        if (_.isEmpty(customService)) {
+          throw new Error(`Invalid entity ${entityName}.`);
+        }
+        return customService;
+    }
+  }
+
+  async onModuleInit() {
+    // console.log(CUSTOM_SETTING_SERVICES);
+    for (const key of Object.keys(CUSTOM_SETTING_SERVICES)) {
+      this.services[key] = await this.moduleRef.get(
+        CUSTOM_SETTING_SERVICES[key],
+        {
+          strict: false
+        }
+      );
+    }
+  }
+
+  public async getSetting(entityName: string, key?: string): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.getSetting(key);
+  }
+  public async setSetting(
+    entityName: string,
+    data: any,
+    key?: string
+  ): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.setSetting(data, key);
+  }
+
+  public async defaultPermission(entityName: string): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.defaultPermission();
+  }
+  public async setPermission(
+    entityName: string,
+    permissoin: any
+  ): Promise<any> {
+    const service = await this._getService(entityName);
+    return service.setPermission(permissoin);
+  }
+}