WIP rename user schema to entity

Author: tacxou

service/src/_common/enum/entity-type.enum.ts

@@ -0,0 +1,12 @@
+export enum EntityType {
+  CONSOLE = 0,
+  OPERATOR = 1,
+  AGENT = 2,
+  CLIENT = 3,
+  COMPANY = 4,
+  OTHER = 99,
+}
+
+export const EntityTypeList: number[] = Object.keys(EntityType)
+  .filter((k) => typeof EntityType[k as any] === 'number')
+  .map((k) => parseInt(EntityType[k as any], 10))

service/src/_common/enum/user-type.enum.ts

@@ -1,15 +1,15 @@
 import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose'
 import { IdnamePart } from '~/_common/schemas/parts/idname.part.schema'
-import { UserTypeList } from '~/_common/enum/user-type.enum'
+import { EntityTypeList } from '~/_common/enum/entity-type.enum'
 
 @Schema({ _id: false })
-export class UserPart extends IdnamePart {
+export class EntityPart extends IdnamePart {
   @Prop({
     type: Number,
-    enum: UserTypeList,
+    enum: EntityTypeList,
     required: true,
   })
   public type: number
 }
 
-export const UserPartSchema = SchemaFactory.createForClass(UserPart)
+export const EntityPartSchema = SchemaFactory.createForClass(EntityPart)

…common/schemas/parts/user.part.schema.ts …mmon/schemas/parts/entity.part.schema.tsservice/src/_common/schemas/parts/user.part.schema.ts renamed to service/src/_common/schemas/parts/entity.part.schema.ts service/src/_common/schemas/parts/user.part.schema.ts renamed to service/src/_common/schemas/parts/entity.part.schema.ts

@@ -0,0 +1,8 @@
+import { PartialType } from '@nestjs/swagger'
+
+export class EntitiesCreateDto {
+
+}
+
+export class EntitiesUpdateDto extends PartialType(EntitiesCreateDto) {
+}

service/src/core/entites/_dto/entites.dto.ts

@@ -0,0 +1,23 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose'
+import { AbstractSchema } from '~/_common/abstracts/schemas/abstract.schema'
+import { ProfilePart, ProfilePartSchema } from '~/core/entites/_schemas/parts/profile.part.schema'
+
+@Schema({
+  collection: 'entites',
+  versionKey: false,
+})
+export class Entity extends AbstractSchema {
+  @Prop({
+    type: String,
+    required: true,
+  })
+  public publicEmail: string
+
+  @Prop({
+    type: ProfilePartSchema,
+    required: true,
+  })
+  public profile: ProfilePart
+}
+
+export const EntitySchema = SchemaFactory.createForClass(Entity)

service/src/core/entites/_schemas/entites.schema.ts

@@ -0,0 +1,35 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose'
+import { Document } from 'mongoose'
+
+@Schema({ _id: false })
+export class ProfilePart extends Document {
+  @Prop({
+    type: String,
+    required: true,
+  })
+  public firstName: string
+
+  @Prop({
+    type: String,
+    required: true,
+  })
+  public lastName: string
+
+  @Prop({
+    type: String,
+  })
+  public thirdName?: string
+
+  @Prop({
+    type: String,
+  })
+  public avatar?: string
+}
+
+export const ProfilePartSchema = SchemaFactory.createForClass(ProfilePart)
+ProfilePartSchema.virtual('commonName').get(function (this: ProfilePart): string {
+  const commonNamePart = [this.firstName]
+  if (this.thirdName) commonNamePart.push(this.thirdName)
+  commonNamePart.push(this.lastName)
+  return commonNamePart.join(' ')
+})

service/src/core/entites/_schemas/parts/profile.part.schema.ts

@@ -1,17 +1,17 @@
 import { DeleteResult } from 'mongodb'
 import { Test, TestingModule } from '@nestjs/testing'
-import { UsersController } from './users.controller'
-import { UsersService } from './users.service'
-import { UsersDto } from './dto/users.dto'
-import { Users } from './schemas/users.schema'
+import { EntitesController } from './entites.controller'
+import { EntitesService } from './entites.service'
+import { UsersDto } from '~/core/entites/_dto/entites.dto'
+import { Users } from '~/core/entites/_schemas/entites.schema'
 import { HttpException, HttpStatus } from '@nestjs/common'
 import { Types } from 'mongoose'
 import { Response, Request } from 'express'
 import { getMockReq, getMockRes } from '@jest-mock/express'
 
 describe('UsersController', () => {
-  let controller: UsersController
-  let service: UsersService
+  let controller: EntitesController
+  let service: EntitesService
   const date = new Date()
   const _id = new Types.ObjectId()
   const { res, mockClear } = getMockRes()
@@ -29,11 +29,11 @@ describe('UsersController', () => {
   beforeEach(async () => {
     mockClear()
     const module: TestingModule = await Test.createTestingModule({
-      controllers: [UsersController],
+      controllers: [EntitesController],
       providers: [
-        UsersService,
+        EntitesService,
         {
-          provide: UsersService,
+          provide: EntitesService,
           useValue: {
             search: jest.fn().mockResolvedValue([[object], 1]),
             create: jest.fn().mockResolvedValue(object),
@@ -48,8 +48,8 @@ describe('UsersController', () => {
       ],
     }).compile()
 
-    controller = module.get<UsersController>(UsersController)
-    service = module.get<UsersService>(UsersService)
+    controller = module.get<EntitesController>(EntitesController)
+    service = module.get<EntitesService>(EntitesService)
   })
 
   describe('search', () => {

…/src/core/users/users.controller.spec.ts …/core/entites/entites.controller.spec.tsservice/src/core/users/users.controller.spec.ts renamed to service/src/core/entites/entites.controller.spec.ts service/src/core/users/users.controller.spec.ts renamed to service/src/core/entites/entites.controller.spec.ts

@@ -0,0 +1,71 @@
+import { Body, Controller, Delete, Get, HttpStatus, Param, Patch, Post, Req, Res } from '@nestjs/common'
+import { EntitesService } from './entites.service'
+import { AbstractController } from '~/_common/abstracts/abstract.controller'
+import { Request, Response } from 'express'
+import { FilterOptions, FilterSchema, SearchFilterOptions, SearchFilterSchema } from '@streamkits/nestjs_module_scrud'
+import { ApiParam } from '@nestjs/swagger'
+import { ObjectIdValidationPipe } from '~/_common/pipes/object-id-validation.pipe'
+import { Types } from 'mongoose'
+import { EntitiesCreateDto, EntitiesUpdateDto } from '~/core/entites/_dto/entites.dto'
+
+@Controller('entites')
+export class EntitesController extends AbstractController {
+  protected readonly projection = {
+    name: 1,
+    color: 1,
+    icon: 1,
+  }
+
+  public constructor(private readonly _service: EntitesService) {
+    super()
+  }
+
+  @Post()
+  public async create(@Req() req: Request, @Res() res: Response, @Body() body: EntitiesCreateDto) {
+    const data = await this._service.create(body)
+    return res.status(HttpStatus.CREATED).json({
+      statusCode: HttpStatus.CREATED,
+      data,
+    })
+  }
+
+  @Get()
+  public async search(@Res() res: Response, @SearchFilterSchema() searchFilterSchema: FilterSchema, @SearchFilterOptions() searchFilterOptions: FilterOptions) {
+    const [data, total] = await this._service.findAndCount(searchFilterSchema, this.projection, searchFilterOptions)
+    return res.status(HttpStatus.OK).json({
+      statusCode: HttpStatus.OK,
+      total,
+      data,
+    })
+  }
+
+  @Get(':_id([0-9a-fA-F]{24})')
+  @ApiParam({ name: '_id', type: String })
+  public async read(@Param('_id', ObjectIdValidationPipe) _id: Types.ObjectId, @Res() res: Response) {
+    const data = await this._service.findById(_id)
+    return res.status(HttpStatus.OK).json({
+      statusCode: HttpStatus.OK,
+      data,
+    })
+  }
+
+  @Patch(':_id([0-9a-fA-F]{24})')
+  @ApiParam({ name: '_id', type: String })
+  public async update(@Param('_id', ObjectIdValidationPipe) _id: Types.ObjectId, @Body() body: EntitiesUpdateDto, @Res() res: Response) {
+    const data = await this._service.update(_id, body)
+    return res.status(HttpStatus.OK).json({
+      statusCode: HttpStatus.OK,
+      data,
+    })
+  }
+
+  @Delete(':_id([0-9a-fA-F]{24})')
+  @ApiParam({ name: '_id', type: String })
+  public async remove(@Param('_id', ObjectIdValidationPipe) _id: Types.ObjectId, @Res() res: Response) {
+    const data = await this._service.delete(_id)
+    return res.status(HttpStatus.OK).json({
+      statusCode: HttpStatus.OK,
+      data,
+    })
+  }
+}

service/src/core/entites/entites.controller.ts

@@ -0,0 +1,19 @@
+import { Module } from '@nestjs/common'
+import { MongooseModule } from '@nestjs/mongoose'
+import { Entity, EntitySchema } from '~/core/entites/_schemas/entites.schema'
+import { EntitesService } from './entites.service'
+import { EntitesController } from './entites.controller'
+
+@Module({
+  imports: [
+    MongooseModule.forFeatureAsync([
+      {
+        name: Entity.name,
+        useFactory: () => EntitySchema,
+      },
+    ]),
+  ],
+  providers: [EntitesService],
+  controllers: [EntitesController],
+})
+export class EntitesModule {}

service/src/core/entites/entites.module.ts

@@ -1,12 +1,12 @@
 import { DeleteResult } from 'mongodb'
 import { Test, TestingModule } from '@nestjs/testing'
-import { UsersService } from './users.service'
+import { EntitesService } from './entites.service'
 import { getModelToken } from '@nestjs/mongoose'
-import { Users } from './schemas/users.schema'
+import { Users } from '~/core/entites/_schemas/entites.schema'
 import { Model, Types } from 'mongoose'
 
 describe('UsersService', () => {
-  let service: UsersService
+  let service: EntitesService
   let model: Model<Users>
   const _id = new Types.ObjectId()
   const date = new Date()
@@ -24,14 +24,14 @@ describe('UsersService', () => {
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
-        UsersService,
+        EntitesService,
         {
           provide: getModelToken(Users.name),
           useValue: Model,
         },
       ],
     }).compile()
-    service = module.get<UsersService>(UsersService)
+    service = module.get<EntitesService>(EntitesService)
     model = module.get<Model<Users>>(getModelToken(Users.name))
   })