@solidstarters/solid-core 1.2.0

package/src/seeders/sms-template-seeder.service.ts

@@ -0,0 +1,48 @@
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { ConfigType } from '@nestjs/config';
+import commonConfig from '../config/common.config';
+import { CreateSmsTemplateDto } from '../dtos/create-sms-template.dto';
+import { SmsTemplateService } from '../services/sms-template.service';
+
+@Injectable()
+export class SmsTemplateSeederService {
+    private readonly logger = new Logger(SmsTemplateSeederService.name);
+
+    constructor(
+        private readonly smsTemplateService: SmsTemplateService,
+        @Inject(commonConfig.KEY)
+        private readonly commonConfiguration: ConfigType<typeof commonConfig>,
+    ) { }
+
+    async seed() {
+        // Read the module metadata from a file specified in the .env 
+        const seedDataFiles = this.commonConfiguration.smsTemplateSeederFiles.split(',');
+        for (let i = 0; i < seedDataFiles.length; i++) {
+            const seedDataFile = seedDataFiles[i];
+            const fullPath = path.join(process.cwd(), seedDataFile);
+
+            // For each module metadata seed file provided, read contents, parse & convert to a variable. 
+            this.logger.log(`Using sms template seed data: ${fullPath}`);
+            const smsTemplateJson = fs.readFileSync(fullPath, 'utf-8').toString();
+            const smsTemplates: CreateSmsTemplateDto[] = JSON.parse(smsTemplateJson);
+
+            for (let i = 0; i < smsTemplates.length; i++) {
+                const smsTemplate = smsTemplates[i];
+                this.logger.log(`Found ${smsTemplate.name} sms template`);
+
+                // We need to load the actual template contents. 
+                if (smsTemplate.body) {
+                    const smsTemplateFilePath = path.join(process.cwd(), smsTemplate.body);
+                    smsTemplate.body = fs.readFileSync(smsTemplateFilePath, 'utf-8').toString()
+                }
+
+                // Save to DB.
+                await this.smsTemplateService.removeByName(smsTemplate.name);
+                await this.smsTemplateService.create(smsTemplate);
+            }
+        }
+    }
+}

package/src/seeders/user-seeder.service.ts

@@ -0,0 +1,32 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { AuthenticationService } from '../services/authentication.service';
+import { UserService } from '../services/user.service';
+
+@Injectable()
+export class UserSeederService {
+    private readonly logger = new Logger(UserSeederService.name);
+
+    constructor(
+        private readonly authenticationService: AuthenticationService,
+        private readonly userService: UserService,
+    ) { }
+
+    async seed() {
+        // see if the user already exists, 
+        let user = await this.userService.findOneByUsername("admin@example.service.com");
+
+        if (!user) {
+            user = await this.authenticationService.signUp({
+                username: 'admin@example.service.com',
+                email: 'admin@example.service.com',
+                password: 'Admin@3214$',
+            });    
+
+            this.logger.log(`Newly created user is ${user}`);
+        }
+
+        // now make this user an Admin by adding them to the Admin role group. 
+        await this.userService.addRoleToUser(user.email, "Admin");
+        await this.userService.addRoleToUser(user.email, "Public");
+    }
+}

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

@@ -0,0 +1,66 @@
+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 { ActionMetadata } from '../entities/action-metadata.entity';
+
+@Injectable()
+export class ActionMetadataService extends CRUDService<ActionMetadata> {
+  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,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(ActionMetadata, 'default')
+    readonly repo: Repository<ActionMetadata>,
+  ) {
+    super(modelMetadataService, moduleMetadataService, mediaStorageProviderService, configService, fileService, mediaService, discoveryService, crudHelperService, entityManager, repo, 'actionMetadata', 'app-builder');
+  }
+
+  async findOneByUserKey(name: string, relations = {}) {
+    const entity = await this.repo.findOne({
+      where: {
+        name: name,
+      },
+      relations: relations,
+    });
+    return entity;
+  }
+
+  async upsert(updateSolidActionDto: any) {
+    // First check if module already exists using name
+    const existingSolidAction = await this.repo.findOne({
+      where: {
+        name: updateSolidActionDto.name
+      }
+    })
+
+    // if found
+    if (existingSolidAction) {
+      const updatedSolidActionDto = { ...existingSolidAction, ...updateSolidActionDto };
+      return this.repo.save(updatedSolidActionDto);
+    }
+    // if not found - create new 
+    else {
+      const moduleMetadata = this.repo.create(updateSolidActionDto);
+      return this.repo.save(moduleMetadata);
+    }
+  }
+
+}