universo-platform-3d

1
import {
2
  Body,
3
  Controller,
4
  Delete,
5
  Get,
6
  HttpException,
7
  HttpStatus,
8
  Param,
9
  Patch,
10
  Post,
11
  Query,
12
  UsePipes,
13
  ValidationPipe
14
} from '@nestjs/common'
15
import { FirebaseTokenAuthGuard } from '../auth/auth.guard'
16
import { CreateUserGroupDto } from './dto/create-group.users.dto'
17
import { UpdateUserGroupDto } from './dto/update-group.users.dto'
18
import { UserGroupService } from './user-group.service'
19
import { CreateUserGroupInviteDto } from './dto/create-group-users-invite.dto'
20
import { USER_GROUP_INVITE_STATUSES } from '../option-sets/user-group-invite-statuses'
21
import { UserGroupInviteService } from './user-group-invite.service'
22
import { CreateUserGroupRequestDto } from './dto/create-group-users-request.dto'
23
import { UserGroupAccessRequestService } from './user-group-access-request.service'
24
import { CreateUserGroupMembershipDto } from './dto/create-group-users-membership.dto'
25
import { USER_GROUP_MEMBERSHIP_STATUSES } from '../option-sets/user-group-membership-statuses'
26
import { GROUP_ROLE } from '../option-sets/group-users-roles'
27
import { UserGroupMembershipService } from './user-group-membership.service'
28
import { Roles } from '../roles/roles.decorator'
29
import { ROLE } from '../roles/models/role.enum'
30
import { ApiCreatedResponse, ApiOkResponse, ApiParam } from '@nestjs/swagger'
31
import { UserGroup } from './user-group.schema'
32
import { ApiResponseProperty } from '@nestjs/swagger/dist/decorators/api-property.decorator'
33
import { UserGroupInvite } from './user-group-invite.schema'
34
import { UserToken } from '../auth/get-user.decorator'
35

36
class UserGroupApiResponse extends UserGroup {
37
  @ApiResponseProperty()
38
  _id: string
39
}
40

41
class UserGroupInviteApiResponse extends UserGroupInvite {
42
  @ApiResponseProperty()
43
  _id: string
44
}
45

46
@UsePipes(new ValidationPipe({ whitelist: true }))
47
@Controller('user-group')
48
@FirebaseTokenAuthGuard()
49
export class UserGroupController {
50
  public static numberOfMonthsUntilInviteExpires = 1
51
  private searchMaxLimit = 500
52

53
  constructor(
54
    private readonly userGroupService: UserGroupService,
55
    private readonly userGroupInviteService: UserGroupInviteService,
56
    private readonly userGroupRequestAccessService: UserGroupAccessRequestService,
57
    private readonly userGroupMembershipService: UserGroupMembershipService
58
  ) {}
59

60
  @Post()
61
  @FirebaseTokenAuthGuard()
62
  @ApiCreatedResponse({ type: UserGroupApiResponse })
63
  public async create(
64
    @UserToken('user_id') userId: string,
65
    @Body() createUserGroupDto: CreateUserGroupDto,
66
    @Body() createUserGroupMembershipDto: CreateUserGroupMembershipDto
67
  ) {
68
    createUserGroupDto.creator = userId
69
    const createdGroup = await this.userGroupService.create(createUserGroupDto)
70

71
    const groupMembershipBase = this.createBaseNewUserMembership(
72
      createUserGroupMembershipDto,
73
      userId,
74
      createdGroup._id,
75
      GROUP_ROLE.GROUP_OWNER
76
    )
77
    await this.userGroupMembershipService.create(groupMembershipBase)
78

79
    return createdGroup
80
  }
81

82
  /**
83
   * @description Find all groups for current user
84
   */
85
  @Get('/my-groups')
86
  @ApiOkResponse({ type: [UserGroupApiResponse] })
87
  public async getAllGroupsForMe(@UserToken('user_id') userId: string) {
88
    return await this.userGroupService.findAllForUser(userId)
89
  }
90

91
  /**
92
   * @description Find all invites for the current user
93
   */
94
  @Get('/my-invites')
95
  @FirebaseTokenAuthGuard()
96
  @ApiOkResponse({ type: [UserGroupInviteApiResponse] })
97
  public async getAllGroupInvitesForMe(@UserToken('user_id') userId: string) {
98
    return await this.userGroupInviteService.findAllForUser(userId)
99
  }
100

101
  /**
102
   * @description This is used for another user, NOT the current user,
103
   * so we only get the PUBLIC groups that the person is a part of
104
   * TODO - add ApiOkResponse type for UserGroupMembership
105
   */
106
  @Get('/group-membership/:otherUserId')
107
  @ApiParam({ name: 'otherUserId', type: 'string', required: true })
108
  @FirebaseTokenAuthGuard()
109
  public async findPublicGroupMembershipForOtherUser(
110
    @Param('otherUserId') otherUserId: string
111
  ) {
112
    return await this.userGroupMembershipService.findPublicGroupMembershipForUser(
113
      otherUserId
114
    )
115
  }
116

117
  /**
118
   * @description Find all group members of current user
119
   * TODO - add ApiOkResponse type for UserGroupMembership
120
   */
121
  @Get('/my-group-membership/:id')
122
  @FirebaseTokenAuthGuard()
123
  @ApiParam({ name: 'id', type: 'string', required: true })
124
  public async getGroupMembershipForMe(
125
    @UserToken('user_id') userId: string,
126
    @Param('id') id: string
127
  ) {
128
    return await this.userGroupMembershipService.findAllMembers(id, userId)
129
  }
130

131
  @Get('search')
132
  @ApiOkResponse({ type: [UserGroupApiResponse] })
133
  public async search(@Query() query) {
134
    const { filterField, filterValue, sortField, sortValue, limit, skip } =
135
      query
136

137
    return await this.userGroupService.search({
138
      filterField: filterField || 'name',
139
      filterValue: filterValue || '',
140
      sortField: sortField || 'name',
141
      sortValue: sortValue || 1,
142
      limit: limit && limit < this.searchMaxLimit ? limit : 25,
143
      skip: skip || 0
144
    })
145
  }
146

147
  @Get(':id')
148
  @ApiParam({ name: 'id', type: 'string', required: true })
149
  @ApiOkResponse({ type: UserGroupApiResponse })
150
  public async findOne(@Param('id') id: string) {
151
    const groupFound = await this.userGroupService.findOne(id)
152
    return groupFound[0]
153
  }
154

155
  @Patch(':id')
156
  @ApiParam({ name: 'id', type: 'string', required: true })
157
  @ApiOkResponse({ type: UserGroupApiResponse })
158
  public async update(
159
    @Param('id') id: string,
160
    @Body() updateUserGroupDto: UpdateUserGroupDto
161
  ) {
162
    return await this.userGroupService.update(id, updateUserGroupDto)
163
  }
164

165
  @Delete(':id')
166
  @ApiParam({ name: 'id', type: 'string', required: true })
167
  @ApiOkResponse({ type: UserGroupApiResponse })
168
  @FirebaseTokenAuthGuard()
169
  public async remove(
170
    @UserToken('user_id') userId: string,
171
    @Param('id') id: string
172
  ) {
173
    const groupMembership =
174
      await this.userGroupMembershipService.findAllMembers(id, userId)
175
    //only owner can delete group
176
    // TODO this needs to be updated with RBAC
177
    if (groupMembership.role == 0) {
178
      return this.userGroupService.remove(id)
179
    } else {
180
      throw new HttpException('Forbidden', HttpStatus.FORBIDDEN)
181
    }
182
  }
183

184
  private makeInviteExpirationDate(): Date {
185
    const now = new Date()
186
    now.setMonth(
187
      now.getMonth() + UserGroupController.numberOfMonthsUntilInviteExpires
188
    )
189
    return now
190
  }
191

192
  private createBaseNewUserMembership(
193
    createGroupMembershipDto: CreateUserGroupMembershipDto,
194
    userId: string,
195
    groupId: string,
196
    role: GROUP_ROLE
197
  ) {
198
    createGroupMembershipDto.user = userId
199
    createGroupMembershipDto.status = USER_GROUP_MEMBERSHIP_STATUSES.ACTIVE
200
    createGroupMembershipDto.role = role
201
    createGroupMembershipDto.group = groupId
202
    return createGroupMembershipDto
203
  }
204
}
205