@solidstarters/solid-core 1.2.0

package/src/services/user.service.ts.bkp

@@ -0,0 +1,311 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+
+import { Repository, SelectQueryBuilder } from 'typeorm';
+import { InjectRepository } from '@nestjs/typeorm';
+import { User } from '../entities/user.entity';
+import { OauthUserDto } from '../dtos/oauth-user-dto';
+import { UpdateUserDto } from '../dtos/update-user.dto';
+import { BasicFilterDto } from 'src/dtos/basic-filters.dto';
+import { CrudHelperService } from 'src/services/crud-helper.service';
+import { RoleMetadata } from '../entities/role-metadata.entity';
+
+
+@Injectable()
+export class UserService {
+
+    constructor(
+        readonly crudHelperService: CrudHelperService,
+        @InjectRepository(User)
+        private readonly userRepository: Repository<User>,
+        @InjectRepository(RoleMetadata)
+        private readonly roleRepository: Repository<RoleMetadata>,
+    ) { }
+
+    async findMany(basicFilterDto: BasicFilterDto) {
+        const alias = 'user';
+        // Extract the required keys from the input query
+        let { limit, offset} = basicFilterDto;
+ 
+        // Create above query on pincode table using query builder
+        var qb: SelectQueryBuilder<User> = this.userRepository.createQueryBuilder(alias)
+        qb = await this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
+
+        // Get the records and the count
+        const [entities, count] = await qb.getManyAndCount();
+
+        const currentPage = Math.floor(offset / limit) + 1;
+        const totalPages = Math.ceil(count / limit);
+
+        const nextPage = currentPage < totalPages ? currentPage + 1 : null;
+        const prevPage = currentPage > 1 ? currentPage - 1 : null;
+
+        const r = {
+            meta: {
+                totalRecords: count,
+                currentPage: currentPage,
+                nextPage: nextPage,
+                prevPage: prevPage,
+                totalPages: totalPages,
+                perPage: +limit,
+            },
+            records: entities
+        };
+        return r
+    }
+
+
+    async findOne(id: number) {
+        const entity = await this.userRepository.findOne({
+            where: {
+                id: id
+            },
+            relations: {
+                roles: true
+            }
+        });
+        if (!entity) {
+            throw new NotFoundException(`entity #${id} not found`);
+        }
+        return entity;
+    }
+
+    async findOneByEmail(email: string): Promise<User> {
+        return await this.userRepository.findOne({
+            where: {
+                email: email
+            },
+            relations: {}
+        });
+        // if (!entity) {
+        //     throw new NotFoundException(`user with email #${email} not found`);
+        // }
+        // return entity;
+    }
+
+    async findOneByAccessCode(accessCode: string): Promise<User> {
+        return await this.userRepository.findOne({
+            where: {
+                accessCode: accessCode
+            },
+            relations: {}
+        });
+    }
+
+    async findOneByUsername(username: string): Promise<User> {
+        return await this.userRepository.findOne({
+            where: {
+                username: username
+            },
+            relations: {}
+        });
+        // if (!entity) {
+        //     throw new NotFoundException(`user with username ${username} not found`);
+        // }
+        // return entity;
+    }
+
+    async addRoleToUser(username: string, roleName: string): Promise<User> {
+        // Find the role, find the user and populate the many 2 many table.
+        const user = await this.userRepository.findOne({
+            where: { username: username },
+            relations: {
+                roles: true
+            }
+        });
+        if (!user) {
+            throw new Error(`User with username '${username}' not found.`);
+        }
+        const role = await this.roleRepository.findOne({ where: { name: roleName } });
+        if (!role) {
+            throw new Error(`Role '${roleName}' not found.`);
+        }
+
+        if (user.roles && user.roles.length > 0) {
+            user.roles.push(role);
+        }
+        else {
+            user.roles = [role];
+        }
+
+        return await this.userRepository.save(user);
+    }
+
+    async addRolesToUser(username: string, roleNames: string[]): Promise<User> {
+        const user = await this.userRepository.findOne({
+            where: { username: username },
+            relations: { roles: true }
+        });
+
+        if (!user) {
+            throw new Error(`User with username '${username}' not found.`);
+        }
+
+        const roles = await this.roleRepository.find({
+            where: roleNames.map(roleName => ({ name: roleName }))
+        });
+
+        if (roles.length !== roleNames.length) {
+            const foundRoleNames = roles.map(role => role.name);
+            const missingRoles = roleNames.filter(roleName => !foundRoleNames.includes(roleName));
+            throw new Error(`The following roles were not found: ${missingRoles.join(', ')}`);
+        }
+
+        const currentRoles = user.roles.map(role => role.name);
+
+        const rolesToAdd = roles.filter(role => !currentRoles.includes(role.name));
+
+        const rolesToRemove = user.roles.filter(role => !roleNames.includes(role.name));
+
+        if (rolesToAdd.length > 0) {
+            user.roles.push(...rolesToAdd);
+        }
+
+        if (rolesToRemove.length > 0) {
+            user.roles = user.roles.filter(role => !rolesToRemove.includes(role));
+        }
+
+        return await this.userRepository.save(user);
+    }
+
+
+    async removeRoleFromUser(username: string, roleName: string): Promise<User> {
+
+        // load the role with the respective permissions.
+        const user = await this.userRepository.findOne({
+            where: {
+                username: username
+            },
+            relations: {
+                roles: true
+            }
+        });
+
+        if (!user) {
+            throw new Error(`User with username '${username}' not found.`);
+        }
+
+        // modify the permissions array.
+        user.roles = user.roles.filter(role => role.name !== roleName);
+
+        return await this.userRepository.save(user);
+    }
+
+    // PROVIDER SPECIFIC CODE
+    async resolveUserOnOauthGoogle(oauthUserDto: OauthUserDto): Promise<User> {
+        const user = await this.userRepository.findOne({
+            where: {
+                email: oauthUserDto.email,
+            },
+            relations: {
+                roles: true
+            }
+        });
+
+        // if we are unable to find a user then we need to create one. 
+        if (!user) {
+            const user = new User();
+            user.username = oauthUserDto.email;
+            user.email = oauthUserDto.email;
+            user.lastLoginProvider = oauthUserDto.provider;
+            user.accessCode = oauthUserDto.accessCode;
+            user.googleAccessToken = oauthUserDto.accessToken;
+            user.googleId = oauthUserDto.providerId;
+            user.googleProfilePicture = oauthUserDto.picture;
+
+            return await this.userRepository.save(user);
+        }
+        // else we update the user and store the generated code & access token. 
+        else {
+            const entity = await this.userRepository.preload({
+                id: user.id,
+                lastLoginProvider: oauthUserDto.provider,
+                accessCode: oauthUserDto.accessCode,
+                googleAccessToken: oauthUserDto.accessToken,
+                googleId: oauthUserDto.providerId,
+                googleProfilePicture: oauthUserDto.picture,
+            });
+
+            await this.userRepository.save(entity);
+        }
+
+        return user;
+    }
+
+    // async addPermissionToUser(userEmail: string, permissionName: string) {
+    //     // TODO: Find the role, find the permission and add them all to the specified userid.
+    // }
+
+    // async removePermissionFromUser(userEmail: string, permissionName: string) {
+    //     // TODO: Find the role, find the permission and remove them all to the specified userid.
+    // }
+
+    async updateUser(id: number, userDetails: UpdateUserDto) {
+        if (!id) {
+            throw new Error('User id is required');
+        }
+        const user = await this.findOne(id);
+        const savedUser = this.userRepository.merge(user, userDetails);
+        return await this.userRepository.save(savedUser);
+    }
+
+    async findUsersByRole(roleName: string, relations: any = {}): Promise<User[]> {
+        return await this.userRepository.find({
+            where: {
+                roles: {
+                    name: roleName
+                }
+            },
+            relations: relations
+        });
+    }
+    async remove(id: number) {
+        if (!id) {
+            throw new Error(`Id Not Found`);
+        }
+        const entity = await this.findOne(id);
+        if (!entity) {
+            throw new Error(`Entity with id ${id} not found`);
+        }
+
+        return this.userRepository.remove(entity);
+    }
+
+    async deleteMany(ids: number[]): Promise<any> {
+        if (!ids || ids.length === 0) {
+            throw new Error('At least one ID is required for deletion');
+        }
+        const removedEntities = [];
+        for (let i = 0; i < ids.length; i++) {
+            const id = ids[i]
+            const entity = await this.userRepository.findOne({
+                where: {
+                    //@ts-ignore
+                    id: id,
+                }
+            });
+            // if (!entity) {
+            //     throw new Error(`Entity with id ${id} not found`);
+            // }
+            removedEntities.push(await this.userRepository.remove(entity));
+        }
+
+        return removedEntities
+    }
+
+
+    private buildFilterConditions(filters: Record<string, any>) {
+        const conditions: Record<string, any> = {};
+
+        Object.keys(filters).forEach((key) => {
+            let value = filters[key];
+
+            if (Array.isArray(value)) {
+                conditions[key] = { $in: value };
+            } else {
+                conditions[key] = { $containsi: value };
+            }
+        });
+
+        return conditions;
+    }
+}

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

@@ -0,0 +1,143 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { DiscoveryService } from "@nestjs/core";
+import { EntityManager, Repository } from 'typeorm';
+import { CRUDService } from 'src/services/crud.service';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { ModuleMetadataService } from 'src/services/module-metadata.service';
+import { MediaStorageProviderMetadataService } from 'src/services/media-storage-provider-metadata.service';
+import { ConfigService } from '@nestjs/config';
+import { MediaService } from "src/services/media.service";
+import { FileService } from "src/services/file.service";
+import { CrudHelperService } from "src/services/crud-helper.service";
+
+
+import { ViewMetadata } from '../entities/view-metadata.entity';
+import { FieldMetadata } from '../entities/field-metadata.entity';
+import { ModelMetadata } from '../entities/model-metadata.entity';
+import { UpdateViewMetadataDto } from '../dtos/update-view-metadata.dto';
+import { ActionMetadataService } from './action-metadata.service';
+
+@Injectable()
+export class ViewMetadataService extends CRUDService<ViewMetadata> {
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly mediaStorageProviderService: MediaStorageProviderMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly mediaService: MediaService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    readonly actionMetadataService: ActionMetadataService,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(ViewMetadata, 'default')
+    readonly repo: Repository<ViewMetadata>,
+    @InjectRepository(FieldMetadata)
+    private readonly fieldMetadataRepo: Repository<FieldMetadata>,
+    @InjectRepository(ModelMetadata)
+    private readonly modelMetadataRepo: Repository<ModelMetadata>,
+  ) {
+    super(modelMetadataService, moduleMetadataService, mediaStorageProviderService, configService, fileService, mediaService, discoveryService, crudHelperService, entityManager, repo, 'viewMetadata', 'app-builder');
+  }
+
+  // START: Custom Service Methods
+  async getLayout(query) {
+    let { modelName, moduleName, viewType, populate } = query;
+
+    // modelName = camelize(modelName);
+
+    // Fetch the view based on module, model & view name.
+    const entity = await this.repo.findOne({
+      where: {
+        model: { singularName: modelName },
+        module: { name: moduleName },
+        type: viewType,
+      },
+      relations: {
+        model: {
+          userKeyField: true,  // Nested population of 'someOtherEntity' within 'model'
+        },    
+        module: true,
+      }
+    });
+    if (entity) {
+      entity.layout = JSON.parse(entity.layout);
+      if (entity?.layout?.attrs?.createAction) {
+        const actionName: string = entity.layout.attrs.createAction;
+        entity.layout.attrs.createAction = await this.actionMetadataService.findOneByUserKey(actionName)
+      }
+      if (entity?.layout?.attrs?.editAction) {
+        const actionName: string = entity.layout.attrs.editAction;
+        entity.layout.attrs.editAction = await this.actionMetadataService.findOneByUserKey(actionName)
+      }
+    }
+    // We also need to fetch a map of fields.
+    const fields = await this.fieldMetadataRepo.find({
+      where: {
+        model: {
+          singularName: modelName,
+        }
+      }
+    });
+    const fieldsMap = new Map<string, FieldMetadata>();
+    for (let i = 0; i < fields.length; i++) {
+      const field = fields[i];
+
+      // For fields of type relation & relationType many-to-one
+      // We fetch metadata regarding the relationModelSingularName
+      if (field.type === 'relation') {
+        const relationModel = await this.modelMetadataRepo.find({
+          where: {
+            singularName: field.relationModelSingularName
+          },
+          relations: {
+            userKeyField: true
+          }
+        });
+
+        if (relationModel) {
+          field['relationModel'] = relationModel[0];
+        }
+      }
+      if (!fieldsMap.has(field.name)) {
+        fieldsMap.set(field.name, field);
+      }
+    }
+
+    return {
+      'solidView': entity,
+      'solidFieldsMetadata': Object.fromEntries(fieldsMap),
+    };
+  }
+
+  async findOneByUserKey(name: string, relations = {}) {
+    const entity = await this.repo.findOne({
+      where: {
+        name: name,
+      },
+      relations: relations,
+    });
+    return entity;
+  }
+
+  async upsert(updateSolidViewDto: UpdateViewMetadataDto) {
+    // First check if module already exists using name
+    const existingSolidView = await this.findOneByUserKey(updateSolidViewDto.name);
+
+    // if found
+    if (existingSolidView) {
+      const updatedSolidViewDto = { ...existingSolidView, ...updateSolidViewDto };
+      return this.repo.save(updatedSolidViewDto);
+    }
+    // if not found - create new 
+    else {
+      const viewData = this.repo.create(updateSolidViewDto);
+      return this.repo.save(viewData);
+    }
+  }
+
+  // END: Custom Service Methods
+
+}

package/src/services/whatsapp/Msg91WhatsappService.ts

@@ -0,0 +1,149 @@
+import { HttpService } from '@nestjs/axios';
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { ConfigType } from '@nestjs/config';
+import commonConfig from 'src/config/common.config';
+import { WhatsappQueuePublisher } from 'src/jobs/whatsapp-publisher.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import { SmsTemplateService } from '../sms-template.service';
+import { Msg91BaseSMSService } from '../sms/Msg91BaseSMSService';
+import { ISMS } from "../../interfaces";
+
+enum Msg91WhatsappParameterHeaderType {
+  image,
+  text,
+}
+
+export interface Msg91WhatsappParameter {
+  header?: {
+    type: Msg91WhatsappParameterHeaderType;
+    value: string;
+  };
+  body: string[];
+}
+
+interface WhatsappRequest {
+  integrated_number: string;
+  content_type: string;
+  payload: WhatsappPayload;
+}
+
+interface WhatsappPayload {
+  messaging_product: string;
+  type: string;
+  template: WhatsappTemplate;
+}
+
+interface WhatsappTemplate {
+  name: string;
+  language: WhatsappLanguage;
+  namespace: string;
+  to_and_components: WhatsappToAndComponents[];
+}
+
+interface WhatsappLanguage {
+  code: string;
+  policy: string;
+}
+
+interface WhatsappToAndComponents {
+  to: string[];
+  components: any;
+}
+
+@Injectable()
+export class Msg91WhatsappService extends Msg91BaseSMSService implements ISMS {
+  readonly logger = new Logger(Msg91WhatsappService.name);
+
+  constructor(
+    @Inject(commonConfig.KEY)
+    commonConfiguration: ConfigType<typeof commonConfig>,
+    whatsappPublisher: WhatsappQueuePublisher,
+    smsTemplateService: SmsTemplateService,
+    private readonly httpService: HttpService,
+  ) {
+    super(commonConfiguration, whatsappPublisher, smsTemplateService);
+  }
+
+  async sendSMSSynchronously(message: QueueMessage<any>): Promise<void> {
+    const body = this.createWhatsappRequest(message);
+    const headers = { authkey: this.commonConfiguration.msg91Whatsapp.apiKey };
+    await this.httpService.axiosRef.post(
+      `${this.commonConfiguration.msg91Whatsapp.url}`,
+      body,
+      { headers },
+    );
+    this.logger.debug(
+      `Sending Whatsapp message for CP registration with body ${JSON.stringify(body)} and url ${this.commonConfiguration.msg91Whatsapp.url}`,
+    );
+  }
+
+  private createWhatsappRequest(message: QueueMessage<any>): WhatsappRequest {
+    const { to, templateId, ...parameters } = message.payload;
+    const whatsappToAndComponents = this.createWhatsappToAndComponents(
+      to,
+      parameters,
+    );
+    const whatsappLanguage = {
+      code: 'en',
+      policy: 'deterministic',
+    };
+    const whatsappTemplate = this.createWhatsappTemplate(
+      templateId,
+      whatsappToAndComponents,
+      whatsappLanguage,
+    );
+    const whatsappPayload = {
+      messaging_product: 'whatsapp',
+      type: 'template',
+      template: whatsappTemplate,
+    };
+    return {
+      integrated_number:
+        this.commonConfiguration.msg91Whatsapp.integratedNumber,
+      content_type: 'template',
+      payload: whatsappPayload,
+    };
+  }
+
+  private createWhatsappToAndComponents(
+    to: string,
+    parameters: Msg91WhatsappParameter,
+  ): WhatsappToAndComponents {
+    return {
+      to: [to],
+      components: this.createWhatsappComponents(parameters),
+    };
+  }
+
+  private createWhatsappComponents(parameters: Msg91WhatsappParameter): any {
+    const components = {};
+    if (parameters.header) {
+      components['header_1'] = {
+        type: parameters.header.type,
+        value: parameters.header.value,
+      };
+    }
+    if (parameters.body && parameters.body.length > 0) {
+      parameters.body.forEach((elem, index) => {
+        components[`body_${index + 1}`] = {
+          type: 'text',
+          value: elem,
+        };
+      });
+    }
+    return components;
+  }
+
+  private createWhatsappTemplate(
+    templateName: string,
+    toAndComponents: WhatsappToAndComponents,
+    language: WhatsappLanguage,
+  ): WhatsappTemplate {
+    return {
+      name: templateName,
+      language: language,
+      namespace: null,
+      to_and_components: [toAndComponents],
+    };
+  }
+}