跳轉到

models/teamdb.py

models.teamdb

TeamDB

TeamDB

Bases: DBBase

Team Collection

Parameters:

Name Type Description Default
pid str

Project id.

 required
tid str

Team id.

 required

Attributes:

Name Type Description
pid str

Project id.
tid str

Team id.
Note

For some use cases, the pid, tid could be empty strings.

Source code in models/teamdb.py 
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
class TeamDB(DBBase):
    ''' Team Collection

    Args:
        pid (str): Project id.
        tid (str): Team id.

    Attributes:
        pid (str): Project id.
        tid (str): Team id.

    Note:
        For some use cases, the `pid`, `tid` could be empty strings.

    '''

    def __init__(self, pid: str | None, tid: str | None) -> None:
        super().__init__('team')
        self.pid = pid
        self.tid = tid

    def index(self) -> None:
        ''' To make collection's index

        Indexs:
            - `chiefs`
            - `members`
            - `pid`

        '''
        self.create_index([('chiefs', 1), ])
        self.create_index([('members', 1), ])
        self.create_index([('pid', 1), ])

    def default(self) -> dict[str, Any]:
        ''' default data

        Returns:
            Return a default struct.

        Struct:
            - ``pid``: Project id.
            - ``tid``: Team id.
            - ``name``: Team name.
            - ``owners``: `list` List of `uid` as team admin.
            - ``chiefs``: `list` List of `uid` as team chiefs.
            - ``members``: `list` List of `uid` as team members.
            - ``desc``: Description.
            - ``tag_members``: List of data
                               `{'id': '<random code>', 'name': '<tag name>'}`.
                               The tags for team to mark on members.

        TODO:
            Need refactor in pydantic.

        '''
        result: dict[str, str | list[str] | None] = {
            'pid': self.pid,
            'tid': self.tid,
            'name': '',
            'owners': [],
            'chiefs': [],
            'members': [],
            'desc': '',
            'tag_members': [],
        }
        self.make_create_at(result)
        return result

    def add(self, data: TeamBase) -> TeamBase:
        ''' Add data

        Args:
            data (TeamBase): The data to inserted / updated.

        Returns:
            Return the inserted / updated data.

        '''
        return TeamBase.parse_obj(self.find_one_and_update(
            {'pid': self.pid, 'tid': self.tid},
            {'$set': data.dict(exclude_none=True)},
            upsert=True,
            return_document=ReturnDocument.AFTER,
        ))

    def update_setting(self, data: dict[str, Any]) -> dict[str, Any]:
        ''' update setting

        Args:
            data (dict): The data to inserted / updated.

        Returns:
            Return the inserted / updated data.

        '''
        return self.find_one_and_update(
            {'pid': self.pid, 'tid': self.tid},
            {'$set': data},
            return_document=ReturnDocument.AFTER,
        )

    def update_users(self, field: str,
                     add_uids: Optional[list[str]] = None,
                     del_uids: Optional[list[str]] = None) -> None:
        ''' Update users

        Args:
            field (str): The `field` should be `chiefs`, `members`, `owners`.
            add_uids (list): Optional, list of uids for add them into the `field`.
            del_uids (list): Optional, list of uids for delete them from the `field`.

        '''
        if add_uids:
            self.find_one_and_update(
                {'pid': self.pid, 'tid': self.tid},
                {'$addToSet': {field: {'$each': add_uids}}})

        if del_uids:
            self.find_one_and_update(
                {'pid': self.pid, 'tid': self.tid},
                {'$pullAll': {field: del_uids}})

    def get(self) -> TeamBase | None:
        ''' Get data

        Returns:
            Return the team info in `pid`, `tid`.

        '''
        for team in self.find({'pid': self.pid, 'tid': self.tid}):
            return TeamBase.parse_obj(team)

        return None

    def add_tag_member(self, tag_data: dict[str, str]) -> None:
        ''' Add tag member

        Args:
            tag_data (dict): The tag data should be:

                `{'id': '<random code>', 'name': '<tag name>'}`.

        '''
        for data in self.find({'pid': self.pid, 'tid': self.tid}, {'tag_members': 1}):
            if 'tag_members' not in data:
                data['tag_members'] = []

            tags = {}
            for tag in data['tag_members']:
                tags[tag['id']] = tag

            tags[tag_data['id']] = tag_data

            self.find_one_and_update(
                {'pid': self.pid, 'tid': self.tid},
                {'$set': {'tag_members': list(tags.values())}},
            )

add 

add(data: TeamBase) -> TeamBase

Add data

Parameters:

Name Type Description Default
data TeamBase

The data to inserted / updated.

 required

Returns:

Type Description
TeamBase

Return the inserted / updated data.
Source code in models/teamdb.py 
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
def add(self, data: TeamBase) -> TeamBase:
    ''' Add data

    Args:
        data (TeamBase): The data to inserted / updated.

    Returns:
        Return the inserted / updated data.

    '''
    return TeamBase.parse_obj(self.find_one_and_update(
        {'pid': self.pid, 'tid': self.tid},
        {'$set': data.dict(exclude_none=True)},
        upsert=True,
        return_document=ReturnDocument.AFTER,
    ))

add_tag_member 

add_tag_member(tag_data: dict[str, str]) -> None

Add tag member

Parameters:

Name Type Description Default
tag_data dict

The tag data should be:

{'id': '<random code>', 'name': '<tag name>'}.

 required
Source code in models/teamdb.py 
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
def add_tag_member(self, tag_data: dict[str, str]) -> None:
    ''' Add tag member

    Args:
        tag_data (dict): The tag data should be:

            `{'id': '<random code>', 'name': '<tag name>'}`.

    '''
    for data in self.find({'pid': self.pid, 'tid': self.tid}, {'tag_members': 1}):
        if 'tag_members' not in data:
            data['tag_members'] = []

        tags = {}
        for tag in data['tag_members']:
            tags[tag['id']] = tag

        tags[tag_data['id']] = tag_data

        self.find_one_and_update(
            {'pid': self.pid, 'tid': self.tid},
            {'$set': {'tag_members': list(tags.values())}},
        )

default 

default() -> dict[str, Any]

default data

Returns:

Type Description
dict[str, Any]

Return a default struct.
Struct
  • pid: Project id.
  • tid: Team id.
  • name: Team name.
  • owners: list List of uid as team admin.
  • chiefs: list List of uid as team chiefs.
  • members: list List of uid as team members.
  • desc: Description.
  • tag_members: List of data {'id': '<random code>', 'name': '<tag name>'}. The tags for team to mark on members.
TODO

Need refactor in pydantic.

Source code in models/teamdb.py 
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
def default(self) -> dict[str, Any]:
    ''' default data

    Returns:
        Return a default struct.

    Struct:
        - ``pid``: Project id.
        - ``tid``: Team id.
        - ``name``: Team name.
        - ``owners``: `list` List of `uid` as team admin.
        - ``chiefs``: `list` List of `uid` as team chiefs.
        - ``members``: `list` List of `uid` as team members.
        - ``desc``: Description.
        - ``tag_members``: List of data
                           `{'id': '<random code>', 'name': '<tag name>'}`.
                           The tags for team to mark on members.

    TODO:
        Need refactor in pydantic.

    '''
    result: dict[str, str | list[str] | None] = {
        'pid': self.pid,
        'tid': self.tid,
        'name': '',
        'owners': [],
        'chiefs': [],
        'members': [],
        'desc': '',
        'tag_members': [],
    }
    self.make_create_at(result)
    return result

get 

get() -> TeamBase | None

Get data

Returns:

Type Description
TeamBase | None

Return the team info in pid, tid.
Source code in models/teamdb.py 
134
135
136
137
138
139
140
141
142
143
144
def get(self) -> TeamBase | None:
    ''' Get data

    Returns:
        Return the team info in `pid`, `tid`.

    '''
    for team in self.find({'pid': self.pid, 'tid': self.tid}):
        return TeamBase.parse_obj(team)

    return None

index 

index() -> None

To make collection's index

Indexs
  • chiefs
  • members
  • pid
Source code in models/teamdb.py 
32
33
34
35
36
37
38
39
40
41
42
43
def index(self) -> None:
    ''' To make collection's index

    Indexs:
        - `chiefs`
        - `members`
        - `pid`

    '''
    self.create_index([('chiefs', 1), ])
    self.create_index([('members', 1), ])
    self.create_index([('pid', 1), ])

update_setting 

update_setting(data: dict[str, Any]) -> dict[str, Any]

update setting

Parameters:

Name Type Description Default
data dict

The data to inserted / updated.

 required

Returns:

Type Description
dict[str, Any]

Return the inserted / updated data.
Source code in models/teamdb.py 
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
def update_setting(self, data: dict[str, Any]) -> dict[str, Any]:
    ''' update setting

    Args:
        data (dict): The data to inserted / updated.

    Returns:
        Return the inserted / updated data.

    '''
    return self.find_one_and_update(
        {'pid': self.pid, 'tid': self.tid},
        {'$set': data},
        return_document=ReturnDocument.AFTER,
    )

update_users 

update_users(
    field: str,
    add_uids: Optional[list[str]] = None,
    del_uids: Optional[list[str]] = None,
) -> None

Update users

Parameters:

Name Type Description Default
field str

The field should be chiefs, members, owners.

 required
add_uids list

Optional, list of uids for add them into the field.

 None
del_uids list

Optional, list of uids for delete them from the field.

 None
Source code in models/teamdb.py 
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
def update_users(self, field: str,
                 add_uids: Optional[list[str]] = None,
                 del_uids: Optional[list[str]] = None) -> None:
    ''' Update users

    Args:
        field (str): The `field` should be `chiefs`, `members`, `owners`.
        add_uids (list): Optional, list of uids for add them into the `field`.
        del_uids (list): Optional, list of uids for delete them from the `field`.

    '''
    if add_uids:
        self.find_one_and_update(
            {'pid': self.pid, 'tid': self.tid},
            {'$addToSet': {field: {'$each': add_uids}}})

    if del_uids:
        self.find_one_and_update(
            {'pid': self.pid, 'tid': self.tid},
            {'$pullAll': {field: del_uids}})

TeamMemberChangedDB

Bases: DBBase

TeamMemberChangedDB Collection

Struct
  • pid: from project id
  • tid: team id
  • uid: user id
  • case: add, del, waiting
TODO

Need refactor in pydantic.

Source code in models/teamdb.py 
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
class TeamMemberChangedDB(DBBase):
    ''' TeamMemberChangedDB Collection

    Struct:
        - ``pid``: from project id
        - ``tid``: team id
        - ``uid``: user id
        - ``case``: ``add``, ``del``, ``waiting``

    TODO:
        Need refactor in pydantic.

    '''

    def __init__(self) -> None:
        super().__init__('team_member_changed')

    def index(self) -> None:
        ''' To make collection's index

        Indexs:
            - `pid`
            - `case`

        '''
        self.create_index([('pid', 1), ])
        self.create_index([('case', 1), ])

    def make_record(self, pid: str, tid: str, action: dict[str, Optional[list[str]]]) -> None:
        ''' make record

        Args:
            pid (str): Project id.
            tid (str): Team id.
            action (dict):

                - `add`: Optional, list of uids. Add or approve to join.
                - `del`: Optional, list of uids. Was joined, but remove now.
                - `waiting`: Optional, list of uids. User has sent the request,
                             and waiting the chiefs to review.
                - `deny`: Optional, list of uids. User has sent the request,
                          but has to deny.

        '''
        if 'add' in action and action['add']:
            query = [{'pid': pid, 'tid': tid, 'case': 'add', 'uid': uid,
                      'create_at': time()} for uid in action['add'] if uid]
            if query:
                self.insert_many(query)

        if 'del' in action and action['del']:
            query = [{'pid': pid, 'tid': tid, 'case': 'del', 'uid': uid,
                      'create_at': time()} for uid in action['del'] if uid]
            if query:
                self.insert_many(query)

        if 'waiting' in action and action['waiting']:
            query = [{'pid': pid, 'tid': tid, 'case': 'waiting', 'uid': uid,
                      'create_at': time()} for uid in action['waiting'] if uid]
            if query:
                self.insert_many(query)

        if 'deny' in action and action['deny']:
            query = [{'pid': pid, 'tid': tid, 'case': 'deny', 'uid': uid,
                      'create_at': time()} for uid in action['deny'] if uid]
            if query:
                self.insert_many(query)

index 

index() -> None

To make collection's index

Indexs
  • pid
  • case
Source code in models/teamdb.py 
237
238
239
240
241
242
243
244
245
246
def index(self) -> None:
    ''' To make collection's index

    Indexs:
        - `pid`
        - `case`

    '''
    self.create_index([('pid', 1), ])
    self.create_index([('case', 1), ])

make_record 

make_record(
    pid: str,
    tid: str,
    action: dict[str, Optional[list[str]]],
) -> None

make record

Parameters:

Name Type Description Default
pid str

Project id.

 required
tid str

Team id.

 required
action dict
  • add: Optional, list of uids. Add or approve to join.
  • del: Optional, list of uids. Was joined, but remove now.
  • waiting: Optional, list of uids. User has sent the request, and waiting the chiefs to review.
  • deny: Optional, list of uids. User has sent the request, but has to deny.
 required
Source code in models/teamdb.py 
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
def make_record(self, pid: str, tid: str, action: dict[str, Optional[list[str]]]) -> None:
    ''' make record

    Args:
        pid (str): Project id.
        tid (str): Team id.
        action (dict):

            - `add`: Optional, list of uids. Add or approve to join.
            - `del`: Optional, list of uids. Was joined, but remove now.
            - `waiting`: Optional, list of uids. User has sent the request,
                         and waiting the chiefs to review.
            - `deny`: Optional, list of uids. User has sent the request,
                      but has to deny.

    '''
    if 'add' in action and action['add']:
        query = [{'pid': pid, 'tid': tid, 'case': 'add', 'uid': uid,
                  'create_at': time()} for uid in action['add'] if uid]
        if query:
            self.insert_many(query)

    if 'del' in action and action['del']:
        query = [{'pid': pid, 'tid': tid, 'case': 'del', 'uid': uid,
                  'create_at': time()} for uid in action['del'] if uid]
        if query:
            self.insert_many(query)

    if 'waiting' in action and action['waiting']:
        query = [{'pid': pid, 'tid': tid, 'case': 'waiting', 'uid': uid,
                  'create_at': time()} for uid in action['waiting'] if uid]
        if query:
            self.insert_many(query)

    if 'deny' in action and action['deny']:
        query = [{'pid': pid, 'tid': tid, 'case': 'deny', 'uid': uid,
                  'create_at': time()} for uid in action['deny'] if uid]
        if query:
            self.insert_many(query)

TeamMemberTagsDB

Bases: DBBase

TeamMemberTagsDB Collection

Save the member's tag info.

Struct
  • pid: Project id.
  • tid: Team id.
  • uid: User id.
  • tags: List of tag id.
TODO

Need refactor in pydantic.

Source code in models/teamdb.py 
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
class TeamMemberTagsDB(DBBase):
    ''' TeamMemberTagsDB Collection

    Save the member's tag info.

    Struct:
        - ``pid``: Project id.
        - ``tid``: Team id.
        - ``uid``: User id.
        - ``tags``: List of tag id.

    TODO:
        Need refactor in pydantic.

    '''

    def __init__(self) -> None:
        super().__init__('team_member_tags')

    def index(self) -> None:
        ''' To make collection's index

        Indexs:
            - `pid`, `tid`

        '''
        self.create_index([('pid', 1), ('tid', 1)])

    def update_and_add(self, pid: str, tid: str, uid: str, tags: list[str]) -> dict[str, Any]:
        ''' update team

        Args:
            pid (str): Project id.
            tid (str): Team id.
            uid (str): User id.
            tags (list): List of tag id.

        Returns:
            Return the inserted / updated data.

        '''
        return self.find_one_and_update(
            {'pid': pid, 'tid': tid, 'uid': uid},
            {'$set': {'tags': tags}},
            upsert=True,
            return_document=ReturnDocument.AFTER,
        )

index 

index() -> None

To make collection's index

Indexs
  • pid, tid
Source code in models/teamdb.py 
190
191
192
193
194
195
196
197
def index(self) -> None:
    ''' To make collection's index

    Indexs:
        - `pid`, `tid`

    '''
    self.create_index([('pid', 1), ('tid', 1)])

update_and_add 

update_and_add(
    pid: str, tid: str, uid: str, tags: list[str]
) -> dict[str, Any]

update team

Parameters:

Name Type Description Default
pid str

Project id.

 required
tid str

Team id.

 required
uid str

User id.

 required
tags list

List of tag id.

 required

Returns:

Type Description
dict[str, Any]

Return the inserted / updated data.
Source code in models/teamdb.py 
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
def update_and_add(self, pid: str, tid: str, uid: str, tags: list[str]) -> dict[str, Any]:
    ''' update team

    Args:
        pid (str): Project id.
        tid (str): Team id.
        uid (str): User id.
        tags (list): List of tag id.

    Returns:
        Return the inserted / updated data.

    '''
    return self.find_one_and_update(
        {'pid': pid, 'tid': tid, 'uid': uid},
        {'$set': {'tags': tags}},
        upsert=True,
        return_document=ReturnDocument.AFTER,
    )

TeamPlanDB

Bases: DBBase

TeamPlan Collection

Source code in models/teamdb.py 
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
class TeamPlanDB(DBBase):
    ''' TeamPlan Collection '''

    def __init__(self) -> None:
        super().__init__('team_plan')

    def index(self) -> None:
        ''' To make collection's index

        Indexs:
            - `pid`

        '''
        self.create_index([('pid', 1), ])

    def add(self, pid: str, tid: str, data: list[dict[str, Any]]) -> dict[str, Any]:
        ''' Save data

        Args:
            pid (str): Project id.
            tid (str): Team id.
            data (dict): List of data to inserted / updated.

                - `title`: Plan title.
                - `start`: Date in `YYYY-MM-DD` format.
                - `end`: Date in `YYYY-MM-DD` format.
                - `desc`: Description.

        Returns:
            Return the inserted / updated data.

        '''
        return self.find_one_and_update(
            {'pid': pid, 'tid': tid},
            {'$set': {'data': data}},
            upsert=True,
            return_document=ReturnDocument.AFTER,
        )

add 

add(
    pid: str, tid: str, data: list[dict[str, Any]]
) -> dict[str, Any]

Save data

Parameters:

Name Type Description Default
pid str

Project id.

 required
tid str

Team id.

 required
data dict

List of data to inserted / updated.

  • title: Plan title.
  • start: Date in YYYY-MM-DD format.
  • end: Date in YYYY-MM-DD format.
  • desc: Description.
 required

Returns:

Type Description
dict[str, Any]

Return the inserted / updated data.
Source code in models/teamdb.py 
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
def add(self, pid: str, tid: str, data: list[dict[str, Any]]) -> dict[str, Any]:
    ''' Save data

    Args:
        pid (str): Project id.
        tid (str): Team id.
        data (dict): List of data to inserted / updated.

            - `title`: Plan title.
            - `start`: Date in `YYYY-MM-DD` format.
            - `end`: Date in `YYYY-MM-DD` format.
            - `desc`: Description.

    Returns:
        Return the inserted / updated data.

    '''
    return self.find_one_and_update(
        {'pid': pid, 'tid': tid},
        {'$set': {'data': data}},
        upsert=True,
        return_document=ReturnDocument.AFTER,
    )

index 

index() -> None

To make collection's index

Indexs
  • pid
Source code in models/teamdb.py 
295
296
297
298
299
300
301
302
def index(self) -> None:
    ''' To make collection's index

    Indexs:
        - `pid`

    '''
    self.create_index([('pid', 1), ])