universo-platform-3d

1
import { Injectable } from '@nestjs/common'
2
import { InjectModel } from '@nestjs/mongoose'
3
import { Model } from 'mongoose'
4
import mongoose from 'mongoose'
5
import { GROUP_ROLE } from '../option-sets/group-users-roles'
6
import {
7
  UserGroupMembershipDocument,
8
  UserGroupMembership
9
} from './user-group-membership.schema'
10
import { CreateUserGroupMembershipDto } from './dto/create-group-users-membership.dto'
11

12
@Injectable()
13
export class UserGroupMembershipService {
14
  constructor(
15
    @InjectModel(UserGroupMembership.name)
16
    private userGroupMembershipModel: Model<UserGroupMembershipDocument>
17
  ) {}
18

19
  public create(
20
    createUserGroupMembershipDto: CreateUserGroupMembershipDto
21
  ): Promise<any> {
22
    const created = new this.userGroupMembershipModel(
23
      createUserGroupMembershipDto
24
    )
25
    return created.save()
26
  }
27

28
  public findOne(id: string): Promise<any> {
29
    return this.userGroupMembershipModel.findById(id).exec()
30
  }
31

32
  public remove(id: string): Promise<any> {
33
    return this.userGroupMembershipModel.findOneAndDelete({ _id: id }).exec()
34
  }
35

36
  public findPublicGroupMembershipForUser(
37
    userId: string
38
  ): Promise<UserGroupMembershipDocument[]> {
39
    return (
40
      this.userGroupMembershipModel
41
        .find()
42
        .where({ user: userId, membershipIsPubliclyVisible: true })
43
        // TODO add a test such that only name is exposed
44
        // TODO add a filter
45
        .populate({
46
          path: 'group',
47
          select: ['name', 'publicDescription', 'public']
48
          // TODO fix this. For some reason, the below code isn't working. Groups with public: false are still being returned. The returned doc is for some reason set to "public": "false" as string false, not boolean false. That could be part of the issue.
49
          // match: {
50
          //   public: {
51
          //     $eq: true
52
          //   }
53
          // }
54
        })
55
        .exec()
56
    )
57
  }
58

59
  public findAllForUserViaUserMembership(userId: string): Promise<any> {
60
    return this.userGroupMembershipModel
61
      .find({ user: userId })
62
      .populate('group')
63
      .exec()
64
  }
65

66
  public findAllForUserWithGroup(userId: string): Promise<any> {
67
    return this.userGroupMembershipModel.find().where({ user: userId }).exec()
68
  }
69

70
  public async getAllAdminLinks(groupId: string, user: string): Promise<any> {
71
    return await this.userGroupMembershipModel.find({
72
      group_id: groupId,
73
      role: { $in: [GROUP_ROLE.GROUP_OWNER, GROUP_ROLE.GROUP_ADMIN] }
74
    })
75
  }
76

77
  public async getAllPublicMembersForPublicGroup(
78
    groupId: string
79
  ): Promise<UserGroupMembershipDocument[]> {
80
    return await this.userGroupMembershipModel
81
      .find({ group: groupId, membershipIsPubliclyVisible: true }) // TODO add a test to ensure private group membership isn't exposed
82
      .populate('user', {
83
        role: 1,
84
        _id: 1,
85
        displayName: 1
86
      })
87
      .exec()
88
  }
89

90
  public async findLeaderShip(groupId: string): Promise<any> {
91
    return await this.userGroupMembershipModel
92
      .aggregate()
93
      .append({
94
        $match: {
95
          group: new mongoose.Types.ObjectId(groupId),
96
          role: {
97
            $in: [GROUP_ROLE.GROUP_OWNER, GROUP_ROLE.GROUP_ADMIN]
98
          }
99
        }
100
      })
101
      .lookup({
102
        from: 'users',
103
        localField: 'user',
104
        foreignField: '_id',
105
        as: 'user'
106
      })
107
      .unwind({ path: '$user' })
108
      .exec()
109
  }
110
  public async findOwners(groupId: string): Promise<any> {
111
    return await this.userGroupMembershipModel
112
      .aggregate()
113
      .append({
114
        $match: {
115
          group: new mongoose.Types.ObjectId(groupId),
116
          role: { $in: GROUP_ROLE.GROUP_ADMIN }
117
        }
118
      })
119
      .lookup({
120
        from: 'users',
121
        localField: 'user',
122
        foreignField: '_id',
123
        as: 'user'
124
      })
125
      .unwind({ path: '$user' })
126
      .exec()
127
  }
128

129
  public async findAllMembers(groupId: string, userId: string): Promise<any> {
130
    return await this.userGroupMembershipModel.findOne({
131
      group: groupId,
132
      user: userId
133
    })
134
  }
135
  public async promoteAdmin(groupId: string, userId: string): Promise<any> {
136
    const userLinkFound = await this.userGroupMembershipModel.findOne({
137
      group: groupId,
138
      user: userId
139
    })
140
    return await this.userGroupMembershipModel
141
      .findByIdAndUpdate(
142
        userLinkFound._id,
143
        { role: GROUP_ROLE.GROUP_ADMIN },
144
        { new: true }
145
      )
146
      .exec()
147
  }
148
  public async promoteOwner(groupId: string, userId: string): Promise<any> {
149
    const userLinkFound = await this.userGroupMembershipModel.findOne({
150
      group: groupId,
151
      user: userId
152
    })
153
    return await this.userGroupMembershipModel
154
      .findByIdAndUpdate(
155
        userLinkFound._id,
156
        { role: GROUP_ROLE.GROUP_OWNER },
157
        { new: true }
158
      )
159
      .exec()
160
  }
161
  public async demoteOwner(groupId: string, userId: string): Promise<any> {
162
    const userLinkFound = await this.userGroupMembershipModel.findOne({
163
      group: groupId,
164
      user: userId
165
    })
166
    return await this.userGroupMembershipModel
167
      .findByIdAndUpdate(
168
        userLinkFound._id,
169
        { role: GROUP_ROLE.GROUP_ADMIN },
170
        { new: true }
171
      )
172
      .exec()
173
  }
174
  public async demoteAdmin(groupId: string, userId: string): Promise<any> {
175
    const userLinkFound = await this.userGroupMembershipModel.findOne({
176
      group: groupId,
177
      user: userId
178
    })
179
    return await this.userGroupMembershipModel
180
      .findByIdAndUpdate(
181
        userLinkFound._id,
182
        { role: GROUP_ROLE.MEMBER },
183
        { new: true }
184
      )
185
      .exec()
186
  }
187
}
188