feat: housing advocate user updates

api/src/controllers/user.controller.ts

@@ -32,14 +32,11 @@ import { mapTo } from '../utilities/mapTo';
 import { PaginatedUserDto } from '../dtos/users/paginated-user.dto';
 import { UserQueryParams } from '../dtos/users/user-query-param.dto';
 import { Request as ExpressRequest, Response } from 'express';
-import { UserUpdate } from '../dtos/users/user-update.dto';
 import { SuccessDTO } from '../dtos/shared/success.dto';
-import { UserCreate } from '../dtos/users/user-create.dto';
 import { UserCreateParams } from '../dtos/users/user-create-params.dto';
 import { UserFavoriteListing } from '../dtos/users/user-favorite-listing.dto';
 import { EmailAndAppUrl } from '../dtos/users/email-and-app-url.dto';
 import { ConfirmationRequest } from '../dtos/users/confirmation-request.dto';
-import { UserInvite } from '../dtos/users/user-invite.dto';
 import { JwtAuthGuard } from '../guards/jwt.guard';
 import { UserProfilePermissionGuard } from '../guards/user-profile-permission-guard';
 import { OptionalAuthGuard } from '../guards/optional.guard';
@@ -53,12 +50,27 @@ import { ExportLogInterceptor } from '../interceptors/export-log.interceptor';
 import { RequestSingleUseCode } from '../dtos/single-use-code/request-single-use-code.dto';
 import { ApiKeyGuard } from '../guards/api-key.guard';
 import { UserDeleteDTO } from '../dtos/users/user-delete.dto';
+import { PublicUserCreate } from '../dtos/users/public-user-create.dto';
+import { PartnerUserCreate } from '../dtos/users/partner-user-create.dto';
+import { AdvocateUserCreate } from '../dtos/users/advocate-user-create.dto';
+import { PublicUserUpdate } from '../dtos/users/public-user-update.dto';
+import { PartnerUserUpdate } from '../dtos/users/partner-user-update.dto';
+import { AdvocateUserUpdate } from '../dtos/users/advocate-user-update.dto';
 
 @Controller('user')
 @ApiTags('user')
 @PermissionTypeDecorator('user')
 @UsePipes(new ValidationPipe(defaultValidationPipeOptions))
-@ApiExtraModels(IdDTO, EmailAndAppUrl)
+@ApiExtraModels(
+  IdDTO,
+  EmailAndAppUrl,
+  PublicUserCreate,
+  PartnerUserCreate,
+  AdvocateUserCreate,
+  PublicUserUpdate,
+  PartnerUserUpdate,
+  AdvocateUserUpdate,
+)
 @UseGuards(ApiKeyGuard)
 export class UserController {
   constructor(
@@ -125,21 +137,55 @@ export class UserController {
     return await this.userService.favoriteListings(userId);
   }
 
-  @Post()
+  @Post('/public')
   @ApiOperation({
     summary: 'Creates a public only user',
-    operationId: 'create',
+    operationId: 'createPublic',
+  })
+  @UseGuards(OptionalAuthGuard, PermissionGuard)
+  @UsePipes(new ValidationPipe(defaultValidationPipeOptions))
+  @ApiOkResponse({ type: User })
+  async createPublicUser(
+    @Request() req: ExpressRequest,
+    @Body() dto: PublicUserCreate,
+    @Query() queryParams: UserCreateParams,
+  ): Promise<User> {
+    return await this.userService.createPublicUser(
+      dto,
+      queryParams.noWelcomeEmail !== true,
+      req,
+    );
+  }
+
+  @Post('/partner')
+  @ApiOperation({
+    summary: 'Creates a partner only user',
+    operationId: 'createPartner',
+  })
+  @ApiOkResponse({ type: User })
+  @UseGuards(PermissionGuard, JwtAuthGuard)
+  @UseInterceptors(ActivityLogInterceptor)
+  async createPartnerUser(
+    @Request() req: ExpressRequest,
+    @Body() dto: PartnerUserCreate,
+  ): Promise<User> {
+    return await this.userService.createPartnerUser(dto, req);
+  }
+
+  @Post('/advocate')
+  @ApiOperation({
+    summary: 'Creates a advocate only user',
+    operationId: 'createAdvocate',
   })
   @ApiOkResponse({ type: User })
   @UseGuards(OptionalAuthGuard, PermissionGuard)
-  async create(
+  async createAdvocateUser(
     @Request() req: ExpressRequest,
-    @Body() dto: UserCreate,
+    @Body() dto: AdvocateUserCreate,
     @Query() queryParams: UserCreateParams,
   ): Promise<User> {
-    return await this.userService.create(
+    return await this.userService.createAdvocateUser(
       dto,
-      false,
       queryParams.noWelcomeEmail !== true,
       req,
     );
@@ -161,18 +207,6 @@ export class UserController {
     );
   }
 
-  @Post('/invite')
-  @ApiOperation({ summary: 'Invite partner user', operationId: 'invite' })
-  @ApiOkResponse({ type: User })
-  @UseGuards(OptionalAuthGuard)
-  @UseInterceptors(ActivityLogInterceptor)
-  async invite(
-    @Body() dto: UserInvite,
-    @Request() req: ExpressRequest,
-  ): Promise<User> {
-    return await this.userService.create(dto, true, undefined, req);
-  }
-
   @Post('request-single-use-code')
   @ApiOperation({
     summary: 'Request single use code',
@@ -268,21 +302,40 @@ export class UserController {
     return await this.userService.deleteAfterInactivity();
   }
 
-  @Put(':id')
-  @ApiOperation({ summary: 'Update user', operationId: 'update' })
+  @Put('/public')
+  @ApiOperation({ summary: 'Update user', operationId: 'updatePublic' })
   @ApiOkResponse({ type: User })
   @UseGuards(JwtAuthGuard, PermissionGuard)
   @UseInterceptors(ActivityLogInterceptor)
-  async update(
+  async updatePublicUser(
     @Request() req: ExpressRequest,
-    @Body() dto: UserUpdate,
+    @Body() dto: PublicUserUpdate,
   ): Promise<User> {
-    const jurisdictionName = req.headers['jurisdictionname'] || '';
-    return await this.userService.update(
-      dto,
-      mapTo(User, req['user']),
-      jurisdictionName as string,
-    );
+    return await this.userService.update(dto, req);
+  }
+
+  @Put('/partner')
+  @ApiOperation({ summary: 'Update user', operationId: 'updatePartner' })
+  @ApiOkResponse({ type: User })
+  @UseGuards(JwtAuthGuard, PermissionGuard)
+  @UseInterceptors(ActivityLogInterceptor)
+  async updatePartnerUser(
+    @Request() req: ExpressRequest,
+    @Body() dto: PartnerUserUpdate,
+  ): Promise<User> {
+    return await this.userService.update(dto, req);
+  }
+
+  @Put('/advocate')
+  @ApiOperation({ summary: 'Update user', operationId: 'updateAdvocate' })
+  @ApiOkResponse({ type: User })
+  @UseGuards(JwtAuthGuard, PermissionGuard)
+  @UseInterceptors(ActivityLogInterceptor)
+  async updateAdvocateUser(
+    @Request() req: ExpressRequest,
+    @Body() dto: AdvocateUserUpdate,
+  ): Promise<User> {
+    return await this.userService.update(dto, req);
   }
 
   @Get(`:id`)

api/src/dtos/users/advocate-user-create.dto.ts

@@ -0,0 +1,23 @@
+import { OmitType } from '@nestjs/swagger';
+import { AdvocateUserUpdate } from './advocate-user-update.dto';
+export class AdvocateUserCreate extends OmitType(AdvocateUserUpdate, [
+  'id',
+  'newEmail',
+  'currentPassword',
+  'password',
+  'title',
+  'phoneNumber',
+  'phoneType',
+  'phoneExtension',
+  'additionalPhoneNumber',
+  'additionalPhoneNumberType',
+  'additionalPhoneExtension',
+] as const) {
+  /* Fields inherited from AdvocateUserUpdate:
+   * - firstName (inherited as required from AdvocateUserUpdate)
+   * - middleName (inherited as optional from AdvocateUserUpdate)
+   * - lastName (inherited as required from AdvocateUserUpdate)
+   * - agency (inherited as required from AdvocateUserUpdate)
+   * - email (inherited as required from AdvocateUserUpdate)
+   **/
+}

api/src/dtos/users/advocate-user-update.dto.ts

@@ -0,0 +1,99 @@
+import { ApiProperty, ApiPropertyOptional, OmitType } from '@nestjs/swagger';
+import { Expose, Type } from 'class-transformer';
+import {
+  IsArray,
+  IsEmail,
+  IsNotEmpty,
+  IsPhoneNumber,
+  IsString,
+  Matches,
+  MaxLength,
+  ValidateIf,
+  ValidateNested,
+} from 'class-validator';
+import { ValidationsGroupsEnum } from '../../enums/shared/validation-groups-enum';
+import Agency from '../agency/agency.dto';
+import { User } from './user.dto';
+import { EnforceLowerCase } from '../../decorators/enforce-lower-case.decorator';
+import { passwordRegex } from '../../utilities/password-regex';
+import { AddressUpdate } from '../addresses/address-update.dto';
+import { IdDTO } from '../shared/id.dto';
+
+export class AdvocateUserUpdate extends OmitType(User, [
+  'createdAt',
+  'updatedAt',
+  'agency',
+  'address',
+  'phoneNumber',
+  'passwordUpdatedAt',
+  'passwordValidForDays',
+  'passwordUpdatedAt',
+  'jurisdictions',
+] as const) {
+  /* Fields inherited from BaseUser:
+   * - firstName (inherited as required from BaseUser)
+   * - middleName (inherited as optional from BaseUser)
+   * - lastName (inherited as required from BaseUser)
+   * - email (inherited as required from BaseUser)
+   * - title (inherited as optional from BaseUserUpdate)
+   * - phoneExtension (inherited as optional from BaseUserUpdate)
+   * - additionalPhoneNumber (inherited as optional from BaseUserUpdate)
+   * - additionalPhoneNumberType (inherited as optional from BaseUserUpdate)
+   * - additionalPhoneExtension (inherited as optional from BaseUserUpdate)
+   **/
+
+  @Expose()
+  @ValidateNested({ groups: [ValidationsGroupsEnum.default] })
+  @Type(() => Agency)
+  @ApiProperty({ type: Agency })
+  agency: Agency;
+
+  @Expose()
+  @ValidateNested({ groups: [ValidationsGroupsEnum.default] })
+  @Type(() => AddressUpdate)
+  @ApiProperty({ type: AddressUpdate })
+  address: AddressUpdate;
+
+  @Expose()
+  @IsPhoneNumber('US', { groups: [ValidationsGroupsEnum.default] })
+  @ApiProperty()
+  phoneNumber: string;
+
+  @Expose()
+  @IsString({ groups: [ValidationsGroupsEnum.default] })
+  @ApiProperty()
+  phoneType: string;
+
+  @Expose()
+  @ApiPropertyOptional()
+  @IsEmail({}, { groups: [ValidationsGroupsEnum.default] })
+  @EnforceLowerCase()
+  newEmail?: string;
+
+  @Expose()
+  @ApiPropertyOptional()
+  @IsString({ groups: [ValidationsGroupsEnum.default] })
+  @Matches(passwordRegex, {
+    message: 'passwordTooWeak',
+    groups: [ValidationsGroupsEnum.default],
+  })
+  password?: string;
+
+  @Expose()
+  @ValidateIf((o) => o.password, { groups: [ValidationsGroupsEnum.default] })
+  @IsNotEmpty({ groups: [ValidationsGroupsEnum.default] })
+  @ApiPropertyOptional()
+  currentPassword?: string;
+
+  @Expose()
+  @IsString({ groups: [ValidationsGroupsEnum.default] })
+  @MaxLength(256, { groups: [ValidationsGroupsEnum.default] })
+  @ApiPropertyOptional()
+  appUrl?: string;
+
+  @Expose()
+  @Type(() => IdDTO)
+  @IsArray({ groups: [ValidationsGroupsEnum.default] })
+  @ApiPropertyOptional({ type: IdDTO, isArray: true })
+  jurisdictions?: IdDTO[];
+}

api/src/dtos/users/user-invite.dto.ts → api/src/dtos/users/partner-user-create.dto.ts

@@ -1,31 +1,23 @@
 import { ApiProperty, OmitType } from '@nestjs/swagger';
+import { PartnerUserUpdate } from './partner-user-update.dto';
 import { Expose, Type } from 'class-transformer';
-import {
-  ArrayMinSize,
-  IsArray,
-  IsEmail,
-  ValidateNested,
-} from 'class-validator';
-import { UserUpdate } from './user-update.dto';
-
-import { EnforceLowerCase } from '../../decorators/enforce-lower-case.decorator';
 import { ValidationsGroupsEnum } from '../../enums/shared/validation-groups-enum';
 import { IdDTO } from '../shared/id.dto';
+import { ArrayMinSize, IsArray, ValidateNested } from 'class-validator';
 
-export class UserInvite extends OmitType(UserUpdate, [
+export class PartnerUserCreate extends OmitType(PartnerUserUpdate, [
   'id',
+  'newEmail',
   'password',
   'currentPassword',
-  'email',
-  'agreedToTermsOfService',
   'jurisdictions',
-]) {
-  @Expose()
-  @ApiProperty()
-  @IsEmail({}, { groups: [ValidationsGroupsEnum.default] })
-  @EnforceLowerCase()
-  email: string;
-
+] as const) {
+  /* Fields inherited from PartnerUserUpdate:
+   * - firstName (inherited as required from PartnerUserUpdate)
+   * - lastName (inherited as required from PartnerUserUpdate)
+   * - email (inherited as required from PartnerUserUpdate)
+   * - userRoles (inherited as required from PartnerUserUpdate)
+   **/
   @Expose()
   @Type(() => IdDTO)
   @IsArray({ groups: [ValidationsGroupsEnum.default] })