@solidstarters/solid-core 1.2.47 → 1.2.48

package/src/services/authentication.service.ts

@@ -933,7 +933,7 @@ export class AuthenticationService {
                 email: user.email,
                 mobile: user.mobile,
                 username: user.username,
-                forcePasswordChange: user.forcePasswordChange,
+                // forcePasswordChange: user.forcePasswordChange,
                 id: user.id,
                 roles: user.roles.map((role, idx, roles) => role.name)
             },

package/src/services/email-template.service.ts

@@ -6,32 +6,37 @@ import { PaginationQueryDto } from 'src/dtos/pagination-query.dto';
 import { EmailTemplate } from '../entities/email-template.entity';
 import { CreateEmailTemplateDto } from '../dtos/create-email-template.dto';
 import { UpdateEmailTemplateDto } from '../dtos/update-email-template.dto';
+import { CRUDService } from './crud.service';
+import { ModelMetadataService } from './model-metadata.service';
+import { ModuleMetadataService } from './module-metadata.service';
+import { MediaStorageProviderMetadataService } from './media-storage-provider-metadata.service';
+import { ConfigService } from '@nestjs/config';
+import { FileService } from './file.service';
+import { MediaService } from './media.service';
+import { DiscoveryService, ModuleRef } from '@nestjs/core';
+import { CrudHelperService } from './crud-helper.service';
 
 @Injectable()
-export class EmailTemplateService {
+export class EmailTemplateService extends CRUDService<EmailTemplate>{
     constructor(
-        @InjectRepository(EmailTemplate)
-        private readonly emailTemplateRepo: Repository<EmailTemplate>,
-        @InjectEntityManager()
-        private readonly entityManager: EntityManager,
-    ) { }
-
-    create(createEmailTemplateDto: CreateEmailTemplateDto) {
-        const entity = this.emailTemplateRepo.create(createEmailTemplateDto);
-        return this.emailTemplateRepo.save(entity);
-    }
-
-    async findAll(paginationQuery: PaginationQueryDto) {
-        const { limit, offset } = paginationQuery;
-
-        return await this.emailTemplateRepo.find({
-            skip: offset,
-            take: limit,
-        });
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly mediaStorageProviderService: MediaStorageProviderMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly mediaService: MediaService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(EmailTemplate, 'default')
+    readonly repo: Repository<EmailTemplate>,
+    readonly moduleRef: ModuleRef,
+    ) {
+        super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'emailTemplate', 'app-builder', moduleRef);
     }
-
     async findOneByName(name: string, relations: any = {}) {
-        const entity = await this.emailTemplateRepo.findOne({
+        const entity = await this.repo.findOne({
             where: {
                 name: name,
             },
@@ -39,42 +44,10 @@ export class EmailTemplateService {
         });
         return entity;
     }
-
-    async findOne(id: number) {
-        const entity = await this.emailTemplateRepo.findOne({
-            where: {
-                id: id,
-            },
-        });
-        if (!entity) {
-            throw new NotFoundException(`Email template #${id} not found`);
-        }
-        return entity;
-    }
-
-    async update(id: number, updateEmailTemplateDto: UpdateEmailTemplateDto) {
-        const t = {
-            id,
-            ...updateEmailTemplateDto,
-        };
-
-        const entity = await this.emailTemplateRepo.preload(t);
-        if (!entity) {
-            throw new NotFoundException(`Email template #${id} not found`);
-        }
-        return this.emailTemplateRepo.save(entity);
-    }
-
     async removeByName(name: string) {
         const entity = await this.findOneByName(name);
         if (entity) {
-            return await this.emailTemplateRepo.remove(entity);
+            return await this.repo.remove(entity);
         }
     }
-
-    async remove(id: number) {
-        const entity = await this.findOne(id);
-        return this.emailTemplateRepo.remove(entity);
-    }
-
 }

package/src/services/sms-template.service.ts

@@ -6,72 +6,49 @@ import { PaginationQueryDto } from 'src/dtos/pagination-query.dto';
 import { SmsTemplate } from '../entities/sms-template.entity';
 import { CreateSmsTemplateDto } from '../dtos/create-sms-template.dto';
 import { UpdateSmsTemplateDto } from '../dtos/update-sms-template.dto';
+import { CRUDService } from './crud.service';
+import { ModelMetadataService } from './model-metadata.service';
+import { ModuleMetadataService } from './module-metadata.service';
+import { MediaStorageProviderMetadataService } from './media-storage-provider-metadata.service';
+import { ConfigService } from '@nestjs/config';
+import { FileService } from './file.service';
+import { MediaService } from './media.service';
+import { DiscoveryService, ModuleRef } from '@nestjs/core';
+import { CrudHelperService } from './crud-helper.service';
 
 @Injectable()
-export class SmsTemplateService {
+export class SmsTemplateService extends CRUDService<SmsTemplate>{
     constructor(
-        @InjectRepository(SmsTemplate)
-        private readonly smsTemplateRepo: Repository<SmsTemplate>,
-        @InjectEntityManager()
-        private readonly entityManager: EntityManager,
-    ) { }
+        readonly modelMetadataService: ModelMetadataService,
+            readonly moduleMetadataService: ModuleMetadataService,
+            readonly mediaStorageProviderService: MediaStorageProviderMetadataService,
+            readonly configService: ConfigService,
+            readonly fileService: FileService,
+            readonly mediaService: MediaService,
+            readonly discoveryService: DiscoveryService,
+            readonly crudHelperService: CrudHelperService,
+            @InjectEntityManager()
+            readonly entityManager: EntityManager,
+            @InjectRepository(SmsTemplate, 'default')
+            readonly repo: Repository<SmsTemplate>,
+            readonly moduleRef: ModuleRef,
+    ) {
+        super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'smsTemplate', 'app-builder', moduleRef);
+     }
 
-    create(createSmsTemplateDto: CreateSmsTemplateDto) {
-        const entity = this.smsTemplateRepo.create(createSmsTemplateDto);
-        return this.smsTemplateRepo.save(entity);
+    async removeByName(name: string) {
+        const entity = await this.findOneByName(name);
+        if (entity) {
+            return await this.repo.remove(entity);
+        }
     }
 
     async findOneByName(name: string) {
-        const entity = await this.smsTemplateRepo.findOne({
+        const entity = await this.repo.findOne({
             where: {
                 name: name,
             },
         });
         return entity;
     }
-
-    async findAll(paginationQuery: PaginationQueryDto) {
-        const { limit, offset } = paginationQuery;
-
-        return await this.smsTemplateRepo.find({
-            skip: offset,
-            take: limit,
-        });
-    }
-
-    async findOne(id: number) {
-        const entity = await this.smsTemplateRepo.findOne({
-            where: {
-                id: id,
-            },
-        });
-        if (!entity) {
-            throw new NotFoundException(`Sms template #${id} not found`);
-        }
-        return entity;
-    }
-
-    async update(id: number, updateSmsTemplateDto: UpdateSmsTemplateDto) {
-        const entity = await this.smsTemplateRepo.preload({
-            id,
-            ...updateSmsTemplateDto,
-        });
-        if (!entity) {
-            throw new NotFoundException(`Sms template #${id} not found`);
-        }
-        return this.smsTemplateRepo.save(entity);
-    }
-
-    async removeByName(name: string) {
-        const entity = await this.findOneByName(name);
-        if (entity) {
-            return await this.smsTemplateRepo.remove(entity);
-        }
-    }
-
-    async remove(id: number) {
-        const entity = await this.findOne(id);
-        return this.smsTemplateRepo.remove(entity);
-    }
-
 }

package/src/services/user-view-metadata.service.ts

@@ -13,6 +13,7 @@ import { CrudHelperService } from 'src/services/crud-helper.service';
 
 import { UserViewMetadata } from '../entities/user-view-metadata.entity';
 import { UpsertUserViewMetadataDto } from 'src/dtos/upsert-user-view-metadata.dto';
+import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
 
 @Injectable()
 export class UserViewMetadataService extends CRUDService<UserViewMetadata> {
@@ -33,9 +34,9 @@ export class UserViewMetadataService extends CRUDService<UserViewMetadata> {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'userViewMetadata', 'solid-core', moduleRef);
   }
 
-  async upsert(query: UpsertUserViewMetadataDto) {
+  async upsert(query: UpsertUserViewMetadataDto, activeUser: ActiveUserData) {
     const existing = await this.repo.findOne({
-      where: { user: { id: query.userId }, viewMetadata: { id: query.viewMetadataId } }
+      where: { user: { id: activeUser?.sub }, viewMetadata: { id: query.viewMetadataId } }
     });
 
     if (existing) {
@@ -43,7 +44,7 @@ export class UserViewMetadataService extends CRUDService<UserViewMetadata> {
       return await this.repo.save(existing);
     } else {
       const newEntry = this.repo.create({
-        user: { id: query.userId },
+        user: { id: activeUser?.sub },
         viewMetadata: { id: query.viewMetadataId },
         layout: JSON.parse(query.layout)
       });

package/src/services/view-metadata.service.ts

@@ -46,8 +46,8 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
   }
 
   // START: Custom Service Methods
-  async getLayout(query) {
-    let { modelName, moduleName, viewType, populate, userId } = query;
+  async getLayout(query, activeUser) {
+    let { modelName, moduleName, viewType, populate } = query;
 
     // modelName = camelize(modelName);
 
@@ -70,13 +70,13 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
       throw new BadRequestException(`Unable to identify view for module: ${moduleName}, model: ${modelName} and viewType: ${viewType}`);
     }
 
-    if (!userId) {
+    if (!activeUser?.sub) {
       throw new BadRequestException(`Unable to identify user for module: ${moduleName}, model: ${modelName} and viewType: ${viewType}`);
     }
 
     const userLayout = await this.userViewMetadataService.repo.findOne({
       where: {
-        user: { id: userId },
+        user: { id: activeUser?.sub },
         viewMetadata: { id: entity.id },
       },
     });