Merge pull request #1178 from rocket-admin/backend_demo_user_account

feat: add demo user registration functionality and related entities

Author: Artuomka

backend/src/common/data-injection.tokens.ts

@@ -99,6 +99,7 @@ export enum UseCaseType {
   SAAS_COMPANY_REGISTRATION = 'SAAS_COMPANY_REGISTRATION',
   SAAS_GET_USER_INFO = 'SAAS_GET_USER_INFO',
   SAAS_USUAL_REGISTER_USER = 'SAAS_USUAL_REGISTER_USER',
+  SAAS_DEMO_USER_REGISTRATION = 'SAAS_DEMO_USER_REGISTRATION',
   SAAS_LOGIN_USER_WITH_GOOGLE = 'SAAS_LOGIN_USER_WITH_GOOGLE',
   SAAS_LOGIN_USER_WITH_GITHUB = 'SAAS_LOGIN_USER_WITH_GITHUB',
   SAAS_SAAS_GET_USERS_INFOS_BY_EMAIL = 'SAAS_SAAS_GET_USERS_INFOS_BY_EMAIL',

backend/src/entities/user/application/data-structures/demo-user-account-register.ds.ts

@@ -0,0 +1,6 @@
+export class SaaSRegisterDemoUserAccountDS {
+  email: string;
+  gclidValue: string;
+  companyName: string;
+  companyId: string;
+}

backend/src/entities/user/user.entity.ts

@@ -44,6 +44,9 @@ export class UserEntity {
   @Column({ default: false })
   suspended: boolean;
 
+  @Column({ default: false })
+  isDemoAccount: boolean;
+
   @BeforeInsert()
   async hashPassword() {
     if (this.password) {

backend/src/microservices/saas-microservice/saas.controller.ts

@@ -18,6 +18,7 @@ import {
   IGetUserInfo,
   ILoginUserWithGitHub,
   ILoginUserWithGoogle,
+  ISaasDemoRegisterUser,
   ISaaSGetCompanyInfoByUserId,
   ISaaSGetUsersCountInCompany,
   ISaasGetUsersInfosByEmail,
@@ -41,6 +42,8 @@ export class SaasController {
     private readonly getUsersInfosByEmailUseCase: ISaasGetUsersInfosByEmail,
     @Inject(UseCaseType.SAAS_USUAL_REGISTER_USER)
     private readonly usualRegisterUserUseCase: ISaasRegisterUser,
+    @Inject(UseCaseType.SAAS_DEMO_USER_REGISTRATION)
+    private readonly demoRegisterUserUseCase: ISaasDemoRegisterUser,
     @Inject(UseCaseType.SAAS_LOGIN_USER_WITH_GOOGLE)
     private readonly loginUserWithGoogleUseCase: ILoginUserWithGoogle,
     @Inject(UseCaseType.SAAS_LOGIN_USER_WITH_GITHUB)
@@ -117,6 +120,23 @@ export class SaasController {
     return await this.usualRegisterUserUseCase.execute({ email, password, gclidValue, name, companyId, companyName });
   }
 
+  @ApiOperation({ summary: 'Register demo user register webhook' })
+  @ApiBody({ type: SaasUsualUserRegisterDS })
+  @ApiResponse({
+    status: 201,
+    description: 'Demo user account has been successfully registered.',
+    type: FoundUserDto,
+  })
+  @Post('user/demo/register')
+  async registerDemoUserAccount(
+    @Body('email') email: string,
+    @Body('gclidValue') gclidValue: string,
+    @Body('companyId') companyId: string,
+    @Body('companyName') companyName: string,
+  ): Promise<FoundUserDto> {
+    return await this.demoRegisterUserUseCase.execute({ email, gclidValue, companyId, companyName });
+  }
+
   @ApiOperation({ summary: 'Login or create user with google webhook' })
   @ApiBody({ type: SaasRegisterUserWithGoogleDS })
   @ApiResponse({

backend/src/microservices/saas-microservice/saas.module.ts

@@ -14,6 +14,7 @@ import { RegisteredCompanyWebhookUseCase } from './use-cases/register-company-we
 import { SaasUsualRegisterUseCase } from './use-cases/saas-usual-register-user.use.case.js';
 import { SuspendUsersUseCase } from './use-cases/suspend-users.use.case.js';
 import { UnFreezeConnectionsInCompanyUseCase } from './use-cases/unfreeze-connections-in-company-use.case.js';
+import { SaasRegisterDemoUserAccountUseCase } from './use-cases/register-demo-user-account.use.case.js';
 
 @Module({
   imports: [],
@@ -66,6 +67,10 @@ import { UnFreezeConnectionsInCompanyUseCase } from './use-cases/unfreeze-connec
       provide: UseCaseType.UNFREEZE_CONNECTIONS_IN_COMPANY,
       useClass: UnFreezeConnectionsInCompanyUseCase,
     },
+    {
+      provide: UseCaseType.SAAS_DEMO_USER_REGISTRATION,
+      useClass: SaasRegisterDemoUserAccountUseCase,
+    },
   ],
   controllers: [SaasController],
   exports: [],
@@ -78,6 +83,7 @@ export class SaasModule {
         { path: 'saas/company/registered', method: RequestMethod.POST },
         { path: 'saas/user/:userId', method: RequestMethod.GET },
         { path: 'saas/user/register', method: RequestMethod.POST },
+        { path: 'saas/user/demo/register', method: RequestMethod.POST },
         { path: 'saas/user/google/login', method: RequestMethod.POST },
         { path: 'saas/user/github/login', method: RequestMethod.POST },
         { path: 'saas/company/:companyId/users/suspend', method: RequestMethod.PUT },

backend/src/microservices/saas-microservice/use-cases/register-demo-user-account.use.case.ts

@@ -0,0 +1,122 @@
+import { Inject, Injectable } from '@nestjs/common';
+import AbstractUseCase from '../../../common/abstract-use.case.js';
+import { IGlobalDatabaseContext } from '../../../common/application/global-database-context.interface.js';
+import { BaseType } from '../../../common/data-injection.tokens.js';
+import { CompanyInfoEntity } from '../../../entities/company-info/company-info.entity.js';
+import { ConnectionEntity } from '../../../entities/connection/connection.entity.js';
+import { GroupEntity } from '../../../entities/group/group.entity.js';
+import { PermissionEntity } from '../../../entities/permission/permission.entity.js';
+import { SaaSRegisterDemoUserAccountDS } from '../../../entities/user/application/data-structures/demo-user-account-register.ds.js';
+import { FoundUserDto } from '../../../entities/user/dto/found-user.dto.js';
+import { UserRoleEnum } from '../../../entities/user/enums/user-role.enum.js';
+import { UserEntity } from '../../../entities/user/user.entity.js';
+import { buildConnectionEntitiesFromTestDtos } from '../../../entities/user/utils/build-connection-entities-from-test-dtos.js';
+import { buildDefaultAdminGroups } from '../../../entities/user/utils/build-default-admin-groups.js';
+import { buildDefaultAdminPermissions } from '../../../entities/user/utils/build-default-admin-permissions.js';
+import { Constants } from '../../../helpers/constants/constants.js';
+import { ISaasDemoRegisterUser } from './saas-use-cases.interface.js';
+
+@Injectable()
+export class SaasRegisterDemoUserAccountUseCase
+  extends AbstractUseCase<SaaSRegisterDemoUserAccountDS, FoundUserDto>
+  implements ISaasDemoRegisterUser
+{
+  constructor(
+    @Inject(BaseType.GLOBAL_DB_CONTEXT)
+    protected _dbContext: IGlobalDatabaseContext,
+  ) {
+    super();
+  }
+
+  protected async implementation(userData: SaaSRegisterDemoUserAccountDS): Promise<FoundUserDto> {
+    const savedUser = await this.createDemoUser(userData);
+    const createdTestConnections = await this.createTestConnections(savedUser);
+    const createdTestGroups = await this.createTestGroups(savedUser, createdTestConnections);
+    await this.createTestPermissions(createdTestGroups);
+    const savedCompanyInfo = await this.createCompanyInfo(userData, createdTestConnections);
+
+    savedUser.company = savedCompanyInfo;
+    await this._dbContext.userRepository.saveUserEntity(savedUser);
+
+    return this.buildFoundUserDto(savedUser);
+  }
+
+  private async createDemoUser(userData: SaaSRegisterDemoUserAccountDS): Promise<UserEntity> {
+    const { email, gclidValue } = userData;
+
+    const demoUser = new UserEntity();
+    demoUser.email = email;
+    demoUser.isDemoAccount = true;
+    demoUser.gclid = gclidValue;
+    demoUser.name = 'Demo User';
+    demoUser.role = UserRoleEnum.ADMIN;
+
+    return await this._dbContext.userRepository.save(demoUser);
+  }
+
+  private async createTestConnections(savedUser: UserEntity): Promise<ConnectionEntity[]> {
+    const testConnections = Constants.getTestConnectionsArr();
+    const testConnectionsEntities = buildConnectionEntitiesFromTestDtos(testConnections);
+
+    return await Promise.all(
+      testConnectionsEntities.map(async (connection): Promise<ConnectionEntity> => {
+        connection.author = savedUser;
+        return await this._dbContext.connectionRepository.saveNewConnection(connection);
+      }),
+    );
+  }
+
+  private async createTestGroups(
+    savedUser: UserEntity,
+    createdTestConnections: ConnectionEntity[],
+  ): Promise<GroupEntity[]> {
+    const testGroupsEntities = buildDefaultAdminGroups(savedUser, createdTestConnections);
+
+    return await Promise.all(
+      testGroupsEntities.map(async (group: GroupEntity) => {
+        return await this._dbContext.groupRepository.saveNewOrUpdatedGroup(group);
+      }),
+    );
+  }
+
+  private async createTestPermissions(createdTestGroups: GroupEntity[]): Promise<void> {
+    const testPermissionsEntities = buildDefaultAdminPermissions(createdTestGroups);
+
+    await Promise.all(
+      testPermissionsEntities.map(async (permission: PermissionEntity) => {
+        await this._dbContext.permissionRepository.saveNewOrUpdatedPermission(permission);
+      }),
+    );
+  }
+
+  private async createCompanyInfo(
+    userData: SaaSRegisterDemoUserAccountDS,
+    createdTestConnections: ConnectionEntity[],
+  ): Promise<CompanyInfoEntity> {
+    const { companyId, companyName } = userData;
+
+    const newCompanyInfo = new CompanyInfoEntity();
+    newCompanyInfo.id = companyId;
+    newCompanyInfo.name = companyName;
+    newCompanyInfo.show_test_connections = true;
+    newCompanyInfo.connections = [...createdTestConnections];
+
+    return await this._dbContext.companyInfoRepository.save(newCompanyInfo);
+  }
+
+  private buildFoundUserDto(savedUser: UserEntity): FoundUserDto {
+    return {
+      id: savedUser.id,
+      createdAt: savedUser.createdAt,
+      isActive: savedUser.isActive,
+      email: savedUser.email,
+      intercom_hash: null,
+      name: savedUser.name,
+      role: savedUser.role,
+      is_2fa_enabled: false,
+      suspended: false,
+      externalRegistrationProvider: savedUser.externalRegistrationProvider,
+      show_test_connections: savedUser.showTestConnections,
+    };
+  }
+}

backend/src/microservices/saas-microservice/use-cases/saas-use-cases.interface.ts

@@ -1,4 +1,5 @@
 import { CompanyInfoEntity } from '../../../entities/company-info/company-info.entity.js';
+import { SaaSRegisterDemoUserAccountDS } from '../../../entities/user/application/data-structures/demo-user-account-register.ds.js';
 import { SaasUsualUserRegisterDS } from '../../../entities/user/application/data-structures/usual-register-user.ds.js';
 import { FoundUserDto } from '../../../entities/user/dto/found-user.dto.js';
 import { UserEntity } from '../../../entities/user/user.entity.js';
@@ -29,6 +30,10 @@ export interface ISaasRegisterUser {
   execute(userData: SaasUsualUserRegisterDS): Promise<FoundUserDto>;
 }
 
+export interface ISaasDemoRegisterUser {
+  execute(userData: SaaSRegisterDemoUserAccountDS): Promise<FoundUserDto>;
+}
+
 export interface ILoginUserWithGoogle {
   execute(inputData: SaasRegisterUserWithGoogleDS, inTransaction: InTransactionEnum): Promise<UserEntity>;
 }

backend/src/microservices/saas-microservice/use-cases/saas-usual-register-user.use.case.ts

@@ -1,4 +1,4 @@
-import { HttpException, HttpStatus, Inject } from '@nestjs/common';
+import { HttpException, HttpStatus, Inject, Injectable } from '@nestjs/common';
 import assert from 'assert';
 import AbstractUseCase from '../../../common/abstract-use.case.js';
 import { IGlobalDatabaseContext } from '../../../common/application/global-database-context.interface.js';
@@ -21,6 +21,7 @@ import { Constants } from '../../../helpers/constants/constants.js';
 import { SaasCompanyGatewayService } from '../../gateways/saas-gateway.ts/saas-company-gateway.service.js';
 import { ISaasRegisterUser } from './saas-use-cases.interface.js';
 
+@Injectable()
 export class SaasUsualRegisterUseCase
   extends AbstractUseCase<SaasUsualUserRegisterDS, FoundUserDto>
   implements ISaasRegisterUser

backend/src/migrations/1747235569575-AddIsDemoAccountToUserEntity.ts

@@ -0,0 +1,13 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddIsDemoAccountToUserEntity1747235569575 implements MigrationInterface {
+  name = 'AddIsDemoAccountToUserEntity1747235569575';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "user" ADD "isDemoAccount" boolean NOT NULL DEFAULT false`);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "user" DROP COLUMN "isDemoAccount"`);
+  }
+}

backend/test/ava-tests/saas-tests/user-e2e.test.ts

@@ -20,10 +20,15 @@ import {
 import { sendRequestToSaasPart } from '../../utils/send-request-to-saas-part.util.js';
 import { TestUtils } from '../../utils/test.utils.js';
 import { Cacher } from '../../../src/helpers/cache/cacher.js';
+import { Constants } from '../../../src/helpers/constants/constants.js';
+import { getTestData } from '../../utils/get-test-data.js';
+import { createTestTable } from '../../utils/create-test-table.js';
+import { MockFactory } from '../../mock.factory.js';
 
 let app: INestApplication;
 let currentTest: string;
 let testUtils: TestUtils;
+const mockFactory = new MockFactory();
 
 test.before(async () => {
   const moduleFixture = await Test.createTestingModule({
@@ -469,3 +474,112 @@ test.skip(`${currentTest} should login user successfully with company id from cu
   }
   t.pass();
 });
+
+currentTest = 'POST /user/demo/register';
+test.serial(`${currentTest} should register demo user`, async (t) => {
+  const result = await fetch('http://rocketadmin-private-microservice:3001/saas/user/demo/register', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Accept: 'application/json',
+    },
+  });
+  if (result.status > 201) {
+    console.info('result.body -> ', await result.json());
+  }
+  const token = `${Constants.JWT_COOKIE_KEY_NAME}=${TestUtils.getJwtTokenFromResponse2(result)}`;
+
+  //check test connections was created
+  const getUserConnectionsResult = await request(app.getHttpServer())
+    .get('/connections')
+    .set('Cookie', token)
+    .set('Content-Type', 'application/json')
+    .set('Accept', 'application/json');
+  const getUserConnectionsRO = JSON.parse(getUserConnectionsResult.text);
+  t.is(getUserConnectionsResult.status, 200);
+  t.is(getUserConnectionsRO.hasOwnProperty('connections'), true);
+  t.is(getUserConnectionsRO.connections.length, 4);
+
+  //check user can add connection and use it
+
+  const connectionToTestDB = getTestData(mockFactory).connectionToPostgres;
+
+  const { testTableName, testTableColumnName, testEntitiesSeedsCount, testTableSecondColumnName } =
+    await createTestTable(connectionToTestDB);
+
+  const createConnectionResponse = await request(app.getHttpServer())
+    .post('/connection')
+    .send(connectionToTestDB)
+    .set('Cookie', token)
+    .set('Content-Type', 'application/json')
+    .set('Accept', 'application/json');
+  const createConnectionRO = JSON.parse(createConnectionResponse.text);
+  t.is(createConnectionResponse.status, 201);
+
+  const getTableRowsResponse = await request(app.getHttpServer())
+    .get(`/table/rows/${createConnectionRO.id}?tableName=${testTableName}&page=1&perPage=50`)
+    .set('Cookie', token)
+    .set('Content-Type', 'application/json')
+    .set('Accept', 'application/json');
+
+  const getTableRowsRO = JSON.parse(getTableRowsResponse.text);
+  t.is(getTableRowsResponse.status, 200);
+
+  t.is(typeof getTableRowsRO, 'object');
+  t.is(getTableRowsRO.hasOwnProperty('rows'), true);
+  t.is(getTableRowsRO.hasOwnProperty('primaryColumns'), true);
+  t.is(getTableRowsRO.hasOwnProperty('pagination'), true);
+  t.is(getTableRowsRO.rows.length, 42);
+  t.is(typeof getTableRowsRO.primaryColumns, 'object');
+  t.is(getTableRowsRO.primaryColumns[0].hasOwnProperty('column_name'), true);
+  t.is(getTableRowsRO.primaryColumns[0].hasOwnProperty('data_type'), true);
+  t.is(getTableRowsRO.primaryColumns[0].column_name, 'id');
+  t.is(getTableRowsRO.primaryColumns[0].data_type, 'integer');
+
+  //check that user has a company
+
+  const getUserCompanyResult = await request(app.getHttpServer())
+    .get('/company/my/full')
+    .set('Cookie', token)
+    .set('Content-Type', 'application/json')
+    .set('Accept', 'application/json');
+  const getUserCompanyRO = JSON.parse(getUserCompanyResult.text);
+  t.is(getUserCompanyResult.status, 200);
+
+  t.truthy(getUserCompanyRO);
+  t.is(typeof getUserCompanyRO, 'object');
+  t.is(getUserCompanyRO.hasOwnProperty('id'), true);
+  t.is(typeof getUserCompanyRO.id, 'string');
+  t.is(getUserCompanyRO.hasOwnProperty('name'), true);
+  t.is(typeof getUserCompanyRO.name, 'string');
+  t.is(getUserCompanyRO.hasOwnProperty('subscriptionLevel'), true);
+  t.is(getUserCompanyRO.subscriptionLevel, 'TEAM_PLAN');
+  t.is(getUserCompanyRO.hasOwnProperty('is_payment_method_added'), true);
+  t.is(getUserCompanyRO.is_payment_method_added, false);
+  t.is(getUserCompanyRO.hasOwnProperty('is2faEnabled'), true);
+  t.is(getUserCompanyRO.is2faEnabled, false);
+  t.is(getUserCompanyRO.hasOwnProperty('show_test_connections'), true);
+  t.is(getUserCompanyRO.show_test_connections, true);
+  t.is(getUserCompanyRO.hasOwnProperty('connections'), true);
+  t.true(Array.isArray(getUserCompanyRO.connections));
+  t.is(getUserCompanyRO.connections.length, 5);
+
+  for (const connection of getUserCompanyRO.connections) {
+    t.is(typeof connection.id, 'string');
+    t.is(typeof connection.title, 'string');
+    t.is(typeof connection.author, 'object');
+    t.is(connection.author.role, 'ADMIN');
+    t.true(Array.isArray(connection.groups));
+    for (const group of connection.groups) {
+      t.is(typeof group.id, 'string');
+      t.is(group.isMain, true);
+      t.is(typeof group.title, 'string');
+      t.true(Array.isArray(group.users));
+      for (const user of group.users) {
+        t.is(typeof user.id, 'string');
+        t.is(user.role, 'ADMIN');
+        t.is(typeof user.email, 'string');
+      }
+    }
+  }
+});