rez_core 5.0.89 → 5.0.90

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "5.0.89",
+  "version": "5.0.90",
   "description": "",
   "author": "",
   "private": false,

package/src/module/meta/service/entity-relation.service.ts

@@ -5,8 +5,7 @@ import { EntityMasterRepository } from '../repository/entity-master.repository';
 
 @Injectable()
 export class EntityRelationService extends EntityServiceImpl {
-  constructor(private readonly dataSource: DataSource,
-              private entityMasterRepo: EntityMasterRepository) {
+  constructor(private entityMasterRepo: EntityMasterRepository) {
     super();
   }
 
@@ -15,12 +14,18 @@ export class EntityRelationService extends EntityServiceImpl {
     loggedInUser: any,
     includeSelf = false,
   ): Promise<any> {
-    const relations = await this.dataSource.query(
-      `SELECT name as label, target_entity_type as value, id 
-       FROM frm_entity_relation 
-       WHERE source_entity_type = $1 AND organization_id = $2`,
-      [entityType, loggedInUser.organization_id],
-    );
+    const entityRelationRepo = this.reflectionHelper.getRepoService('EntityRelation');
+
+    const relations = await entityRelationRepo
+      .createQueryBuilder("er")
+      .select([
+        "er.name AS label",
+        "er.target_entity_type AS value",
+        "er.id AS id",
+      ])
+      .where("er.source_entity_type = :entityType", { entityType })
+      .andWhere("er.organization_id = :orgId", { orgId: loggedInUser.organization_id })
+      .getRawMany();
   
     if (includeSelf) {
       const entity = await this.entityMasterRepo.getEntityByMappedEntityType(entityType, loggedInUser.organization_id);
@@ -46,40 +51,17 @@ export class EntityRelationService extends EntityServiceImpl {
 
     if (!targetIds.length) return [];
 
-    let paramIndex = 1;
-    const params: any[] = [];
-
-    // $1 and $2 are text (entity types)
-    params.push(sourceEntity); // do NOT convert to string, pg will treat as text
-    const sourceEntityParam = `$${paramIndex++}`;
-
-    params.push(targetEntity);
-    const targetEntityParam = `$${paramIndex++}`;
-
-    // Build placeholders for IDs → IDs must remain NUMBER
-    const idPlaceholders = targetIds
-      .map((id) => {
-        params.push(Number(id));   // ✔ FIX: Use Number
-        return `$${paramIndex++}`;
-      })
-      .join(", ");
-
-    // org id
-    params.push(Number(orgId));   // ✔ FIX: Use Number
-    const orgPlaceholder = `$${paramIndex}`;
-
-    const sql = `
-        SELECT DISTINCT source_entity_id
-        FROM frm_entity_relation_data
-        WHERE source_entity_type = ${sourceEntityParam}
-          AND target_entity_type = ${targetEntityParam}
-          AND target_entity_id IN (${idPlaceholders})
-          AND organization_id = ${orgPlaceholder}
-    `;
-
-    const rows = await this.dataSource.query(sql, params);
+    const entityRelationRepo = this.reflectionHelper.getRepoService('EntityRelation');
+    const rows = await entityRelationRepo
+      .createQueryBuilder("erd")
+      .select("DISTINCT erd.source_entity_id", "source_entity_id")
+      .where("erd.source_entity_type = :sourceEntity", { sourceEntity })
+      .andWhere("erd.target_entity_type = :targetEntity", { targetEntity })
+      .andWhere("erd.target_entity_id IN (:...targetIds)", { targetIds })
+      .andWhere("erd.organization_id = :orgId", { orgId })
+      .getRawMany();
 
-    return rows.map((r: any) => Number(r.source_entity_id));
+    return rows.map((r) => Number(r.source_entity_id));
   }
   
   

package/src/module/module/service/module-access.service.ts

@@ -11,6 +11,7 @@ import { DataSource, EntityManager } from 'typeorm';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { MenuRepository } from '../repository/menu.repository';
 import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
+import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
 
 @Injectable()
 export class ModuleAccessService {
@@ -20,6 +21,7 @@ export class ModuleAccessService {
     private readonly dataSource: DataSource,
     @Inject('ListMasterService')
     private readonly listMasterService: ListMasterService,
+    private readonly reflectionHelper: ReflectionHelper
   ) {}
 
   async getModules({ appcode,loggedInUser }: { appcode: string ,loggedInUser: UserData}) {
@@ -172,11 +174,13 @@ export class ModuleAccessService {
 
     // Step 3: If level_type is SCH, check school status using raw query
     if (level_type === 'SCH') {
-      const result = await this.dataSource.query(
-        `SELECT * FROM sso_school WHERE id = ${level_id}`
-      );
+      const schoolRepo =  this.reflectionHelper.getRepoService('SSOSchool');
 
-      const school = result?.[0];
+      const school = await schoolRepo.findOne({
+        where: {
+          id: level_id
+        }
+      });
 
       const resolveStatus = await this.listMasterService.getResolvedListCode(
         STATUS_INACTIVE,

package/src/module/notification/service/notification.service.ts

@@ -1,16 +1,18 @@
 import { Inject, Injectable } from '@nestjs/common';
-import { DataSource } from 'typeorm';
+import { DataSource, EntityManager } from 'typeorm';
 import { MediaDataService } from 'src/module/meta/service/media-data.service';
 import * as admin from 'firebase-admin';
 import axios from 'axios';
 import { ConfigService } from '@nestjs/config';
+import { ReflectionHelper } from 'src/utils/service/reflection-helper.service';
 
 @Injectable()
 export class NotificationsService {
   constructor(
-    private readonly dataSource: DataSource,
+    private readonly entityManager: EntityManager,
     private readonly mediaDataService: MediaDataService,
     private readonly configService: ConfigService,
+    private readonly reflectionHelper: ReflectionHelper,
     @Inject('FIREBASE_ADMIN') private readonly firebaseAdmin: typeof admin,
   ) {}
 
@@ -90,11 +92,7 @@ export class NotificationsService {
       AND n.level_type = $${paramIndex + 2}
   `;
 
-    const params: string[] = [
-      String(id),
-      String(level_id),
-      String(level_type),
-    ];
+    const params: string[] = [String(id), String(level_id), String(level_type)];
     paramIndex += 3;
 
     //
@@ -111,7 +109,7 @@ export class NotificationsService {
     //
     // Execute query
     //
-    const notifications = await this.dataSource.query(sql, params);
+    const notifications = await this.entityManager.query(sql, params);
 
     //
     // Enrich profile image + user name
@@ -119,7 +117,8 @@ export class NotificationsService {
     const mediaCache = new Map();
 
     for (const notification of notifications) {
-      notification.is_read = notification.is_read === 1 || notification.is_read === '1';
+      notification.is_read =
+        notification.is_read === 1 || notification.is_read === '1';
 
       try {
         const baseUrl = this.configService.get<string>('REDIRECT_BE_URL');
@@ -145,16 +144,21 @@ export class NotificationsService {
   async markAllAsRead(loggedInUser: any) {
     const { id, level_id, level_type } = loggedInUser;
 
-    const query = `
-    UPDATE frm_notification
-    SET is_read = 1
-    WHERE user_id = $1 AND level_id = $2 AND level_type = $3 AND is_read = 0
-  `;
-
-    const params = [id, level_id, level_type];
-
-    const result = await this.dataSource.query(query, params);
-
-    return { success: true, affectedRows: result.affectedRows || 0 };
+    const notificationRepo =
+      this.reflectionHelper.getRepoService('NotificationData');
+
+    const result = await notificationRepo.update(
+      {
+        user_id: id,
+        level_id: level_id,
+        level_type: level_type,
+        is_read: 0,
+      },
+      {
+        is_read: 1,
+      },
+    );
+
+    return { success: true, affectedRows: result.affected || 0 };
   }
 }

package/src/module/workflow/repository/action-data.repository.ts

@@ -1,23 +1,22 @@
 import { BadRequestException, Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { ActionDataEntity } from '../entity/action-data.entity';
-import { DataSource, LessThan, Repository } from 'typeorm';
+import { LessThan, Repository } from 'typeorm';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { TaskDataEntity } from '../entity/task-data.entity';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { FORM_STATUS_TO_BE_SENT } from 'src/constant/global.constant';
 import { ConfigService } from '@nestjs/config';
 import axios from 'axios';
-import { WorkflowAutomationEngineService } from 'src/module/workflow-automation/service/workflow-automation-engine.service';
+import {
+  WorkflowAutomationEngineService,
+} from 'src/module/workflow-automation/service/workflow-automation-engine.service';
 
 @Injectable()
 export class ActionDataRepository extends EntityServiceImpl {
   constructor(
     @InjectRepository(ActionDataEntity)
     private readonly actionDataRepo: Repository<ActionDataEntity>,
-    private readonly dataSource: DataSource,
-    // @InjectRepository(FormDataEntity)
-    // private readonly formRepo: Repository<FormDataEntity>,
     @InjectRepository(TaskDataEntity)
     private readonly TaskRepository: Repository<TaskDataEntity>,
     private readonly configService: ConfigService,
@@ -39,10 +38,14 @@ export class ActionDataRepository extends EntityServiceImpl {
 
     if (action.length > 0) {
       for (const act of action) {
-        const is_mandatory = await this.dataSource.query(
-          `SELECT code FROM frm_list_master_items WHERE id = $1 and organization_id = $2 LIMIT 1;`,
-          [act.action_requirement, loggedInUser.organization_id],
-        );
+        const listMasterItemsRepo = this.reflectionHelper.getRepoService('ListMasterItems');
+        const is_mandatory = await listMasterItemsRepo.findOne({
+          where: {
+            id: act.action_requirement,
+            organization_id: loggedInUser.organization_id,
+          },
+        });
+
         const isFirst = act.sequence == minSequence;
         const actionData = this.actionDataRepo.create({
           stage_id: act.stage_id,
@@ -55,7 +58,7 @@ export class ActionDataRepository extends EntityServiceImpl {
           mapped_entity_type,
           is_current: isFirst ? 'Y' : null,
           start_time: isFirst ? new Date() : null,
-          is_mandatory: is_mandatory[0]?.code === 'mandatory' ? true : false,
+          is_mandatory: is_mandatory?.code === 'mandatory' ? true : false,
           category: act?.action_category_code,
         } as ActionDataEntity);
         await this.actionDataRepo.save(actionData);
@@ -91,7 +94,7 @@ export class ActionDataRepository extends EntityServiceImpl {
             status: FORM_STATUS_TO_BE_SENT,
             action_id: act.id,
             created_date: istDate,
-            pdf_template: act.pdf_template
+            pdf_template: act.pdf_template,
           };
 
           const createdEntity = await super.createEntity(
@@ -100,23 +103,25 @@ export class ActionDataRepository extends EntityServiceImpl {
           );
           // THEN INSERT SDFM IN RELATION TASK TABLE
 
-          let relationData = await this.dataSource.query(
-            `SELECT * FROM frm_entity_relation WHERE source_entity_type = $1  AND target_entity_type = $2`,
-            [createdEntity.mapped_entity_type, createdEntity.entity_type],
-          );
+          const entityRelationRepo = this.reflectionHelper.getRepoService('EntityRelation');
+          let relationData = await entityRelationRepo.findOne({
+            where: {
+              source_entity_type: createdEntity.mapped_entity_type,
+              target_entity_type: createdEntity.entity_type,
+            },
+          });
 
           if (relationData) {
-            await this.dataSource.query(
-              `INSERT INTO frm_entity_relation_data (organization_id, source_entity_id, source_entity_type, target_entity_id, target_entity_type, relation_type) VALUES ($1, $2, $3, $4, $5,$6)`,
-              [
-                loggedInUser.organization_id,
-                createdEntity.mapped_entity_id,
-                createdEntity.mapped_entity_type,
-                createdEntity.id,
-                createdEntity.entity_type,
-                relationData[0]?.relation_type,
-              ],
-            );
+            const entityRelationDataRepo = this.reflectionHelper.getRepoService('EntityRelationData');
+
+            await entityRelationDataRepo.save({
+              organization_id: loggedInUser.organization_id,
+              source_entity_id: createdEntity.mapped_entity_id,
+              source_entity_type: createdEntity.mapped_entity_type,
+              target_entity_id: createdEntity.id,
+              target_entity_type: createdEntity.entity_type,
+              relation_type: relationData?.relation_type,
+            });
           }
 
           await this.workflowAutomationEngineService.handleEntityEvent(
@@ -261,8 +266,8 @@ export class ActionDataRepository extends EntityServiceImpl {
           where: {
             code: 'in_progress',
             organization_id: organization_id,
-            listtype: 'TKST'
-          }
+            listtype: 'TKST',
+          },
         });
 
         task.status = listMasterItem.id ?? task.status;

package/src/module/workflow/repository/action.repository.ts

@@ -1,36 +1,22 @@
-import {
-  BadRequestException,
-  Inject,
-  Injectable,
-  NotFoundException,
-} from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { DataSource, In, Repository } from 'typeorm';
-import { ActionEntity } from '../entity/action.entity';
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { In } from 'typeorm';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
 
 @Injectable()
 export class ActionRepository {
-  constructor(
-    @InjectRepository(ActionEntity)
-    private readonly actionRepository: Repository<ActionEntity>,
-    private readonly dataSource: DataSource,
-    private readonly reflectionHelper: ReflectionHelper,
-  ) {
-  }
+  constructor(private readonly reflectionHelper: ReflectionHelper) {}
 
   async getReasonCode(loggedInUser: UserData): Promise<any> {
     const { organization_id } = loggedInUser;
-    const result = await this.dataSource.query(
-      `
-          SELECT name, type
-          FROM frm_list_master
-          WHERE organization_id = $1
-            AND source = 'master'
-      `,
-      [organization_id],
-    );
+    const listMasterItemsRepo =
+      this.reflectionHelper.getRepoService('ListMasterItems');
+    const result = await listMasterItemsRepo.find({
+      where: {
+        organization_id,
+        source: 'master',
+      },
+    });
 
     const formatted = result.map((item: any) => ({
       label: item.name,
@@ -45,15 +31,16 @@ export class ActionRepository {
     if (!list_type) {
       throw new BadRequestException('list_type is required');
     }
-    const result = await this.dataSource.query(
-      `
-          SELECT name, id
-          FROM frm_list_master_items
-          WHERE listtype = $1
-            AND organization_id = $2
-      `,
-      [list_type, organization_id],
-    );
+
+    const listMasterItemsRepo =
+      this.reflectionHelper.getRepoService('ListMasterItems');
+
+    const result = await listMasterItemsRepo.find({
+      where: {
+        listtype: list_type,
+        organization_id,
+      },
+    });
 
     // Format as array of key-value pairs
     return result.map((row: any) => ({
@@ -65,7 +52,8 @@ export class ActionRepository {
   async getActions(loggedInUser: UserData, stage_id: number) {
     const { organization_id } = loggedInUser;
 
-    const workflowStageActionRepo = this.reflectionHelper.getRepoService('StageActionMapping');
+    const workflowStageActionRepo =
+      this.reflectionHelper.getRepoService('StageActionMapping');
 
     // Step 1: Get all action_ids for the provided stage_id
     const stageActions = await workflowStageActionRepo.find({
@@ -79,7 +67,8 @@ export class ActionRepository {
     const mappingIds = stageActions.map((sa) => sa.id);
 
     // Step 2: Get template codes with mapping IDs
-    const workflowActionTemplateMappingRepo = this.reflectionHelper.getRepoService('ActionTemplateMapping');
+    const workflowActionTemplateMappingRepo =
+      this.reflectionHelper.getRepoService('ActionTemplateMapping');
 
     const templateMappings = await workflowActionTemplateMappingRepo.find({
       where: {
@@ -92,7 +81,8 @@ export class ActionRepository {
     // Step 3: Fetch template names from frm_wf_comm_template
     const templateCodeToName: Record<string, string> = {};
 
-    const workflowCommTemplateRepo = this.reflectionHelper.getRepoService('CommTemplate');
+    const workflowCommTemplateRepo =
+      this.reflectionHelper.getRepoService('CommTemplate');
 
     if (templateCodes.length > 0) {
       const templates = await workflowCommTemplateRepo.find({
@@ -136,7 +126,8 @@ export class ActionRepository {
     }
 
     // Step 6: Fetch action details
-    const workflowActionRepo = this.reflectionHelper.getRepoService('ActionEntity');
+    const workflowActionRepo =
+      this.reflectionHelper.getRepoService('ActionEntity');
 
     const actionResults = await workflowActionRepo
       .createQueryBuilder()
@@ -147,7 +138,11 @@ export class ActionRepository {
         'ar.name AS action_requirement',
       ])
       .from('frm_wf_action', 'a')
-      .leftJoin('frm_wf_action_category', 'ac', 'ac.id::text = a.action_category')
+      .leftJoin(
+        'frm_wf_action_category',
+        'ac',
+        'ac.id::text = a.action_category',
+      )
       .leftJoin(
         'frm_list_master_items',
         'ar',
@@ -181,7 +176,8 @@ export class ActionRepository {
     action_id?: number,
   ) {
     // Step 1: Get all action_ids for the provided stage_id
-    let stageActionMappingRepo = this.reflectionHelper.getRepoService('StageActionMapping');
+    let stageActionMappingRepo =
+      this.reflectionHelper.getRepoService('StageActionMapping');
 
     const stageActions = await stageActionMappingRepo.find({
       where: {
@@ -207,8 +203,8 @@ export class ActionRepository {
     const actionRepo = this.reflectionHelper.getRepoService('ActionEntity');
     actionResults = await actionRepo.find({
       where: {
-        id: In(actionIds)
-      }
+        id: In(actionIds),
+      },
     });
 
     // Step 3: Format result
@@ -251,46 +247,47 @@ export class ActionRepository {
     const actionRepo = this.reflectionHelper.getRepoService('ActionEntity');
 
     const actions = await actionRepo
-      .createQueryBuilder("a")
+      .createQueryBuilder('a')
       .select([
-        "a.id AS action_id",
-        "a.name AS action_name",
-        "a.reason_code AS action_reason_code",
-        "a.default_reason_code AS default_reason_code",
-        "a.default_value AS default_value",
-        "a.mode AS mode",
-        "a.action_category AS action_category_id",
-        "ac.reason_code AS category_reason_code",
-        "ac.modalname AS modalname",
-        "ac.logo AS logo",
-        "ac.name AS action_category_name",
-        "a.dependent_action_id AS dependent_action_id",
+        'a.id AS action_id',
+        'a.name AS action_name',
+        'a.reason_code AS action_reason_code',
+        'a.default_reason_code AS default_reason_code',
+        'a.default_value AS default_value',
+        'a.mode AS mode',
+        'a.action_category AS action_category_id',
+        'ac.reason_code AS category_reason_code',
+        'ac.modalname AS modalname',
+        'ac.logo AS logo',
+        'ac.name AS action_category_name',
+        'a.dependent_action_id AS dependent_action_id',
       ])
       .leftJoin(
-        "frm_wf_action_category",
-        "ac",
-        "ac.id = a.action_category::bigint"
+        'frm_wf_action_category',
+        'ac',
+        'ac.id = a.action_category::bigint',
       )
-      .where("a.organization_id = :orgId", { orgId: organization_id })
-      .andWhere("a.id IN (:...actionIds)", { actionIds })
-      .orderBy("a.sequence", "ASC")
+      .where('a.organization_id = :orgId', { orgId: organization_id })
+      .andWhere('a.id IN (:...actionIds)', { actionIds })
+      .orderBy('a.sequence', 'ASC')
       .getRawMany();
 
     // Step 3: Fetch action_data
-    const actionDataRepo = this.reflectionHelper.getRepoService('ActionDataEntity');
+    const actionDataRepo =
+      this.reflectionHelper.getRepoService('ActionDataEntity');
 
     const actionData = await actionDataRepo
-      .createQueryBuilder("ad")
+      .createQueryBuilder('ad')
       .select([
-        "ad.action_id AS action_id",
-        "ad.is_current AS is_current",
-        "ad.is_mandatory AS is_mandatory",
-        "ad.is_done AS is_done",
+        'ad.action_id AS action_id',
+        'ad.is_current AS is_current',
+        'ad.is_mandatory AS is_mandatory',
+        'ad.is_done AS is_done',
       ])
-      .where("ad.stage_id = :stageId", { stageId: stage_id })
-      .andWhere("ad.action_id IN (:...actionIds)", { actionIds })
-      .andWhere("ad.mapped_entity_id = :mapped_entity_id", { mapped_entity_id })
-      .andWhere("ad.mapped_entity_type = :mapped_entity_type", {
+      .where('ad.stage_id = :stageId', { stageId: stage_id })
+      .andWhere('ad.action_id IN (:...actionIds)', { actionIds })
+      .andWhere('ad.mapped_entity_id = :mapped_entity_id', { mapped_entity_id })
+      .andWhere('ad.mapped_entity_type = :mapped_entity_type', {
         mapped_entity_type,
       })
       .getRawMany();
@@ -298,8 +295,8 @@ export class ActionRepository {
     const actionIdToData = actionData.reduce((acc, row) => {
       acc[row.action_id] = {
         is_current: row.is_current === 'Y',
-        is_mandatory: row.is_mandatory === 1,
-        is_done: row.is_done === 1,
+        is_mandatory: row.is_mandatory,
+        is_done: row.is_done,
       };
       return acc;
     }, {});
@@ -323,10 +320,10 @@ export class ActionRepository {
         name: row.action_category_name,
         reason_code,
         default_reason_code: row.default_reason_code,
-        is_default: row.default_value === 1,
-        is_current: data?.is_current ?? false,
-        is_done: data?.is_done ?? false,
-        is_mandatory: data?.is_mandatory ?? false,
+        is_default: row.default_value,
+        is_current: data?.is_current,
+        is_done: data?.is_done,
+        is_mandatory: data?.is_mandatory,
       };
     });
 

package/src/module/workflow/repository/comm-template.repository.ts

@@ -1,6 +1,6 @@
 import { Injectable, NotFoundException } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { DataSource, Repository } from 'typeorm';
+import { Repository } from 'typeorm';
 import { CommTemplate } from '../entity/comm-template.entity';
 import { TemplateAttach } from '../entity/template-attach-mapper.entity';
 import { MediaDataService } from 'src/module/meta/service/media-data.service';
@@ -14,9 +14,9 @@ export class CommTemplateRepository {
     @InjectRepository(TemplateAttach)
     private readonly templateAttachEntity: Repository<TemplateAttach>,
     private readonly mediaDataService: MediaDataService,
-    private readonly dataSource: DataSource,
     private readonly reflectionHelper: ReflectionHelper,
-  ) {}
+  ) {
+  }
 
   async getAllCommTemplate(
     entity_type: string,
@@ -35,21 +35,27 @@ export class CommTemplateRepository {
         where: {
           id: action_id,
           organization_id: organization_id,
-        }
-      })
+        },
+      });
 
       if (!actionResult) {
         throw new Error('Invalid action_id');
       }
 
       is_template = actionResult.is_template;
-      await this.dataSource.query(
-        `UPDATE frm_wf_comm_template
-     SET is_template = $1
-     WHERE mapped_entity_type = $2
-       AND organization_id = $3 AND level_id = $4 AND level_type=$5`,
-        [is_template, entity_type, organization_id, level_id, level_type],
-      );
+      await this.commTemplateRepository.find({
+        where: {},
+      });
+
+      await this.commTemplateRepository
+        .createQueryBuilder()
+        .update()
+        .set({ is_template: Boolean(is_template) })
+        .where('mapped_entity_type = :entityType', { entity_type })
+        .andWhere('organization_id = :orgId', { orgId: organization_id })
+        .andWhere('level_id = :levelId', { levelId: level_id })
+        .andWhere('level_type = :levelType', { levelType: level_type })
+        .execute();
     }
 
     const whereCondition: any = {
@@ -145,7 +151,7 @@ export class CommTemplateRepository {
   async findByCodeAndLevelIdAndLevelTypeAndAppCode(code: string, level_id: string,
                                                    level_type: string, appcode: string) {
     return await this.commTemplateRepository.findOne({
-      where: {code, level_id, level_type, appcode}
+      where: { code, level_id, level_type, appcode },
     });
   }
 }