Show More
@@ -1,6046 +1,6046 b'' | |||||
1 | # Copyright (C) 2010-2023 RhodeCode GmbH |
|
1 | # Copyright (C) 2010-2023 RhodeCode GmbH | |
2 | # |
|
2 | # | |
3 | # This program is free software: you can redistribute it and/or modify |
|
3 | # This program is free software: you can redistribute it and/or modify | |
4 | # it under the terms of the GNU Affero General Public License, version 3 |
|
4 | # it under the terms of the GNU Affero General Public License, version 3 | |
5 | # (only), as published by the Free Software Foundation. |
|
5 | # (only), as published by the Free Software Foundation. | |
6 | # |
|
6 | # | |
7 | # This program is distributed in the hope that it will be useful, |
|
7 | # This program is distributed in the hope that it will be useful, | |
8 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
8 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
9 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
9 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
10 | # GNU General Public License for more details. |
|
10 | # GNU General Public License for more details. | |
11 | # |
|
11 | # | |
12 | # You should have received a copy of the GNU Affero General Public License |
|
12 | # You should have received a copy of the GNU Affero General Public License | |
13 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
13 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
14 | # |
|
14 | # | |
15 | # This program is dual-licensed. If you wish to learn more about the |
|
15 | # This program is dual-licensed. If you wish to learn more about the | |
16 | # RhodeCode Enterprise Edition, including its added features, Support services, |
|
16 | # RhodeCode Enterprise Edition, including its added features, Support services, | |
17 | # and proprietary license terms, please see https://rhodecode.com/licenses/ |
|
17 | # and proprietary license terms, please see https://rhodecode.com/licenses/ | |
18 |
|
18 | |||
19 | """ |
|
19 | """ | |
20 | Database Models for RhodeCode Enterprise |
|
20 | Database Models for RhodeCode Enterprise | |
21 | """ |
|
21 | """ | |
22 |
|
22 | |||
23 | import re |
|
23 | import re | |
24 | import os |
|
24 | import os | |
25 | import time |
|
25 | import time | |
26 | import string |
|
26 | import string | |
27 | import logging |
|
27 | import logging | |
28 | import datetime |
|
28 | import datetime | |
29 | import uuid |
|
29 | import uuid | |
30 | import warnings |
|
30 | import warnings | |
31 | import ipaddress |
|
31 | import ipaddress | |
32 | import functools |
|
32 | import functools | |
33 | import traceback |
|
33 | import traceback | |
34 | import collections |
|
34 | import collections | |
35 |
|
35 | |||
36 | import pyotp |
|
36 | import pyotp | |
37 | from sqlalchemy import ( |
|
37 | from sqlalchemy import ( | |
38 | or_, and_, not_, func, cast, TypeDecorator, event, select, |
|
38 | or_, and_, not_, func, cast, TypeDecorator, event, select, | |
39 | true, false, null, union_all, |
|
39 | true, false, null, union_all, | |
40 | Index, Sequence, UniqueConstraint, ForeignKey, CheckConstraint, Column, |
|
40 | Index, Sequence, UniqueConstraint, ForeignKey, CheckConstraint, Column, | |
41 | Boolean, String, Unicode, UnicodeText, DateTime, Integer, LargeBinary, |
|
41 | Boolean, String, Unicode, UnicodeText, DateTime, Integer, LargeBinary, | |
42 | Text, Float, PickleType, BigInteger) |
|
42 | Text, Float, PickleType, BigInteger) | |
43 | from sqlalchemy.sql.expression import case |
|
43 | from sqlalchemy.sql.expression import case | |
44 | from sqlalchemy.sql.functions import coalesce, count # pragma: no cover |
|
44 | from sqlalchemy.sql.functions import coalesce, count # pragma: no cover | |
45 | from sqlalchemy.orm import ( |
|
45 | from sqlalchemy.orm import ( | |
46 | relationship, lazyload, joinedload, class_mapper, validates, aliased, load_only) |
|
46 | relationship, lazyload, joinedload, class_mapper, validates, aliased, load_only) | |
47 | from sqlalchemy.ext.declarative import declared_attr |
|
47 | from sqlalchemy.ext.declarative import declared_attr | |
48 | from sqlalchemy.ext.hybrid import hybrid_property |
|
48 | from sqlalchemy.ext.hybrid import hybrid_property | |
49 | from sqlalchemy.exc import IntegrityError # pragma: no cover |
|
49 | from sqlalchemy.exc import IntegrityError # pragma: no cover | |
50 | from sqlalchemy.dialects.mysql import LONGTEXT |
|
50 | from sqlalchemy.dialects.mysql import LONGTEXT | |
51 | from zope.cachedescriptors.property import Lazy as LazyProperty |
|
51 | from zope.cachedescriptors.property import Lazy as LazyProperty | |
52 | from pyramid.threadlocal import get_current_request |
|
52 | from pyramid.threadlocal import get_current_request | |
53 | from webhelpers2.text import remove_formatting |
|
53 | from webhelpers2.text import remove_formatting | |
54 |
|
54 | |||
55 | from rhodecode import ConfigGet |
|
55 | from rhodecode import ConfigGet | |
56 | from rhodecode.lib.str_utils import safe_bytes |
|
56 | from rhodecode.lib.str_utils import safe_bytes | |
57 | from rhodecode.translation import _ |
|
57 | from rhodecode.translation import _ | |
58 | from rhodecode.lib.vcs import get_vcs_instance, VCSError |
|
58 | from rhodecode.lib.vcs import get_vcs_instance, VCSError | |
59 | from rhodecode.lib.vcs.backends.base import ( |
|
59 | from rhodecode.lib.vcs.backends.base import ( | |
60 | EmptyCommit, Reference, unicode_to_reference, reference_to_unicode) |
|
60 | EmptyCommit, Reference, unicode_to_reference, reference_to_unicode) | |
61 | from rhodecode.lib.utils2 import ( |
|
61 | from rhodecode.lib.utils2 import ( | |
62 | str2bool, safe_str, get_commit_safe, sha1_safe, |
|
62 | str2bool, safe_str, get_commit_safe, sha1_safe, | |
63 | time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict, |
|
63 | time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict, | |
64 | glob2re, StrictAttributeDict, cleaned_uri, datetime_to_time) |
|
64 | glob2re, StrictAttributeDict, cleaned_uri, datetime_to_time) | |
65 | from rhodecode.lib.jsonalchemy import ( |
|
65 | from rhodecode.lib.jsonalchemy import ( | |
66 | MutationObj, MutationList, JsonType, JsonRaw) |
|
66 | MutationObj, MutationList, JsonType, JsonRaw) | |
67 | from rhodecode.lib.hash_utils import sha1 |
|
67 | from rhodecode.lib.hash_utils import sha1 | |
68 | from rhodecode.lib import ext_json |
|
68 | from rhodecode.lib import ext_json | |
69 | from rhodecode.lib import enc_utils |
|
69 | from rhodecode.lib import enc_utils | |
70 | from rhodecode.lib.ext_json import json, str_json |
|
70 | from rhodecode.lib.ext_json import json, str_json | |
71 | from rhodecode.lib.caching_query import FromCache |
|
71 | from rhodecode.lib.caching_query import FromCache | |
72 | from rhodecode.lib.exceptions import ( |
|
72 | from rhodecode.lib.exceptions import ( | |
73 | ArtifactMetadataDuplicate, ArtifactMetadataBadValueType) |
|
73 | ArtifactMetadataDuplicate, ArtifactMetadataBadValueType) | |
74 | from rhodecode.model.meta import Base, Session |
|
74 | from rhodecode.model.meta import Base, Session | |
75 |
|
75 | |||
76 | URL_SEP = '/' |
|
76 | URL_SEP = '/' | |
77 | log = logging.getLogger(__name__) |
|
77 | log = logging.getLogger(__name__) | |
78 |
|
78 | |||
79 | # ============================================================================= |
|
79 | # ============================================================================= | |
80 | # BASE CLASSES |
|
80 | # BASE CLASSES | |
81 | # ============================================================================= |
|
81 | # ============================================================================= | |
82 |
|
82 | |||
83 | # this is propagated from .ini file rhodecode.encrypted_values.secret or |
|
83 | # this is propagated from .ini file rhodecode.encrypted_values.secret or | |
84 | # beaker.session.secret if first is not set. |
|
84 | # beaker.session.secret if first is not set. | |
85 | # and initialized at environment.py |
|
85 | # and initialized at environment.py | |
86 | ENCRYPTION_KEY: bytes = b'' |
|
86 | ENCRYPTION_KEY: bytes = b'' | |
87 |
|
87 | |||
88 | # used to sort permissions by types, '#' used here is not allowed to be in |
|
88 | # used to sort permissions by types, '#' used here is not allowed to be in | |
89 | # usernames, and it's very early in sorted string.printable table. |
|
89 | # usernames, and it's very early in sorted string.printable table. | |
90 | PERMISSION_TYPE_SORT = { |
|
90 | PERMISSION_TYPE_SORT = { | |
91 | 'admin': '####', |
|
91 | 'admin': '####', | |
92 | 'write': '###', |
|
92 | 'write': '###', | |
93 | 'read': '##', |
|
93 | 'read': '##', | |
94 | 'none': '#', |
|
94 | 'none': '#', | |
95 | } |
|
95 | } | |
96 |
|
96 | |||
97 |
|
97 | |||
98 | def display_user_sort(obj): |
|
98 | def display_user_sort(obj): | |
99 | """ |
|
99 | """ | |
100 | Sort function used to sort permissions in .permissions() function of |
|
100 | Sort function used to sort permissions in .permissions() function of | |
101 | Repository, RepoGroup, UserGroup. Also it put the default user in front |
|
101 | Repository, RepoGroup, UserGroup. Also it put the default user in front | |
102 | of all other resources |
|
102 | of all other resources | |
103 | """ |
|
103 | """ | |
104 |
|
104 | |||
105 | if obj.username == User.DEFAULT_USER: |
|
105 | if obj.username == User.DEFAULT_USER: | |
106 | return '#####' |
|
106 | return '#####' | |
107 | prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '') |
|
107 | prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '') | |
108 | extra_sort_num = '1' # default |
|
108 | extra_sort_num = '1' # default | |
109 |
|
109 | |||
110 | # NOTE(dan): inactive duplicates goes last |
|
110 | # NOTE(dan): inactive duplicates goes last | |
111 | if getattr(obj, 'duplicate_perm', None): |
|
111 | if getattr(obj, 'duplicate_perm', None): | |
112 | extra_sort_num = '9' |
|
112 | extra_sort_num = '9' | |
113 | return prefix + extra_sort_num + obj.username |
|
113 | return prefix + extra_sort_num + obj.username | |
114 |
|
114 | |||
115 |
|
115 | |||
116 | def display_user_group_sort(obj): |
|
116 | def display_user_group_sort(obj): | |
117 | """ |
|
117 | """ | |
118 | Sort function used to sort permissions in .permissions() function of |
|
118 | Sort function used to sort permissions in .permissions() function of | |
119 | Repository, RepoGroup, UserGroup. Also it put the default user in front |
|
119 | Repository, RepoGroup, UserGroup. Also it put the default user in front | |
120 | of all other resources |
|
120 | of all other resources | |
121 | """ |
|
121 | """ | |
122 |
|
122 | |||
123 | prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '') |
|
123 | prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '') | |
124 | return prefix + obj.users_group_name |
|
124 | return prefix + obj.users_group_name | |
125 |
|
125 | |||
126 |
|
126 | |||
127 | def _hash_key(k): |
|
127 | def _hash_key(k): | |
128 | return sha1_safe(k) |
|
128 | return sha1_safe(k) | |
129 |
|
129 | |||
130 |
|
130 | |||
131 | def description_escaper(desc): |
|
131 | def description_escaper(desc): | |
132 | from rhodecode.lib import helpers as h |
|
132 | from rhodecode.lib import helpers as h | |
133 |
return h. |
|
133 | return h.escape(desc) | |
134 |
|
134 | |||
135 |
|
135 | |||
136 | def in_filter_generator(qry, items, limit=500): |
|
136 | def in_filter_generator(qry, items, limit=500): | |
137 | """ |
|
137 | """ | |
138 | Splits IN() into multiple with OR |
|
138 | Splits IN() into multiple with OR | |
139 | e.g.:: |
|
139 | e.g.:: | |
140 | cnt = Repository.query().filter( |
|
140 | cnt = Repository.query().filter( | |
141 | or_( |
|
141 | or_( | |
142 | *in_filter_generator(Repository.repo_id, range(100000)) |
|
142 | *in_filter_generator(Repository.repo_id, range(100000)) | |
143 | )).count() |
|
143 | )).count() | |
144 | """ |
|
144 | """ | |
145 | if not items: |
|
145 | if not items: | |
146 | # empty list will cause empty query which might cause security issues |
|
146 | # empty list will cause empty query which might cause security issues | |
147 | # this can lead to hidden unpleasant results |
|
147 | # this can lead to hidden unpleasant results | |
148 | items = [-1] |
|
148 | items = [-1] | |
149 |
|
149 | |||
150 | parts = [] |
|
150 | parts = [] | |
151 | for chunk in range(0, len(items), limit): |
|
151 | for chunk in range(0, len(items), limit): | |
152 | parts.append( |
|
152 | parts.append( | |
153 | qry.in_(items[chunk: chunk + limit]) |
|
153 | qry.in_(items[chunk: chunk + limit]) | |
154 | ) |
|
154 | ) | |
155 |
|
155 | |||
156 | return parts |
|
156 | return parts | |
157 |
|
157 | |||
158 |
|
158 | |||
159 | base_table_args = { |
|
159 | base_table_args = { | |
160 | 'extend_existing': True, |
|
160 | 'extend_existing': True, | |
161 | 'mysql_engine': 'InnoDB', |
|
161 | 'mysql_engine': 'InnoDB', | |
162 | 'mysql_charset': 'utf8', |
|
162 | 'mysql_charset': 'utf8', | |
163 | 'sqlite_autoincrement': True |
|
163 | 'sqlite_autoincrement': True | |
164 | } |
|
164 | } | |
165 |
|
165 | |||
166 |
|
166 | |||
167 | class EncryptedTextValue(TypeDecorator): |
|
167 | class EncryptedTextValue(TypeDecorator): | |
168 | """ |
|
168 | """ | |
169 | Special column for encrypted long text data, use like:: |
|
169 | Special column for encrypted long text data, use like:: | |
170 |
|
170 | |||
171 | value = Column("encrypted_value", EncryptedValue(), nullable=False) |
|
171 | value = Column("encrypted_value", EncryptedValue(), nullable=False) | |
172 |
|
172 | |||
173 | This column is intelligent so if value is in unencrypted form it return |
|
173 | This column is intelligent so if value is in unencrypted form it return | |
174 | unencrypted form, but on save it always encrypts |
|
174 | unencrypted form, but on save it always encrypts | |
175 | """ |
|
175 | """ | |
176 | cache_ok = True |
|
176 | cache_ok = True | |
177 | impl = Text |
|
177 | impl = Text | |
178 |
|
178 | |||
179 | def process_bind_param(self, value, dialect): |
|
179 | def process_bind_param(self, value, dialect): | |
180 | """ |
|
180 | """ | |
181 | Setter for storing value |
|
181 | Setter for storing value | |
182 | """ |
|
182 | """ | |
183 | import rhodecode |
|
183 | import rhodecode | |
184 | if not value: |
|
184 | if not value: | |
185 | return value |
|
185 | return value | |
186 |
|
186 | |||
187 | # protect against double encrypting if values is already encrypted |
|
187 | # protect against double encrypting if values is already encrypted | |
188 | if value.startswith('enc$aes$') \ |
|
188 | if value.startswith('enc$aes$') \ | |
189 | or value.startswith('enc$aes_hmac$') \ |
|
189 | or value.startswith('enc$aes_hmac$') \ | |
190 | or value.startswith('enc2$'): |
|
190 | or value.startswith('enc2$'): | |
191 | raise ValueError('value needs to be in unencrypted format, ' |
|
191 | raise ValueError('value needs to be in unencrypted format, ' | |
192 | 'ie. not starting with enc$ or enc2$') |
|
192 | 'ie. not starting with enc$ or enc2$') | |
193 |
|
193 | |||
194 | algo = rhodecode.CONFIG.get('rhodecode.encrypted_values.algorithm') or 'aes' |
|
194 | algo = rhodecode.CONFIG.get('rhodecode.encrypted_values.algorithm') or 'aes' | |
195 | bytes_val = enc_utils.encrypt_value(value, enc_key=ENCRYPTION_KEY, algo=algo) |
|
195 | bytes_val = enc_utils.encrypt_value(value, enc_key=ENCRYPTION_KEY, algo=algo) | |
196 | return safe_str(bytes_val) |
|
196 | return safe_str(bytes_val) | |
197 |
|
197 | |||
198 | def process_result_value(self, value, dialect): |
|
198 | def process_result_value(self, value, dialect): | |
199 | """ |
|
199 | """ | |
200 | Getter for retrieving value |
|
200 | Getter for retrieving value | |
201 | """ |
|
201 | """ | |
202 |
|
202 | |||
203 | import rhodecode |
|
203 | import rhodecode | |
204 | if not value: |
|
204 | if not value: | |
205 | return value |
|
205 | return value | |
206 |
|
206 | |||
207 | bytes_val = enc_utils.decrypt_value(value, enc_key=ENCRYPTION_KEY) |
|
207 | bytes_val = enc_utils.decrypt_value(value, enc_key=ENCRYPTION_KEY) | |
208 |
|
208 | |||
209 | return safe_str(bytes_val) |
|
209 | return safe_str(bytes_val) | |
210 |
|
210 | |||
211 |
|
211 | |||
212 | class BaseModel(object): |
|
212 | class BaseModel(object): | |
213 | """ |
|
213 | """ | |
214 | Base Model for all classes |
|
214 | Base Model for all classes | |
215 | """ |
|
215 | """ | |
216 |
|
216 | |||
217 | @classmethod |
|
217 | @classmethod | |
218 | def _get_keys(cls): |
|
218 | def _get_keys(cls): | |
219 | """return column names for this model """ |
|
219 | """return column names for this model """ | |
220 | return class_mapper(cls).c.keys() |
|
220 | return class_mapper(cls).c.keys() | |
221 |
|
221 | |||
222 | def get_dict(self): |
|
222 | def get_dict(self): | |
223 | """ |
|
223 | """ | |
224 | return dict with keys and values corresponding |
|
224 | return dict with keys and values corresponding | |
225 | to this model data """ |
|
225 | to this model data """ | |
226 |
|
226 | |||
227 | d = {} |
|
227 | d = {} | |
228 | for k in self._get_keys(): |
|
228 | for k in self._get_keys(): | |
229 | d[k] = getattr(self, k) |
|
229 | d[k] = getattr(self, k) | |
230 |
|
230 | |||
231 | # also use __json__() if present to get additional fields |
|
231 | # also use __json__() if present to get additional fields | |
232 | _json_attr = getattr(self, '__json__', None) |
|
232 | _json_attr = getattr(self, '__json__', None) | |
233 | if _json_attr: |
|
233 | if _json_attr: | |
234 | # update with attributes from __json__ |
|
234 | # update with attributes from __json__ | |
235 | if callable(_json_attr): |
|
235 | if callable(_json_attr): | |
236 | _json_attr = _json_attr() |
|
236 | _json_attr = _json_attr() | |
237 | for k, val in _json_attr.items(): |
|
237 | for k, val in _json_attr.items(): | |
238 | d[k] = val |
|
238 | d[k] = val | |
239 | return d |
|
239 | return d | |
240 |
|
240 | |||
241 | def get_appstruct(self): |
|
241 | def get_appstruct(self): | |
242 | """return list with keys and values tuples corresponding |
|
242 | """return list with keys and values tuples corresponding | |
243 | to this model data """ |
|
243 | to this model data """ | |
244 |
|
244 | |||
245 | lst = [] |
|
245 | lst = [] | |
246 | for k in self._get_keys(): |
|
246 | for k in self._get_keys(): | |
247 | lst.append((k, getattr(self, k),)) |
|
247 | lst.append((k, getattr(self, k),)) | |
248 | return lst |
|
248 | return lst | |
249 |
|
249 | |||
250 | def populate_obj(self, populate_dict): |
|
250 | def populate_obj(self, populate_dict): | |
251 | """populate model with data from given populate_dict""" |
|
251 | """populate model with data from given populate_dict""" | |
252 |
|
252 | |||
253 | for k in self._get_keys(): |
|
253 | for k in self._get_keys(): | |
254 | if k in populate_dict: |
|
254 | if k in populate_dict: | |
255 | setattr(self, k, populate_dict[k]) |
|
255 | setattr(self, k, populate_dict[k]) | |
256 |
|
256 | |||
257 | @classmethod |
|
257 | @classmethod | |
258 | def query(cls): |
|
258 | def query(cls): | |
259 | return Session().query(cls) |
|
259 | return Session().query(cls) | |
260 |
|
260 | |||
261 | @classmethod |
|
261 | @classmethod | |
262 | def select(cls, custom_cls=None): |
|
262 | def select(cls, custom_cls=None): | |
263 | """ |
|
263 | """ | |
264 | stmt = cls.select().where(cls.user_id==1) |
|
264 | stmt = cls.select().where(cls.user_id==1) | |
265 | # optionally |
|
265 | # optionally | |
266 | stmt = cls.select(User.user_id).where(cls.user_id==1) |
|
266 | stmt = cls.select(User.user_id).where(cls.user_id==1) | |
267 | result = cls.execute(stmt) | cls.scalars(stmt) |
|
267 | result = cls.execute(stmt) | cls.scalars(stmt) | |
268 | """ |
|
268 | """ | |
269 |
|
269 | |||
270 | if custom_cls: |
|
270 | if custom_cls: | |
271 | stmt = select(custom_cls) |
|
271 | stmt = select(custom_cls) | |
272 | else: |
|
272 | else: | |
273 | stmt = select(cls) |
|
273 | stmt = select(cls) | |
274 | return stmt |
|
274 | return stmt | |
275 |
|
275 | |||
276 | @classmethod |
|
276 | @classmethod | |
277 | def execute(cls, stmt): |
|
277 | def execute(cls, stmt): | |
278 | return Session().execute(stmt) |
|
278 | return Session().execute(stmt) | |
279 |
|
279 | |||
280 | @classmethod |
|
280 | @classmethod | |
281 | def scalars(cls, stmt): |
|
281 | def scalars(cls, stmt): | |
282 | return Session().scalars(stmt) |
|
282 | return Session().scalars(stmt) | |
283 |
|
283 | |||
284 | @classmethod |
|
284 | @classmethod | |
285 | def get(cls, id_): |
|
285 | def get(cls, id_): | |
286 | if id_: |
|
286 | if id_: | |
287 | return cls.query().get(id_) |
|
287 | return cls.query().get(id_) | |
288 |
|
288 | |||
289 | @classmethod |
|
289 | @classmethod | |
290 | def get_or_404(cls, id_): |
|
290 | def get_or_404(cls, id_): | |
291 | from pyramid.httpexceptions import HTTPNotFound |
|
291 | from pyramid.httpexceptions import HTTPNotFound | |
292 |
|
292 | |||
293 | try: |
|
293 | try: | |
294 | id_ = int(id_) |
|
294 | id_ = int(id_) | |
295 | except (TypeError, ValueError): |
|
295 | except (TypeError, ValueError): | |
296 | raise HTTPNotFound() |
|
296 | raise HTTPNotFound() | |
297 |
|
297 | |||
298 | res = cls.query().get(id_) |
|
298 | res = cls.query().get(id_) | |
299 | if not res: |
|
299 | if not res: | |
300 | raise HTTPNotFound() |
|
300 | raise HTTPNotFound() | |
301 | return res |
|
301 | return res | |
302 |
|
302 | |||
303 | @classmethod |
|
303 | @classmethod | |
304 | def getAll(cls): |
|
304 | def getAll(cls): | |
305 | # deprecated and left for backward compatibility |
|
305 | # deprecated and left for backward compatibility | |
306 | return cls.get_all() |
|
306 | return cls.get_all() | |
307 |
|
307 | |||
308 | @classmethod |
|
308 | @classmethod | |
309 | def get_all(cls): |
|
309 | def get_all(cls): | |
310 | return cls.query().all() |
|
310 | return cls.query().all() | |
311 |
|
311 | |||
312 | @classmethod |
|
312 | @classmethod | |
313 | def delete(cls, id_): |
|
313 | def delete(cls, id_): | |
314 | obj = cls.query().get(id_) |
|
314 | obj = cls.query().get(id_) | |
315 | Session().delete(obj) |
|
315 | Session().delete(obj) | |
316 |
|
316 | |||
317 | @classmethod |
|
317 | @classmethod | |
318 | def identity_cache(cls, session, attr_name, value): |
|
318 | def identity_cache(cls, session, attr_name, value): | |
319 | exist_in_session = [] |
|
319 | exist_in_session = [] | |
320 | for (item_cls, pkey), instance in session.identity_map.items(): |
|
320 | for (item_cls, pkey), instance in session.identity_map.items(): | |
321 | if cls == item_cls and getattr(instance, attr_name) == value: |
|
321 | if cls == item_cls and getattr(instance, attr_name) == value: | |
322 | exist_in_session.append(instance) |
|
322 | exist_in_session.append(instance) | |
323 | if exist_in_session: |
|
323 | if exist_in_session: | |
324 | if len(exist_in_session) == 1: |
|
324 | if len(exist_in_session) == 1: | |
325 | return exist_in_session[0] |
|
325 | return exist_in_session[0] | |
326 | log.exception( |
|
326 | log.exception( | |
327 | 'multiple objects with attr %s and ' |
|
327 | 'multiple objects with attr %s and ' | |
328 | 'value %s found with same name: %r', |
|
328 | 'value %s found with same name: %r', | |
329 | attr_name, value, exist_in_session) |
|
329 | attr_name, value, exist_in_session) | |
330 |
|
330 | |||
331 | @property |
|
331 | @property | |
332 | def cls_name(self): |
|
332 | def cls_name(self): | |
333 | return self.__class__.__name__ |
|
333 | return self.__class__.__name__ | |
334 |
|
334 | |||
335 | def __repr__(self): |
|
335 | def __repr__(self): | |
336 | return f'<DB:{self.cls_name}>' |
|
336 | return f'<DB:{self.cls_name}>' | |
337 |
|
337 | |||
338 |
|
338 | |||
339 | class RhodeCodeSetting(Base, BaseModel): |
|
339 | class RhodeCodeSetting(Base, BaseModel): | |
340 | __tablename__ = 'rhodecode_settings' |
|
340 | __tablename__ = 'rhodecode_settings' | |
341 | __table_args__ = ( |
|
341 | __table_args__ = ( | |
342 | UniqueConstraint('app_settings_name'), |
|
342 | UniqueConstraint('app_settings_name'), | |
343 | base_table_args |
|
343 | base_table_args | |
344 | ) |
|
344 | ) | |
345 |
|
345 | |||
346 | SETTINGS_TYPES = { |
|
346 | SETTINGS_TYPES = { | |
347 | 'str': safe_str, |
|
347 | 'str': safe_str, | |
348 | 'int': safe_int, |
|
348 | 'int': safe_int, | |
349 | 'unicode': safe_str, |
|
349 | 'unicode': safe_str, | |
350 | 'bool': str2bool, |
|
350 | 'bool': str2bool, | |
351 | 'list': functools.partial(aslist, sep=',') |
|
351 | 'list': functools.partial(aslist, sep=',') | |
352 | } |
|
352 | } | |
353 | DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions' |
|
353 | DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions' | |
354 | GLOBAL_CONF_KEY = 'app_settings' |
|
354 | GLOBAL_CONF_KEY = 'app_settings' | |
355 |
|
355 | |||
356 | app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
356 | app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
357 | app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None) |
|
357 | app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None) | |
358 | _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None) |
|
358 | _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None) | |
359 | _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None) |
|
359 | _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None) | |
360 |
|
360 | |||
361 | def __init__(self, key='', val='', type='unicode'): |
|
361 | def __init__(self, key='', val='', type='unicode'): | |
362 | self.app_settings_name = key |
|
362 | self.app_settings_name = key | |
363 | self.app_settings_type = type |
|
363 | self.app_settings_type = type | |
364 | self.app_settings_value = val |
|
364 | self.app_settings_value = val | |
365 |
|
365 | |||
366 | @validates('_app_settings_value') |
|
366 | @validates('_app_settings_value') | |
367 | def validate_settings_value(self, key, val): |
|
367 | def validate_settings_value(self, key, val): | |
368 | assert type(val) == str |
|
368 | assert type(val) == str | |
369 | return val |
|
369 | return val | |
370 |
|
370 | |||
371 | @hybrid_property |
|
371 | @hybrid_property | |
372 | def app_settings_value(self): |
|
372 | def app_settings_value(self): | |
373 | v = self._app_settings_value |
|
373 | v = self._app_settings_value | |
374 | _type = self.app_settings_type |
|
374 | _type = self.app_settings_type | |
375 | if _type: |
|
375 | if _type: | |
376 | _type = self.app_settings_type.split('.')[0] |
|
376 | _type = self.app_settings_type.split('.')[0] | |
377 | # decode the encrypted value |
|
377 | # decode the encrypted value | |
378 | if 'encrypted' in self.app_settings_type: |
|
378 | if 'encrypted' in self.app_settings_type: | |
379 | cipher = EncryptedTextValue() |
|
379 | cipher = EncryptedTextValue() | |
380 | v = safe_str(cipher.process_result_value(v, None)) |
|
380 | v = safe_str(cipher.process_result_value(v, None)) | |
381 |
|
381 | |||
382 | converter = self.SETTINGS_TYPES.get(_type) or \ |
|
382 | converter = self.SETTINGS_TYPES.get(_type) or \ | |
383 | self.SETTINGS_TYPES['unicode'] |
|
383 | self.SETTINGS_TYPES['unicode'] | |
384 | return converter(v) |
|
384 | return converter(v) | |
385 |
|
385 | |||
386 | @app_settings_value.setter |
|
386 | @app_settings_value.setter | |
387 | def app_settings_value(self, val): |
|
387 | def app_settings_value(self, val): | |
388 | """ |
|
388 | """ | |
389 | Setter that will always make sure we use unicode in app_settings_value |
|
389 | Setter that will always make sure we use unicode in app_settings_value | |
390 |
|
390 | |||
391 | :param val: |
|
391 | :param val: | |
392 | """ |
|
392 | """ | |
393 | val = safe_str(val) |
|
393 | val = safe_str(val) | |
394 | # encode the encrypted value |
|
394 | # encode the encrypted value | |
395 | if 'encrypted' in self.app_settings_type: |
|
395 | if 'encrypted' in self.app_settings_type: | |
396 | cipher = EncryptedTextValue() |
|
396 | cipher = EncryptedTextValue() | |
397 | val = safe_str(cipher.process_bind_param(val, None)) |
|
397 | val = safe_str(cipher.process_bind_param(val, None)) | |
398 | self._app_settings_value = val |
|
398 | self._app_settings_value = val | |
399 |
|
399 | |||
400 | @hybrid_property |
|
400 | @hybrid_property | |
401 | def app_settings_type(self): |
|
401 | def app_settings_type(self): | |
402 | return self._app_settings_type |
|
402 | return self._app_settings_type | |
403 |
|
403 | |||
404 | @app_settings_type.setter |
|
404 | @app_settings_type.setter | |
405 | def app_settings_type(self, val): |
|
405 | def app_settings_type(self, val): | |
406 | if val.split('.')[0] not in self.SETTINGS_TYPES: |
|
406 | if val.split('.')[0] not in self.SETTINGS_TYPES: | |
407 | raise Exception('type must be one of %s got %s' |
|
407 | raise Exception('type must be one of %s got %s' | |
408 | % (self.SETTINGS_TYPES.keys(), val)) |
|
408 | % (self.SETTINGS_TYPES.keys(), val)) | |
409 | self._app_settings_type = val |
|
409 | self._app_settings_type = val | |
410 |
|
410 | |||
411 | @classmethod |
|
411 | @classmethod | |
412 | def get_by_prefix(cls, prefix): |
|
412 | def get_by_prefix(cls, prefix): | |
413 | return RhodeCodeSetting.query()\ |
|
413 | return RhodeCodeSetting.query()\ | |
414 | .filter(RhodeCodeSetting.app_settings_name.startswith(prefix))\ |
|
414 | .filter(RhodeCodeSetting.app_settings_name.startswith(prefix))\ | |
415 | .all() |
|
415 | .all() | |
416 |
|
416 | |||
417 | def __repr__(self): |
|
417 | def __repr__(self): | |
418 | return "<%s('%s:%s[%s]')>" % ( |
|
418 | return "<%s('%s:%s[%s]')>" % ( | |
419 | self.cls_name, |
|
419 | self.cls_name, | |
420 | self.app_settings_name, self.app_settings_value, |
|
420 | self.app_settings_name, self.app_settings_value, | |
421 | self.app_settings_type |
|
421 | self.app_settings_type | |
422 | ) |
|
422 | ) | |
423 |
|
423 | |||
424 |
|
424 | |||
425 | class RhodeCodeUi(Base, BaseModel): |
|
425 | class RhodeCodeUi(Base, BaseModel): | |
426 | __tablename__ = 'rhodecode_ui' |
|
426 | __tablename__ = 'rhodecode_ui' | |
427 | __table_args__ = ( |
|
427 | __table_args__ = ( | |
428 | UniqueConstraint('ui_key'), |
|
428 | UniqueConstraint('ui_key'), | |
429 | base_table_args |
|
429 | base_table_args | |
430 | ) |
|
430 | ) | |
431 | # Sync those values with vcsserver.config.hooks |
|
431 | # Sync those values with vcsserver.config.hooks | |
432 |
|
432 | |||
433 | HOOK_REPO_SIZE = 'changegroup.repo_size' |
|
433 | HOOK_REPO_SIZE = 'changegroup.repo_size' | |
434 | # HG |
|
434 | # HG | |
435 | HOOK_PRE_PULL = 'preoutgoing.pre_pull' |
|
435 | HOOK_PRE_PULL = 'preoutgoing.pre_pull' | |
436 | HOOK_PULL = 'outgoing.pull_logger' |
|
436 | HOOK_PULL = 'outgoing.pull_logger' | |
437 | HOOK_PRE_PUSH = 'prechangegroup.pre_push' |
|
437 | HOOK_PRE_PUSH = 'prechangegroup.pre_push' | |
438 | HOOK_PRETX_PUSH = 'pretxnchangegroup.pre_push' |
|
438 | HOOK_PRETX_PUSH = 'pretxnchangegroup.pre_push' | |
439 | HOOK_PUSH = 'changegroup.push_logger' |
|
439 | HOOK_PUSH = 'changegroup.push_logger' | |
440 | HOOK_PUSH_KEY = 'pushkey.key_push' |
|
440 | HOOK_PUSH_KEY = 'pushkey.key_push' | |
441 |
|
441 | |||
442 | HOOKS_BUILTIN = [ |
|
442 | HOOKS_BUILTIN = [ | |
443 | HOOK_PRE_PULL, |
|
443 | HOOK_PRE_PULL, | |
444 | HOOK_PULL, |
|
444 | HOOK_PULL, | |
445 | HOOK_PRE_PUSH, |
|
445 | HOOK_PRE_PUSH, | |
446 | HOOK_PRETX_PUSH, |
|
446 | HOOK_PRETX_PUSH, | |
447 | HOOK_PUSH, |
|
447 | HOOK_PUSH, | |
448 | HOOK_PUSH_KEY, |
|
448 | HOOK_PUSH_KEY, | |
449 | ] |
|
449 | ] | |
450 |
|
450 | |||
451 | # TODO: johbo: Unify way how hooks are configured for git and hg, |
|
451 | # TODO: johbo: Unify way how hooks are configured for git and hg, | |
452 | # git part is currently hardcoded. |
|
452 | # git part is currently hardcoded. | |
453 |
|
453 | |||
454 | # SVN PATTERNS |
|
454 | # SVN PATTERNS | |
455 | SVN_BRANCH_ID = 'vcs_svn_branch' |
|
455 | SVN_BRANCH_ID = 'vcs_svn_branch' | |
456 | SVN_TAG_ID = 'vcs_svn_tag' |
|
456 | SVN_TAG_ID = 'vcs_svn_tag' | |
457 |
|
457 | |||
458 | ui_id = Column( |
|
458 | ui_id = Column( | |
459 | "ui_id", Integer(), nullable=False, unique=True, default=None, |
|
459 | "ui_id", Integer(), nullable=False, unique=True, default=None, | |
460 | primary_key=True) |
|
460 | primary_key=True) | |
461 | ui_section = Column( |
|
461 | ui_section = Column( | |
462 | "ui_section", String(255), nullable=True, unique=None, default=None) |
|
462 | "ui_section", String(255), nullable=True, unique=None, default=None) | |
463 | ui_key = Column( |
|
463 | ui_key = Column( | |
464 | "ui_key", String(255), nullable=True, unique=None, default=None) |
|
464 | "ui_key", String(255), nullable=True, unique=None, default=None) | |
465 | ui_value = Column( |
|
465 | ui_value = Column( | |
466 | "ui_value", String(255), nullable=True, unique=None, default=None) |
|
466 | "ui_value", String(255), nullable=True, unique=None, default=None) | |
467 | ui_active = Column( |
|
467 | ui_active = Column( | |
468 | "ui_active", Boolean(), nullable=True, unique=None, default=True) |
|
468 | "ui_active", Boolean(), nullable=True, unique=None, default=True) | |
469 |
|
469 | |||
470 | def __repr__(self): |
|
470 | def __repr__(self): | |
471 | return '<%s[%s]%s=>%s]>' % (self.cls_name, self.ui_section, |
|
471 | return '<%s[%s]%s=>%s]>' % (self.cls_name, self.ui_section, | |
472 | self.ui_key, self.ui_value) |
|
472 | self.ui_key, self.ui_value) | |
473 |
|
473 | |||
474 |
|
474 | |||
475 | class RepoRhodeCodeSetting(Base, BaseModel): |
|
475 | class RepoRhodeCodeSetting(Base, BaseModel): | |
476 | __tablename__ = 'repo_rhodecode_settings' |
|
476 | __tablename__ = 'repo_rhodecode_settings' | |
477 | __table_args__ = ( |
|
477 | __table_args__ = ( | |
478 | UniqueConstraint( |
|
478 | UniqueConstraint( | |
479 | 'app_settings_name', 'repository_id', |
|
479 | 'app_settings_name', 'repository_id', | |
480 | name='uq_repo_rhodecode_setting_name_repo_id'), |
|
480 | name='uq_repo_rhodecode_setting_name_repo_id'), | |
481 | base_table_args |
|
481 | base_table_args | |
482 | ) |
|
482 | ) | |
483 |
|
483 | |||
484 | repository_id = Column( |
|
484 | repository_id = Column( | |
485 | "repository_id", Integer(), ForeignKey('repositories.repo_id'), |
|
485 | "repository_id", Integer(), ForeignKey('repositories.repo_id'), | |
486 | nullable=False) |
|
486 | nullable=False) | |
487 | app_settings_id = Column( |
|
487 | app_settings_id = Column( | |
488 | "app_settings_id", Integer(), nullable=False, unique=True, |
|
488 | "app_settings_id", Integer(), nullable=False, unique=True, | |
489 | default=None, primary_key=True) |
|
489 | default=None, primary_key=True) | |
490 | app_settings_name = Column( |
|
490 | app_settings_name = Column( | |
491 | "app_settings_name", String(255), nullable=True, unique=None, |
|
491 | "app_settings_name", String(255), nullable=True, unique=None, | |
492 | default=None) |
|
492 | default=None) | |
493 | _app_settings_value = Column( |
|
493 | _app_settings_value = Column( | |
494 | "app_settings_value", String(4096), nullable=True, unique=None, |
|
494 | "app_settings_value", String(4096), nullable=True, unique=None, | |
495 | default=None) |
|
495 | default=None) | |
496 | _app_settings_type = Column( |
|
496 | _app_settings_type = Column( | |
497 | "app_settings_type", String(255), nullable=True, unique=None, |
|
497 | "app_settings_type", String(255), nullable=True, unique=None, | |
498 | default=None) |
|
498 | default=None) | |
499 |
|
499 | |||
500 | repository = relationship('Repository', viewonly=True) |
|
500 | repository = relationship('Repository', viewonly=True) | |
501 |
|
501 | |||
502 | def __init__(self, repository_id, key='', val='', type='unicode'): |
|
502 | def __init__(self, repository_id, key='', val='', type='unicode'): | |
503 | self.repository_id = repository_id |
|
503 | self.repository_id = repository_id | |
504 | self.app_settings_name = key |
|
504 | self.app_settings_name = key | |
505 | self.app_settings_type = type |
|
505 | self.app_settings_type = type | |
506 | self.app_settings_value = val |
|
506 | self.app_settings_value = val | |
507 |
|
507 | |||
508 | @validates('_app_settings_value') |
|
508 | @validates('_app_settings_value') | |
509 | def validate_settings_value(self, key, val): |
|
509 | def validate_settings_value(self, key, val): | |
510 | assert type(val) == str |
|
510 | assert type(val) == str | |
511 | return val |
|
511 | return val | |
512 |
|
512 | |||
513 | @hybrid_property |
|
513 | @hybrid_property | |
514 | def app_settings_value(self): |
|
514 | def app_settings_value(self): | |
515 | v = self._app_settings_value |
|
515 | v = self._app_settings_value | |
516 | type_ = self.app_settings_type |
|
516 | type_ = self.app_settings_type | |
517 | SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES |
|
517 | SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES | |
518 | converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode'] |
|
518 | converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode'] | |
519 | return converter(v) |
|
519 | return converter(v) | |
520 |
|
520 | |||
521 | @app_settings_value.setter |
|
521 | @app_settings_value.setter | |
522 | def app_settings_value(self, val): |
|
522 | def app_settings_value(self, val): | |
523 | """ |
|
523 | """ | |
524 | Setter that will always make sure we use unicode in app_settings_value |
|
524 | Setter that will always make sure we use unicode in app_settings_value | |
525 |
|
525 | |||
526 | :param val: |
|
526 | :param val: | |
527 | """ |
|
527 | """ | |
528 | self._app_settings_value = safe_str(val) |
|
528 | self._app_settings_value = safe_str(val) | |
529 |
|
529 | |||
530 | @hybrid_property |
|
530 | @hybrid_property | |
531 | def app_settings_type(self): |
|
531 | def app_settings_type(self): | |
532 | return self._app_settings_type |
|
532 | return self._app_settings_type | |
533 |
|
533 | |||
534 | @app_settings_type.setter |
|
534 | @app_settings_type.setter | |
535 | def app_settings_type(self, val): |
|
535 | def app_settings_type(self, val): | |
536 | SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES |
|
536 | SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES | |
537 | if val not in SETTINGS_TYPES: |
|
537 | if val not in SETTINGS_TYPES: | |
538 | raise Exception('type must be one of %s got %s' |
|
538 | raise Exception('type must be one of %s got %s' | |
539 | % (SETTINGS_TYPES.keys(), val)) |
|
539 | % (SETTINGS_TYPES.keys(), val)) | |
540 | self._app_settings_type = val |
|
540 | self._app_settings_type = val | |
541 |
|
541 | |||
542 | def __repr__(self): |
|
542 | def __repr__(self): | |
543 | return "<%s('%s:%s:%s[%s]')>" % ( |
|
543 | return "<%s('%s:%s:%s[%s]')>" % ( | |
544 | self.cls_name, self.repository.repo_name, |
|
544 | self.cls_name, self.repository.repo_name, | |
545 | self.app_settings_name, self.app_settings_value, |
|
545 | self.app_settings_name, self.app_settings_value, | |
546 | self.app_settings_type |
|
546 | self.app_settings_type | |
547 | ) |
|
547 | ) | |
548 |
|
548 | |||
549 |
|
549 | |||
550 | class RepoRhodeCodeUi(Base, BaseModel): |
|
550 | class RepoRhodeCodeUi(Base, BaseModel): | |
551 | __tablename__ = 'repo_rhodecode_ui' |
|
551 | __tablename__ = 'repo_rhodecode_ui' | |
552 | __table_args__ = ( |
|
552 | __table_args__ = ( | |
553 | UniqueConstraint( |
|
553 | UniqueConstraint( | |
554 | 'repository_id', 'ui_section', 'ui_key', |
|
554 | 'repository_id', 'ui_section', 'ui_key', | |
555 | name='uq_repo_rhodecode_ui_repository_id_section_key'), |
|
555 | name='uq_repo_rhodecode_ui_repository_id_section_key'), | |
556 | base_table_args |
|
556 | base_table_args | |
557 | ) |
|
557 | ) | |
558 |
|
558 | |||
559 | repository_id = Column( |
|
559 | repository_id = Column( | |
560 | "repository_id", Integer(), ForeignKey('repositories.repo_id'), |
|
560 | "repository_id", Integer(), ForeignKey('repositories.repo_id'), | |
561 | nullable=False) |
|
561 | nullable=False) | |
562 | ui_id = Column( |
|
562 | ui_id = Column( | |
563 | "ui_id", Integer(), nullable=False, unique=True, default=None, |
|
563 | "ui_id", Integer(), nullable=False, unique=True, default=None, | |
564 | primary_key=True) |
|
564 | primary_key=True) | |
565 | ui_section = Column( |
|
565 | ui_section = Column( | |
566 | "ui_section", String(255), nullable=True, unique=None, default=None) |
|
566 | "ui_section", String(255), nullable=True, unique=None, default=None) | |
567 | ui_key = Column( |
|
567 | ui_key = Column( | |
568 | "ui_key", String(255), nullable=True, unique=None, default=None) |
|
568 | "ui_key", String(255), nullable=True, unique=None, default=None) | |
569 | ui_value = Column( |
|
569 | ui_value = Column( | |
570 | "ui_value", String(255), nullable=True, unique=None, default=None) |
|
570 | "ui_value", String(255), nullable=True, unique=None, default=None) | |
571 | ui_active = Column( |
|
571 | ui_active = Column( | |
572 | "ui_active", Boolean(), nullable=True, unique=None, default=True) |
|
572 | "ui_active", Boolean(), nullable=True, unique=None, default=True) | |
573 |
|
573 | |||
574 | repository = relationship('Repository', viewonly=True) |
|
574 | repository = relationship('Repository', viewonly=True) | |
575 |
|
575 | |||
576 | def __repr__(self): |
|
576 | def __repr__(self): | |
577 | return '<%s[%s:%s]%s=>%s]>' % ( |
|
577 | return '<%s[%s:%s]%s=>%s]>' % ( | |
578 | self.cls_name, self.repository.repo_name, |
|
578 | self.cls_name, self.repository.repo_name, | |
579 | self.ui_section, self.ui_key, self.ui_value) |
|
579 | self.ui_section, self.ui_key, self.ui_value) | |
580 |
|
580 | |||
581 |
|
581 | |||
582 | class User(Base, BaseModel): |
|
582 | class User(Base, BaseModel): | |
583 | __tablename__ = 'users' |
|
583 | __tablename__ = 'users' | |
584 | __table_args__ = ( |
|
584 | __table_args__ = ( | |
585 | UniqueConstraint('username'), UniqueConstraint('email'), |
|
585 | UniqueConstraint('username'), UniqueConstraint('email'), | |
586 | Index('u_username_idx', 'username'), |
|
586 | Index('u_username_idx', 'username'), | |
587 | Index('u_email_idx', 'email'), |
|
587 | Index('u_email_idx', 'email'), | |
588 | base_table_args |
|
588 | base_table_args | |
589 | ) |
|
589 | ) | |
590 |
|
590 | |||
591 | DEFAULT_USER = 'default' |
|
591 | DEFAULT_USER = 'default' | |
592 | DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org' |
|
592 | DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org' | |
593 | DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}' |
|
593 | DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}' | |
594 | RECOVERY_CODES_COUNT = 10 |
|
594 | RECOVERY_CODES_COUNT = 10 | |
595 |
|
595 | |||
596 | user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
596 | user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
597 | username = Column("username", String(255), nullable=True, unique=None, default=None) |
|
597 | username = Column("username", String(255), nullable=True, unique=None, default=None) | |
598 | password = Column("password", String(255), nullable=True, unique=None, default=None) |
|
598 | password = Column("password", String(255), nullable=True, unique=None, default=None) | |
599 | active = Column("active", Boolean(), nullable=True, unique=None, default=True) |
|
599 | active = Column("active", Boolean(), nullable=True, unique=None, default=True) | |
600 | admin = Column("admin", Boolean(), nullable=True, unique=None, default=False) |
|
600 | admin = Column("admin", Boolean(), nullable=True, unique=None, default=False) | |
601 | name = Column("firstname", String(255), nullable=True, unique=None, default=None) |
|
601 | name = Column("firstname", String(255), nullable=True, unique=None, default=None) | |
602 | lastname = Column("lastname", String(255), nullable=True, unique=None, default=None) |
|
602 | lastname = Column("lastname", String(255), nullable=True, unique=None, default=None) | |
603 | _email = Column("email", String(255), nullable=True, unique=None, default=None) |
|
603 | _email = Column("email", String(255), nullable=True, unique=None, default=None) | |
604 | last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None) |
|
604 | last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None) | |
605 | last_activity = Column('last_activity', DateTime(timezone=False), nullable=True, unique=None, default=None) |
|
605 | last_activity = Column('last_activity', DateTime(timezone=False), nullable=True, unique=None, default=None) | |
606 | description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql')) |
|
606 | description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql')) | |
607 |
|
607 | |||
608 | extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None) |
|
608 | extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None) | |
609 | extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None) |
|
609 | extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None) | |
610 | _api_key = Column("api_key", String(255), nullable=True, unique=None, default=None) |
|
610 | _api_key = Column("api_key", String(255), nullable=True, unique=None, default=None) | |
611 | inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True) |
|
611 | inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True) | |
612 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
612 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
613 | _user_data = Column("user_data", LargeBinary(), nullable=True) # JSON data |
|
613 | _user_data = Column("user_data", LargeBinary(), nullable=True) # JSON data | |
614 |
|
614 | |||
615 | user_log = relationship('UserLog', back_populates='user') |
|
615 | user_log = relationship('UserLog', back_populates='user') | |
616 | user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all, delete-orphan') |
|
616 | user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all, delete-orphan') | |
617 |
|
617 | |||
618 | repositories = relationship('Repository', back_populates='user') |
|
618 | repositories = relationship('Repository', back_populates='user') | |
619 | repository_groups = relationship('RepoGroup', back_populates='user') |
|
619 | repository_groups = relationship('RepoGroup', back_populates='user') | |
620 | user_groups = relationship('UserGroup', back_populates='user') |
|
620 | user_groups = relationship('UserGroup', back_populates='user') | |
621 |
|
621 | |||
622 | user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all', back_populates='follows_user') |
|
622 | user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all', back_populates='follows_user') | |
623 | followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all', back_populates='user') |
|
623 | followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all', back_populates='user') | |
624 |
|
624 | |||
625 | repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all, delete-orphan') |
|
625 | repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all, delete-orphan') | |
626 | repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all, delete-orphan', back_populates='user') |
|
626 | repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all, delete-orphan', back_populates='user') | |
627 | user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all, delete-orphan', back_populates='user') |
|
627 | user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all, delete-orphan', back_populates='user') | |
628 |
|
628 | |||
629 | group_member = relationship('UserGroupMember', cascade='all', back_populates='user') |
|
629 | group_member = relationship('UserGroupMember', cascade='all', back_populates='user') | |
630 |
|
630 | |||
631 | notifications = relationship('UserNotification', cascade='all', back_populates='user') |
|
631 | notifications = relationship('UserNotification', cascade='all', back_populates='user') | |
632 | # notifications assigned to this user |
|
632 | # notifications assigned to this user | |
633 | user_created_notifications = relationship('Notification', cascade='all', back_populates='created_by_user') |
|
633 | user_created_notifications = relationship('Notification', cascade='all', back_populates='created_by_user') | |
634 | # comments created by this user |
|
634 | # comments created by this user | |
635 | user_comments = relationship('ChangesetComment', cascade='all', back_populates='author') |
|
635 | user_comments = relationship('ChangesetComment', cascade='all', back_populates='author') | |
636 | # user profile extra info |
|
636 | # user profile extra info | |
637 | user_emails = relationship('UserEmailMap', cascade='all', back_populates='user') |
|
637 | user_emails = relationship('UserEmailMap', cascade='all', back_populates='user') | |
638 | user_ip_map = relationship('UserIpMap', cascade='all', back_populates='user') |
|
638 | user_ip_map = relationship('UserIpMap', cascade='all', back_populates='user') | |
639 | user_auth_tokens = relationship('UserApiKeys', cascade='all', back_populates='user') |
|
639 | user_auth_tokens = relationship('UserApiKeys', cascade='all', back_populates='user') | |
640 | user_ssh_keys = relationship('UserSshKeys', cascade='all', back_populates='user') |
|
640 | user_ssh_keys = relationship('UserSshKeys', cascade='all', back_populates='user') | |
641 |
|
641 | |||
642 | # gists |
|
642 | # gists | |
643 | user_gists = relationship('Gist', cascade='all', back_populates='owner') |
|
643 | user_gists = relationship('Gist', cascade='all', back_populates='owner') | |
644 | # user pull requests |
|
644 | # user pull requests | |
645 | user_pull_requests = relationship('PullRequest', cascade='all', back_populates='author') |
|
645 | user_pull_requests = relationship('PullRequest', cascade='all', back_populates='author') | |
646 |
|
646 | |||
647 | # external identities |
|
647 | # external identities | |
648 | external_identities = relationship('ExternalIdentity', primaryjoin="User.user_id==ExternalIdentity.local_user_id", cascade='all') |
|
648 | external_identities = relationship('ExternalIdentity', primaryjoin="User.user_id==ExternalIdentity.local_user_id", cascade='all') | |
649 | # review rules |
|
649 | # review rules | |
650 | user_review_rules = relationship('RepoReviewRuleUser', cascade='all', back_populates='user') |
|
650 | user_review_rules = relationship('RepoReviewRuleUser', cascade='all', back_populates='user') | |
651 |
|
651 | |||
652 | # artifacts owned |
|
652 | # artifacts owned | |
653 | artifacts = relationship('FileStore', primaryjoin='FileStore.user_id==User.user_id', back_populates='upload_user') |
|
653 | artifacts = relationship('FileStore', primaryjoin='FileStore.user_id==User.user_id', back_populates='upload_user') | |
654 |
|
654 | |||
655 | # no cascade, set NULL |
|
655 | # no cascade, set NULL | |
656 | scope_artifacts = relationship('FileStore', primaryjoin='FileStore.scope_user_id==User.user_id', cascade='', back_populates='user') |
|
656 | scope_artifacts = relationship('FileStore', primaryjoin='FileStore.scope_user_id==User.user_id', cascade='', back_populates='user') | |
657 |
|
657 | |||
658 | def __repr__(self): |
|
658 | def __repr__(self): | |
659 | return f"<{self.cls_name}('id={self.user_id}, username={self.username}')>" |
|
659 | return f"<{self.cls_name}('id={self.user_id}, username={self.username}')>" | |
660 |
|
660 | |||
661 | @hybrid_property |
|
661 | @hybrid_property | |
662 | def email(self): |
|
662 | def email(self): | |
663 | return self._email |
|
663 | return self._email | |
664 |
|
664 | |||
665 | @email.setter |
|
665 | @email.setter | |
666 | def email(self, val): |
|
666 | def email(self, val): | |
667 | self._email = val.lower() if val else None |
|
667 | self._email = val.lower() if val else None | |
668 |
|
668 | |||
669 | @hybrid_property |
|
669 | @hybrid_property | |
670 | def first_name(self): |
|
670 | def first_name(self): | |
671 | if self.name: |
|
671 | if self.name: | |
672 | return description_escaper(self.name) |
|
672 | return description_escaper(self.name) | |
673 | return self.name |
|
673 | return self.name | |
674 |
|
674 | |||
675 | @hybrid_property |
|
675 | @hybrid_property | |
676 | def last_name(self): |
|
676 | def last_name(self): | |
677 | if self.lastname: |
|
677 | if self.lastname: | |
678 | return description_escaper(self.lastname) |
|
678 | return description_escaper(self.lastname) | |
679 | return self.lastname |
|
679 | return self.lastname | |
680 |
|
680 | |||
681 | @hybrid_property |
|
681 | @hybrid_property | |
682 | def api_key(self): |
|
682 | def api_key(self): | |
683 | """ |
|
683 | """ | |
684 | Fetch if exist an auth-token with role ALL connected to this user |
|
684 | Fetch if exist an auth-token with role ALL connected to this user | |
685 | """ |
|
685 | """ | |
686 | user_auth_token = UserApiKeys.query()\ |
|
686 | user_auth_token = UserApiKeys.query()\ | |
687 | .filter(UserApiKeys.user_id == self.user_id)\ |
|
687 | .filter(UserApiKeys.user_id == self.user_id)\ | |
688 | .filter(or_(UserApiKeys.expires == -1, |
|
688 | .filter(or_(UserApiKeys.expires == -1, | |
689 | UserApiKeys.expires >= time.time()))\ |
|
689 | UserApiKeys.expires >= time.time()))\ | |
690 | .filter(UserApiKeys.role == UserApiKeys.ROLE_ALL).first() |
|
690 | .filter(UserApiKeys.role == UserApiKeys.ROLE_ALL).first() | |
691 | if user_auth_token: |
|
691 | if user_auth_token: | |
692 | user_auth_token = user_auth_token.api_key |
|
692 | user_auth_token = user_auth_token.api_key | |
693 |
|
693 | |||
694 | return user_auth_token |
|
694 | return user_auth_token | |
695 |
|
695 | |||
696 | @api_key.setter |
|
696 | @api_key.setter | |
697 | def api_key(self, val): |
|
697 | def api_key(self, val): | |
698 | # don't allow to set API key this is deprecated for now |
|
698 | # don't allow to set API key this is deprecated for now | |
699 | self._api_key = None |
|
699 | self._api_key = None | |
700 |
|
700 | |||
701 | @property |
|
701 | @property | |
702 | def reviewer_pull_requests(self): |
|
702 | def reviewer_pull_requests(self): | |
703 | return PullRequestReviewers.query() \ |
|
703 | return PullRequestReviewers.query() \ | |
704 | .options(joinedload(PullRequestReviewers.pull_request)) \ |
|
704 | .options(joinedload(PullRequestReviewers.pull_request)) \ | |
705 | .filter(PullRequestReviewers.user_id == self.user_id) \ |
|
705 | .filter(PullRequestReviewers.user_id == self.user_id) \ | |
706 | .all() |
|
706 | .all() | |
707 |
|
707 | |||
708 | @property |
|
708 | @property | |
709 | def firstname(self): |
|
709 | def firstname(self): | |
710 | # alias for future |
|
710 | # alias for future | |
711 | return self.name |
|
711 | return self.name | |
712 |
|
712 | |||
713 | @property |
|
713 | @property | |
714 | def emails(self): |
|
714 | def emails(self): | |
715 | other = UserEmailMap.query()\ |
|
715 | other = UserEmailMap.query()\ | |
716 | .filter(UserEmailMap.user == self) \ |
|
716 | .filter(UserEmailMap.user == self) \ | |
717 | .order_by(UserEmailMap.email_id.asc()) \ |
|
717 | .order_by(UserEmailMap.email_id.asc()) \ | |
718 | .all() |
|
718 | .all() | |
719 | return [self.email] + [x.email for x in other] |
|
719 | return [self.email] + [x.email for x in other] | |
720 |
|
720 | |||
721 | def emails_cached(self): |
|
721 | def emails_cached(self): | |
722 | emails = [] |
|
722 | emails = [] | |
723 | if self.user_id != self.get_default_user_id(): |
|
723 | if self.user_id != self.get_default_user_id(): | |
724 | emails = UserEmailMap.query()\ |
|
724 | emails = UserEmailMap.query()\ | |
725 | .filter(UserEmailMap.user == self) \ |
|
725 | .filter(UserEmailMap.user == self) \ | |
726 | .order_by(UserEmailMap.email_id.asc()) |
|
726 | .order_by(UserEmailMap.email_id.asc()) | |
727 |
|
727 | |||
728 | emails = emails.options( |
|
728 | emails = emails.options( | |
729 | FromCache("sql_cache_short", f"get_user_{self.user_id}_emails") |
|
729 | FromCache("sql_cache_short", f"get_user_{self.user_id}_emails") | |
730 | ) |
|
730 | ) | |
731 |
|
731 | |||
732 | return [self.email] + [x.email for x in emails] |
|
732 | return [self.email] + [x.email for x in emails] | |
733 |
|
733 | |||
734 | @property |
|
734 | @property | |
735 | def auth_tokens(self): |
|
735 | def auth_tokens(self): | |
736 | auth_tokens = self.get_auth_tokens() |
|
736 | auth_tokens = self.get_auth_tokens() | |
737 | return [x.api_key for x in auth_tokens] |
|
737 | return [x.api_key for x in auth_tokens] | |
738 |
|
738 | |||
739 | def get_auth_tokens(self): |
|
739 | def get_auth_tokens(self): | |
740 | return UserApiKeys.query()\ |
|
740 | return UserApiKeys.query()\ | |
741 | .filter(UserApiKeys.user == self)\ |
|
741 | .filter(UserApiKeys.user == self)\ | |
742 | .order_by(UserApiKeys.user_api_key_id.asc())\ |
|
742 | .order_by(UserApiKeys.user_api_key_id.asc())\ | |
743 | .all() |
|
743 | .all() | |
744 |
|
744 | |||
745 | @LazyProperty |
|
745 | @LazyProperty | |
746 | def feed_token(self): |
|
746 | def feed_token(self): | |
747 | return self.get_feed_token() |
|
747 | return self.get_feed_token() | |
748 |
|
748 | |||
749 | def get_feed_token(self, cache=True): |
|
749 | def get_feed_token(self, cache=True): | |
750 | feed_tokens = UserApiKeys.query()\ |
|
750 | feed_tokens = UserApiKeys.query()\ | |
751 | .filter(UserApiKeys.user == self)\ |
|
751 | .filter(UserApiKeys.user == self)\ | |
752 | .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED) |
|
752 | .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED) | |
753 | if cache: |
|
753 | if cache: | |
754 | feed_tokens = feed_tokens.options( |
|
754 | feed_tokens = feed_tokens.options( | |
755 | FromCache("sql_cache_short", f"get_user_feed_token_{self.user_id}")) |
|
755 | FromCache("sql_cache_short", f"get_user_feed_token_{self.user_id}")) | |
756 |
|
756 | |||
757 | feed_tokens = feed_tokens.all() |
|
757 | feed_tokens = feed_tokens.all() | |
758 | if feed_tokens: |
|
758 | if feed_tokens: | |
759 | return feed_tokens[0].api_key |
|
759 | return feed_tokens[0].api_key | |
760 | return 'NO_FEED_TOKEN_AVAILABLE' |
|
760 | return 'NO_FEED_TOKEN_AVAILABLE' | |
761 |
|
761 | |||
762 | @LazyProperty |
|
762 | @LazyProperty | |
763 | def artifact_token(self): |
|
763 | def artifact_token(self): | |
764 | return self.get_artifact_token() |
|
764 | return self.get_artifact_token() | |
765 |
|
765 | |||
766 | def get_artifact_token(self, cache=True): |
|
766 | def get_artifact_token(self, cache=True): | |
767 | artifacts_tokens = UserApiKeys.query()\ |
|
767 | artifacts_tokens = UserApiKeys.query()\ | |
768 | .filter(UserApiKeys.user == self) \ |
|
768 | .filter(UserApiKeys.user == self) \ | |
769 | .filter(or_(UserApiKeys.expires == -1, |
|
769 | .filter(or_(UserApiKeys.expires == -1, | |
770 | UserApiKeys.expires >= time.time())) \ |
|
770 | UserApiKeys.expires >= time.time())) \ | |
771 | .filter(UserApiKeys.role == UserApiKeys.ROLE_ARTIFACT_DOWNLOAD) |
|
771 | .filter(UserApiKeys.role == UserApiKeys.ROLE_ARTIFACT_DOWNLOAD) | |
772 |
|
772 | |||
773 | if cache: |
|
773 | if cache: | |
774 | artifacts_tokens = artifacts_tokens.options( |
|
774 | artifacts_tokens = artifacts_tokens.options( | |
775 | FromCache("sql_cache_short", f"get_user_artifact_token_{self.user_id}")) |
|
775 | FromCache("sql_cache_short", f"get_user_artifact_token_{self.user_id}")) | |
776 |
|
776 | |||
777 | artifacts_tokens = artifacts_tokens.all() |
|
777 | artifacts_tokens = artifacts_tokens.all() | |
778 | if artifacts_tokens: |
|
778 | if artifacts_tokens: | |
779 | return artifacts_tokens[0].api_key |
|
779 | return artifacts_tokens[0].api_key | |
780 | return 'NO_ARTIFACT_TOKEN_AVAILABLE' |
|
780 | return 'NO_ARTIFACT_TOKEN_AVAILABLE' | |
781 |
|
781 | |||
782 | def get_or_create_artifact_token(self): |
|
782 | def get_or_create_artifact_token(self): | |
783 | artifacts_tokens = UserApiKeys.query()\ |
|
783 | artifacts_tokens = UserApiKeys.query()\ | |
784 | .filter(UserApiKeys.user == self) \ |
|
784 | .filter(UserApiKeys.user == self) \ | |
785 | .filter(or_(UserApiKeys.expires == -1, |
|
785 | .filter(or_(UserApiKeys.expires == -1, | |
786 | UserApiKeys.expires >= time.time())) \ |
|
786 | UserApiKeys.expires >= time.time())) \ | |
787 | .filter(UserApiKeys.role == UserApiKeys.ROLE_ARTIFACT_DOWNLOAD) |
|
787 | .filter(UserApiKeys.role == UserApiKeys.ROLE_ARTIFACT_DOWNLOAD) | |
788 |
|
788 | |||
789 | artifacts_tokens = artifacts_tokens.all() |
|
789 | artifacts_tokens = artifacts_tokens.all() | |
790 | if artifacts_tokens: |
|
790 | if artifacts_tokens: | |
791 | return artifacts_tokens[0].api_key |
|
791 | return artifacts_tokens[0].api_key | |
792 | else: |
|
792 | else: | |
793 | from rhodecode.model.auth_token import AuthTokenModel |
|
793 | from rhodecode.model.auth_token import AuthTokenModel | |
794 | artifact_token = AuthTokenModel().create( |
|
794 | artifact_token = AuthTokenModel().create( | |
795 | self, 'auto-generated-artifact-token', |
|
795 | self, 'auto-generated-artifact-token', | |
796 | lifetime=-1, role=UserApiKeys.ROLE_ARTIFACT_DOWNLOAD) |
|
796 | lifetime=-1, role=UserApiKeys.ROLE_ARTIFACT_DOWNLOAD) | |
797 | Session.commit() |
|
797 | Session.commit() | |
798 | return artifact_token.api_key |
|
798 | return artifact_token.api_key | |
799 |
|
799 | |||
800 | def is_totp_valid(self, received_code, secret): |
|
800 | def is_totp_valid(self, received_code, secret): | |
801 | totp = pyotp.TOTP(secret) |
|
801 | totp = pyotp.TOTP(secret) | |
802 | return totp.verify(received_code) |
|
802 | return totp.verify(received_code) | |
803 |
|
803 | |||
804 | def is_2fa_recovery_code_valid(self, received_code, secret): |
|
804 | def is_2fa_recovery_code_valid(self, received_code, secret): | |
805 | encrypted_recovery_codes = self.user_data.get('recovery_codes_2fa', []) |
|
805 | encrypted_recovery_codes = self.user_data.get('recovery_codes_2fa', []) | |
806 | recovery_codes = self.get_2fa_recovery_codes() |
|
806 | recovery_codes = self.get_2fa_recovery_codes() | |
807 | if received_code in recovery_codes: |
|
807 | if received_code in recovery_codes: | |
808 | encrypted_recovery_codes.pop(recovery_codes.index(received_code)) |
|
808 | encrypted_recovery_codes.pop(recovery_codes.index(received_code)) | |
809 | self.update_userdata(recovery_codes_2fa=encrypted_recovery_codes) |
|
809 | self.update_userdata(recovery_codes_2fa=encrypted_recovery_codes) | |
810 | return True |
|
810 | return True | |
811 | return False |
|
811 | return False | |
812 |
|
812 | |||
813 | @hybrid_property |
|
813 | @hybrid_property | |
814 | def has_forced_2fa(self): |
|
814 | def has_forced_2fa(self): | |
815 | """ |
|
815 | """ | |
816 | Checks if 2fa was forced for current user |
|
816 | Checks if 2fa was forced for current user | |
817 | """ |
|
817 | """ | |
818 | from rhodecode.model.settings import SettingsModel |
|
818 | from rhodecode.model.settings import SettingsModel | |
819 | if value := SettingsModel().get_setting_by_name(f'auth_{self.extern_type}_global_2fa'): |
|
819 | if value := SettingsModel().get_setting_by_name(f'auth_{self.extern_type}_global_2fa'): | |
820 | return value.app_settings_value |
|
820 | return value.app_settings_value | |
821 | return False |
|
821 | return False | |
822 |
|
822 | |||
823 | @hybrid_property |
|
823 | @hybrid_property | |
824 | def has_enabled_2fa(self): |
|
824 | def has_enabled_2fa(self): | |
825 | """ |
|
825 | """ | |
826 | Checks if user enabled 2fa |
|
826 | Checks if user enabled 2fa | |
827 | """ |
|
827 | """ | |
828 | if value := self.has_forced_2fa: |
|
828 | if value := self.has_forced_2fa: | |
829 | return value |
|
829 | return value | |
830 | return self.user_data.get('enabled_2fa', False) |
|
830 | return self.user_data.get('enabled_2fa', False) | |
831 |
|
831 | |||
832 | @has_enabled_2fa.setter |
|
832 | @has_enabled_2fa.setter | |
833 | def has_enabled_2fa(self, val): |
|
833 | def has_enabled_2fa(self, val): | |
834 | val = str2bool(val) |
|
834 | val = str2bool(val) | |
835 | self.update_userdata(enabled_2fa=val) |
|
835 | self.update_userdata(enabled_2fa=val) | |
836 | if not val: |
|
836 | if not val: | |
837 | # NOTE: setting to false we clear the user_data to not store any 2fa artifacts |
|
837 | # NOTE: setting to false we clear the user_data to not store any 2fa artifacts | |
838 | self.update_userdata(secret_2fa=None, recovery_codes_2fa=[], check_2fa=False) |
|
838 | self.update_userdata(secret_2fa=None, recovery_codes_2fa=[], check_2fa=False) | |
839 | Session().commit() |
|
839 | Session().commit() | |
840 |
|
840 | |||
841 | @hybrid_property |
|
841 | @hybrid_property | |
842 | def check_2fa_required(self): |
|
842 | def check_2fa_required(self): | |
843 | """ |
|
843 | """ | |
844 | Check if check 2fa flag is set for this user |
|
844 | Check if check 2fa flag is set for this user | |
845 | """ |
|
845 | """ | |
846 | value = self.user_data.get('check_2fa', False) |
|
846 | value = self.user_data.get('check_2fa', False) | |
847 | return value |
|
847 | return value | |
848 |
|
848 | |||
849 | @check_2fa_required.setter |
|
849 | @check_2fa_required.setter | |
850 | def check_2fa_required(self, val): |
|
850 | def check_2fa_required(self, val): | |
851 | val = str2bool(val) |
|
851 | val = str2bool(val) | |
852 | self.update_userdata(check_2fa=val) |
|
852 | self.update_userdata(check_2fa=val) | |
853 | Session().commit() |
|
853 | Session().commit() | |
854 |
|
854 | |||
855 | @hybrid_property |
|
855 | @hybrid_property | |
856 | def has_seen_2fa_codes(self): |
|
856 | def has_seen_2fa_codes(self): | |
857 | """ |
|
857 | """ | |
858 | get the flag about if user has seen 2fa recovery codes |
|
858 | get the flag about if user has seen 2fa recovery codes | |
859 | """ |
|
859 | """ | |
860 | value = self.user_data.get('recovery_codes_2fa_seen', False) |
|
860 | value = self.user_data.get('recovery_codes_2fa_seen', False) | |
861 | return value |
|
861 | return value | |
862 |
|
862 | |||
863 | @has_seen_2fa_codes.setter |
|
863 | @has_seen_2fa_codes.setter | |
864 | def has_seen_2fa_codes(self, val): |
|
864 | def has_seen_2fa_codes(self, val): | |
865 | val = str2bool(val) |
|
865 | val = str2bool(val) | |
866 | self.update_userdata(recovery_codes_2fa_seen=val) |
|
866 | self.update_userdata(recovery_codes_2fa_seen=val) | |
867 | Session().commit() |
|
867 | Session().commit() | |
868 |
|
868 | |||
869 | @hybrid_property |
|
869 | @hybrid_property | |
870 | def needs_2fa_configure(self): |
|
870 | def needs_2fa_configure(self): | |
871 | """ |
|
871 | """ | |
872 | Determines if setup2fa has completed for this user. Means he has all needed data for 2fa to work. |
|
872 | Determines if setup2fa has completed for this user. Means he has all needed data for 2fa to work. | |
873 |
|
873 | |||
874 | Currently this is 2fa enabled and secret exists |
|
874 | Currently this is 2fa enabled and secret exists | |
875 | """ |
|
875 | """ | |
876 | if self.has_enabled_2fa: |
|
876 | if self.has_enabled_2fa: | |
877 | return not self.user_data.get('secret_2fa') |
|
877 | return not self.user_data.get('secret_2fa') | |
878 | return False |
|
878 | return False | |
879 |
|
879 | |||
880 | def init_2fa_recovery_codes(self, persist=True, force=False): |
|
880 | def init_2fa_recovery_codes(self, persist=True, force=False): | |
881 | """ |
|
881 | """ | |
882 | Creates 2fa recovery codes |
|
882 | Creates 2fa recovery codes | |
883 | """ |
|
883 | """ | |
884 | recovery_codes = self.user_data.get('recovery_codes_2fa', []) |
|
884 | recovery_codes = self.user_data.get('recovery_codes_2fa', []) | |
885 | encrypted_codes = [] |
|
885 | encrypted_codes = [] | |
886 | if not recovery_codes or force: |
|
886 | if not recovery_codes or force: | |
887 | for _ in range(self.RECOVERY_CODES_COUNT): |
|
887 | for _ in range(self.RECOVERY_CODES_COUNT): | |
888 | recovery_code = pyotp.random_base32() |
|
888 | recovery_code = pyotp.random_base32() | |
889 | recovery_codes.append(recovery_code) |
|
889 | recovery_codes.append(recovery_code) | |
890 | encrypted_code = enc_utils.encrypt_value(safe_bytes(recovery_code), enc_key=ENCRYPTION_KEY) |
|
890 | encrypted_code = enc_utils.encrypt_value(safe_bytes(recovery_code), enc_key=ENCRYPTION_KEY) | |
891 | encrypted_codes.append(safe_str(encrypted_code)) |
|
891 | encrypted_codes.append(safe_str(encrypted_code)) | |
892 | if persist: |
|
892 | if persist: | |
893 | self.update_userdata(recovery_codes_2fa=encrypted_codes, recovery_codes_2fa_seen=False) |
|
893 | self.update_userdata(recovery_codes_2fa=encrypted_codes, recovery_codes_2fa_seen=False) | |
894 | return recovery_codes |
|
894 | return recovery_codes | |
895 | # User should not check the same recovery codes more than once |
|
895 | # User should not check the same recovery codes more than once | |
896 | return [] |
|
896 | return [] | |
897 |
|
897 | |||
898 | def get_2fa_recovery_codes(self): |
|
898 | def get_2fa_recovery_codes(self): | |
899 | encrypted_recovery_codes = self.user_data.get('recovery_codes_2fa', []) |
|
899 | encrypted_recovery_codes = self.user_data.get('recovery_codes_2fa', []) | |
900 |
|
900 | |||
901 | recovery_codes = list(map( |
|
901 | recovery_codes = list(map( | |
902 | lambda val: safe_str( |
|
902 | lambda val: safe_str( | |
903 | enc_utils.decrypt_value( |
|
903 | enc_utils.decrypt_value( | |
904 | val, |
|
904 | val, | |
905 | enc_key=ENCRYPTION_KEY |
|
905 | enc_key=ENCRYPTION_KEY | |
906 | )), |
|
906 | )), | |
907 | encrypted_recovery_codes)) |
|
907 | encrypted_recovery_codes)) | |
908 | return recovery_codes |
|
908 | return recovery_codes | |
909 |
|
909 | |||
910 | def init_secret_2fa(self, persist=True, force=False): |
|
910 | def init_secret_2fa(self, persist=True, force=False): | |
911 | secret_2fa = self.user_data.get('secret_2fa') |
|
911 | secret_2fa = self.user_data.get('secret_2fa') | |
912 | if not secret_2fa or force: |
|
912 | if not secret_2fa or force: | |
913 | secret = pyotp.random_base32() |
|
913 | secret = pyotp.random_base32() | |
914 | if persist: |
|
914 | if persist: | |
915 | self.update_userdata(secret_2fa=safe_str(enc_utils.encrypt_value(safe_bytes(secret), enc_key=ENCRYPTION_KEY))) |
|
915 | self.update_userdata(secret_2fa=safe_str(enc_utils.encrypt_value(safe_bytes(secret), enc_key=ENCRYPTION_KEY))) | |
916 | return secret |
|
916 | return secret | |
917 | return '' |
|
917 | return '' | |
918 |
|
918 | |||
919 | @hybrid_property |
|
919 | @hybrid_property | |
920 | def secret_2fa(self) -> str: |
|
920 | def secret_2fa(self) -> str: | |
921 | """ |
|
921 | """ | |
922 | get stored secret for 2fa |
|
922 | get stored secret for 2fa | |
923 | """ |
|
923 | """ | |
924 | secret_2fa = self.user_data.get('secret_2fa') |
|
924 | secret_2fa = self.user_data.get('secret_2fa') | |
925 | if secret_2fa: |
|
925 | if secret_2fa: | |
926 | return safe_str( |
|
926 | return safe_str( | |
927 | enc_utils.decrypt_value(secret_2fa, enc_key=ENCRYPTION_KEY)) |
|
927 | enc_utils.decrypt_value(secret_2fa, enc_key=ENCRYPTION_KEY)) | |
928 | return '' |
|
928 | return '' | |
929 |
|
929 | |||
930 | @secret_2fa.setter |
|
930 | @secret_2fa.setter | |
931 | def secret_2fa(self, value: str) -> None: |
|
931 | def secret_2fa(self, value: str) -> None: | |
932 | encrypted_value = enc_utils.encrypt_value(safe_bytes(value), enc_key=ENCRYPTION_KEY) |
|
932 | encrypted_value = enc_utils.encrypt_value(safe_bytes(value), enc_key=ENCRYPTION_KEY) | |
933 | self.update_userdata(secret_2fa=safe_str(encrypted_value)) |
|
933 | self.update_userdata(secret_2fa=safe_str(encrypted_value)) | |
934 |
|
934 | |||
935 | def regenerate_2fa_recovery_codes(self): |
|
935 | def regenerate_2fa_recovery_codes(self): | |
936 | """ |
|
936 | """ | |
937 | Regenerates 2fa recovery codes upon request |
|
937 | Regenerates 2fa recovery codes upon request | |
938 | """ |
|
938 | """ | |
939 | new_recovery_codes = self.init_2fa_recovery_codes(force=True) |
|
939 | new_recovery_codes = self.init_2fa_recovery_codes(force=True) | |
940 | Session().commit() |
|
940 | Session().commit() | |
941 | return new_recovery_codes |
|
941 | return new_recovery_codes | |
942 |
|
942 | |||
943 | @classmethod |
|
943 | @classmethod | |
944 | def extra_valid_auth_tokens(cls, user, role=None): |
|
944 | def extra_valid_auth_tokens(cls, user, role=None): | |
945 | tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\ |
|
945 | tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\ | |
946 | .filter(or_(UserApiKeys.expires == -1, |
|
946 | .filter(or_(UserApiKeys.expires == -1, | |
947 | UserApiKeys.expires >= time.time())) |
|
947 | UserApiKeys.expires >= time.time())) | |
948 | if role: |
|
948 | if role: | |
949 | tokens = tokens.filter(or_(UserApiKeys.role == role, |
|
949 | tokens = tokens.filter(or_(UserApiKeys.role == role, | |
950 | UserApiKeys.role == UserApiKeys.ROLE_ALL)) |
|
950 | UserApiKeys.role == UserApiKeys.ROLE_ALL)) | |
951 | return tokens.all() |
|
951 | return tokens.all() | |
952 |
|
952 | |||
953 | def authenticate_by_token(self, auth_token, roles=None, scope_repo_id=None): |
|
953 | def authenticate_by_token(self, auth_token, roles=None, scope_repo_id=None): | |
954 | from rhodecode.lib import auth |
|
954 | from rhodecode.lib import auth | |
955 |
|
955 | |||
956 | log.debug('Trying to authenticate user: %s via auth-token, ' |
|
956 | log.debug('Trying to authenticate user: %s via auth-token, ' | |
957 | 'and roles: %s', self, roles) |
|
957 | 'and roles: %s', self, roles) | |
958 |
|
958 | |||
959 | if not auth_token: |
|
959 | if not auth_token: | |
960 | return False |
|
960 | return False | |
961 |
|
961 | |||
962 | roles = (roles or []) + [UserApiKeys.ROLE_ALL] |
|
962 | roles = (roles or []) + [UserApiKeys.ROLE_ALL] | |
963 | tokens_q = UserApiKeys.query()\ |
|
963 | tokens_q = UserApiKeys.query()\ | |
964 | .filter(UserApiKeys.user_id == self.user_id)\ |
|
964 | .filter(UserApiKeys.user_id == self.user_id)\ | |
965 | .filter(or_(UserApiKeys.expires == -1, |
|
965 | .filter(or_(UserApiKeys.expires == -1, | |
966 | UserApiKeys.expires >= time.time())) |
|
966 | UserApiKeys.expires >= time.time())) | |
967 |
|
967 | |||
968 | tokens_q = tokens_q.filter(UserApiKeys.role.in_(roles)) |
|
968 | tokens_q = tokens_q.filter(UserApiKeys.role.in_(roles)) | |
969 |
|
969 | |||
970 | crypto_backend = auth.crypto_backend() |
|
970 | crypto_backend = auth.crypto_backend() | |
971 | enc_token_map = {} |
|
971 | enc_token_map = {} | |
972 | plain_token_map = {} |
|
972 | plain_token_map = {} | |
973 | for token in tokens_q: |
|
973 | for token in tokens_q: | |
974 | if token.api_key.startswith(crypto_backend.ENC_PREF): |
|
974 | if token.api_key.startswith(crypto_backend.ENC_PREF): | |
975 | enc_token_map[token.api_key] = token |
|
975 | enc_token_map[token.api_key] = token | |
976 | else: |
|
976 | else: | |
977 | plain_token_map[token.api_key] = token |
|
977 | plain_token_map[token.api_key] = token | |
978 | log.debug( |
|
978 | log.debug( | |
979 | 'Found %s plain and %s encrypted tokens to check for authentication for this user', |
|
979 | 'Found %s plain and %s encrypted tokens to check for authentication for this user', | |
980 | len(plain_token_map), len(enc_token_map)) |
|
980 | len(plain_token_map), len(enc_token_map)) | |
981 |
|
981 | |||
982 | # plain token match comes first |
|
982 | # plain token match comes first | |
983 | match = plain_token_map.get(auth_token) |
|
983 | match = plain_token_map.get(auth_token) | |
984 |
|
984 | |||
985 | # check encrypted tokens now |
|
985 | # check encrypted tokens now | |
986 | if not match: |
|
986 | if not match: | |
987 | for token_hash, token in enc_token_map.items(): |
|
987 | for token_hash, token in enc_token_map.items(): | |
988 | # NOTE(marcink): this is expensive to calculate, but most secure |
|
988 | # NOTE(marcink): this is expensive to calculate, but most secure | |
989 | if crypto_backend.hash_check(auth_token, token_hash): |
|
989 | if crypto_backend.hash_check(auth_token, token_hash): | |
990 | match = token |
|
990 | match = token | |
991 | break |
|
991 | break | |
992 |
|
992 | |||
993 | if match: |
|
993 | if match: | |
994 | log.debug('Found matching token %s', match) |
|
994 | log.debug('Found matching token %s', match) | |
995 | if match.repo_id: |
|
995 | if match.repo_id: | |
996 | log.debug('Found scope, checking for scope match of token %s', match) |
|
996 | log.debug('Found scope, checking for scope match of token %s', match) | |
997 | if match.repo_id == scope_repo_id: |
|
997 | if match.repo_id == scope_repo_id: | |
998 | return True |
|
998 | return True | |
999 | else: |
|
999 | else: | |
1000 | log.debug( |
|
1000 | log.debug( | |
1001 | 'AUTH_TOKEN: scope mismatch, token has a set repo scope: %s, ' |
|
1001 | 'AUTH_TOKEN: scope mismatch, token has a set repo scope: %s, ' | |
1002 | 'and calling scope is:%s, skipping further checks', |
|
1002 | 'and calling scope is:%s, skipping further checks', | |
1003 | match.repo, scope_repo_id) |
|
1003 | match.repo, scope_repo_id) | |
1004 | return False |
|
1004 | return False | |
1005 | else: |
|
1005 | else: | |
1006 | return True |
|
1006 | return True | |
1007 |
|
1007 | |||
1008 | return False |
|
1008 | return False | |
1009 |
|
1009 | |||
1010 | @property |
|
1010 | @property | |
1011 | def ip_addresses(self): |
|
1011 | def ip_addresses(self): | |
1012 | ret = UserIpMap.query().filter(UserIpMap.user == self).all() |
|
1012 | ret = UserIpMap.query().filter(UserIpMap.user == self).all() | |
1013 | return [x.ip_addr for x in ret] |
|
1013 | return [x.ip_addr for x in ret] | |
1014 |
|
1014 | |||
1015 | @property |
|
1015 | @property | |
1016 | def username_and_name(self): |
|
1016 | def username_and_name(self): | |
1017 | return f'{self.username} ({self.first_name} {self.last_name})' |
|
1017 | return f'{self.username} ({self.first_name} {self.last_name})' | |
1018 |
|
1018 | |||
1019 | @property |
|
1019 | @property | |
1020 | def username_or_name_or_email(self): |
|
1020 | def username_or_name_or_email(self): | |
1021 | full_name = self.full_name if self.full_name != ' ' else None |
|
1021 | full_name = self.full_name if self.full_name != ' ' else None | |
1022 | return self.username or full_name or self.email |
|
1022 | return self.username or full_name or self.email | |
1023 |
|
1023 | |||
1024 | @property |
|
1024 | @property | |
1025 | def full_name(self): |
|
1025 | def full_name(self): | |
1026 | return f'{self.first_name} {self.last_name}' |
|
1026 | return f'{self.first_name} {self.last_name}' | |
1027 |
|
1027 | |||
1028 | @property |
|
1028 | @property | |
1029 | def full_name_or_username(self): |
|
1029 | def full_name_or_username(self): | |
1030 | return (f'{self.first_name} {self.last_name}' |
|
1030 | return (f'{self.first_name} {self.last_name}' | |
1031 | if (self.first_name and self.last_name) else self.username) |
|
1031 | if (self.first_name and self.last_name) else self.username) | |
1032 |
|
1032 | |||
1033 | @property |
|
1033 | @property | |
1034 | def full_contact(self): |
|
1034 | def full_contact(self): | |
1035 | return f'{self.first_name} {self.last_name} <{self.email}>' |
|
1035 | return f'{self.first_name} {self.last_name} <{self.email}>' | |
1036 |
|
1036 | |||
1037 | @property |
|
1037 | @property | |
1038 | def short_contact(self): |
|
1038 | def short_contact(self): | |
1039 | return f'{self.first_name} {self.last_name}' |
|
1039 | return f'{self.first_name} {self.last_name}' | |
1040 |
|
1040 | |||
1041 | @property |
|
1041 | @property | |
1042 | def is_admin(self): |
|
1042 | def is_admin(self): | |
1043 | return self.admin |
|
1043 | return self.admin | |
1044 |
|
1044 | |||
1045 | @property |
|
1045 | @property | |
1046 | def language(self): |
|
1046 | def language(self): | |
1047 | return self.user_data.get('language') |
|
1047 | return self.user_data.get('language') | |
1048 |
|
1048 | |||
1049 | def AuthUser(self, **kwargs): |
|
1049 | def AuthUser(self, **kwargs): | |
1050 | """ |
|
1050 | """ | |
1051 | Returns instance of AuthUser for this user |
|
1051 | Returns instance of AuthUser for this user | |
1052 | """ |
|
1052 | """ | |
1053 | from rhodecode.lib.auth import AuthUser |
|
1053 | from rhodecode.lib.auth import AuthUser | |
1054 | return AuthUser(user_id=self.user_id, username=self.username, **kwargs) |
|
1054 | return AuthUser(user_id=self.user_id, username=self.username, **kwargs) | |
1055 |
|
1055 | |||
1056 | @hybrid_property |
|
1056 | @hybrid_property | |
1057 | def user_data(self): |
|
1057 | def user_data(self): | |
1058 | if not self._user_data: |
|
1058 | if not self._user_data: | |
1059 | return {} |
|
1059 | return {} | |
1060 |
|
1060 | |||
1061 | try: |
|
1061 | try: | |
1062 | return json.loads(self._user_data) or {} |
|
1062 | return json.loads(self._user_data) or {} | |
1063 | except TypeError: |
|
1063 | except TypeError: | |
1064 | return {} |
|
1064 | return {} | |
1065 |
|
1065 | |||
1066 | @user_data.setter |
|
1066 | @user_data.setter | |
1067 | def user_data(self, val): |
|
1067 | def user_data(self, val): | |
1068 | if not isinstance(val, dict): |
|
1068 | if not isinstance(val, dict): | |
1069 | raise Exception(f'user_data must be dict, got {type(val)}') |
|
1069 | raise Exception(f'user_data must be dict, got {type(val)}') | |
1070 | try: |
|
1070 | try: | |
1071 | self._user_data = safe_bytes(json.dumps(val)) |
|
1071 | self._user_data = safe_bytes(json.dumps(val)) | |
1072 | except Exception: |
|
1072 | except Exception: | |
1073 | log.error(traceback.format_exc()) |
|
1073 | log.error(traceback.format_exc()) | |
1074 |
|
1074 | |||
1075 | @classmethod |
|
1075 | @classmethod | |
1076 | def get(cls, user_id, cache=False): |
|
1076 | def get(cls, user_id, cache=False): | |
1077 | if not user_id: |
|
1077 | if not user_id: | |
1078 | return |
|
1078 | return | |
1079 |
|
1079 | |||
1080 | user = cls.query() |
|
1080 | user = cls.query() | |
1081 | if cache: |
|
1081 | if cache: | |
1082 | user = user.options( |
|
1082 | user = user.options( | |
1083 | FromCache("sql_cache_short", f"get_users_{user_id}")) |
|
1083 | FromCache("sql_cache_short", f"get_users_{user_id}")) | |
1084 | return user.get(user_id) |
|
1084 | return user.get(user_id) | |
1085 |
|
1085 | |||
1086 | @classmethod |
|
1086 | @classmethod | |
1087 | def get_by_username(cls, username, case_insensitive=False, |
|
1087 | def get_by_username(cls, username, case_insensitive=False, | |
1088 | cache=False): |
|
1088 | cache=False): | |
1089 |
|
1089 | |||
1090 | if case_insensitive: |
|
1090 | if case_insensitive: | |
1091 | q = cls.select().where( |
|
1091 | q = cls.select().where( | |
1092 | func.lower(cls.username) == func.lower(username)) |
|
1092 | func.lower(cls.username) == func.lower(username)) | |
1093 | else: |
|
1093 | else: | |
1094 | q = cls.select().where(cls.username == username) |
|
1094 | q = cls.select().where(cls.username == username) | |
1095 |
|
1095 | |||
1096 | if cache: |
|
1096 | if cache: | |
1097 | hash_key = _hash_key(username) |
|
1097 | hash_key = _hash_key(username) | |
1098 | q = q.options( |
|
1098 | q = q.options( | |
1099 | FromCache("sql_cache_short", f"get_user_by_name_{hash_key}")) |
|
1099 | FromCache("sql_cache_short", f"get_user_by_name_{hash_key}")) | |
1100 |
|
1100 | |||
1101 | return cls.execute(q).scalar_one_or_none() |
|
1101 | return cls.execute(q).scalar_one_or_none() | |
1102 |
|
1102 | |||
1103 | @classmethod |
|
1103 | @classmethod | |
1104 | def get_by_username_or_primary_email(cls, user_identifier): |
|
1104 | def get_by_username_or_primary_email(cls, user_identifier): | |
1105 | qs = union_all(cls.select().where(func.lower(cls.username) == func.lower(user_identifier)), |
|
1105 | qs = union_all(cls.select().where(func.lower(cls.username) == func.lower(user_identifier)), | |
1106 | cls.select().where(func.lower(cls.email) == func.lower(user_identifier))) |
|
1106 | cls.select().where(func.lower(cls.email) == func.lower(user_identifier))) | |
1107 | return cls.execute(cls.select(User).from_statement(qs)).scalar_one_or_none() |
|
1107 | return cls.execute(cls.select(User).from_statement(qs)).scalar_one_or_none() | |
1108 |
|
1108 | |||
1109 | @classmethod |
|
1109 | @classmethod | |
1110 | def get_by_auth_token(cls, auth_token, cache=False): |
|
1110 | def get_by_auth_token(cls, auth_token, cache=False): | |
1111 |
|
1111 | |||
1112 | q = cls.select(User)\ |
|
1112 | q = cls.select(User)\ | |
1113 | .join(UserApiKeys)\ |
|
1113 | .join(UserApiKeys)\ | |
1114 | .where(UserApiKeys.api_key == auth_token)\ |
|
1114 | .where(UserApiKeys.api_key == auth_token)\ | |
1115 | .where(or_(UserApiKeys.expires == -1, |
|
1115 | .where(or_(UserApiKeys.expires == -1, | |
1116 | UserApiKeys.expires >= time.time())) |
|
1116 | UserApiKeys.expires >= time.time())) | |
1117 |
|
1117 | |||
1118 | if cache: |
|
1118 | if cache: | |
1119 | q = q.options( |
|
1119 | q = q.options( | |
1120 | FromCache("sql_cache_short", f"get_auth_token_{auth_token}")) |
|
1120 | FromCache("sql_cache_short", f"get_auth_token_{auth_token}")) | |
1121 |
|
1121 | |||
1122 | matched_user = cls.execute(q).scalar_one_or_none() |
|
1122 | matched_user = cls.execute(q).scalar_one_or_none() | |
1123 |
|
1123 | |||
1124 | return matched_user |
|
1124 | return matched_user | |
1125 |
|
1125 | |||
1126 | @classmethod |
|
1126 | @classmethod | |
1127 | def get_by_email(cls, email, case_insensitive=False, cache=False): |
|
1127 | def get_by_email(cls, email, case_insensitive=False, cache=False): | |
1128 |
|
1128 | |||
1129 | if case_insensitive: |
|
1129 | if case_insensitive: | |
1130 | q = cls.select().where(func.lower(cls.email) == func.lower(email)) |
|
1130 | q = cls.select().where(func.lower(cls.email) == func.lower(email)) | |
1131 | else: |
|
1131 | else: | |
1132 | q = cls.select().where(cls.email == email) |
|
1132 | q = cls.select().where(cls.email == email) | |
1133 |
|
1133 | |||
1134 | if cache: |
|
1134 | if cache: | |
1135 | email_key = _hash_key(email) |
|
1135 | email_key = _hash_key(email) | |
1136 | q = q.options( |
|
1136 | q = q.options( | |
1137 | FromCache("sql_cache_short", f"get_email_key_{email_key}")) |
|
1137 | FromCache("sql_cache_short", f"get_email_key_{email_key}")) | |
1138 |
|
1138 | |||
1139 | ret = cls.execute(q).scalar_one_or_none() |
|
1139 | ret = cls.execute(q).scalar_one_or_none() | |
1140 |
|
1140 | |||
1141 | if ret is None: |
|
1141 | if ret is None: | |
1142 | q = cls.select(UserEmailMap) |
|
1142 | q = cls.select(UserEmailMap) | |
1143 | # try fetching in alternate email map |
|
1143 | # try fetching in alternate email map | |
1144 | if case_insensitive: |
|
1144 | if case_insensitive: | |
1145 | q = q.where(func.lower(UserEmailMap.email) == func.lower(email)) |
|
1145 | q = q.where(func.lower(UserEmailMap.email) == func.lower(email)) | |
1146 | else: |
|
1146 | else: | |
1147 | q = q.where(UserEmailMap.email == email) |
|
1147 | q = q.where(UserEmailMap.email == email) | |
1148 | q = q.options(joinedload(UserEmailMap.user)) |
|
1148 | q = q.options(joinedload(UserEmailMap.user)) | |
1149 | if cache: |
|
1149 | if cache: | |
1150 | q = q.options( |
|
1150 | q = q.options( | |
1151 | FromCache("sql_cache_short", f"get_email_map_key_{email_key}")) |
|
1151 | FromCache("sql_cache_short", f"get_email_map_key_{email_key}")) | |
1152 |
|
1152 | |||
1153 | result = cls.execute(q).scalar_one_or_none() |
|
1153 | result = cls.execute(q).scalar_one_or_none() | |
1154 | ret = getattr(result, 'user', None) |
|
1154 | ret = getattr(result, 'user', None) | |
1155 |
|
1155 | |||
1156 | return ret |
|
1156 | return ret | |
1157 |
|
1157 | |||
1158 | @classmethod |
|
1158 | @classmethod | |
1159 | def get_from_cs_author(cls, author): |
|
1159 | def get_from_cs_author(cls, author): | |
1160 | """ |
|
1160 | """ | |
1161 | Tries to get User objects out of commit author string |
|
1161 | Tries to get User objects out of commit author string | |
1162 |
|
1162 | |||
1163 | :param author: |
|
1163 | :param author: | |
1164 | """ |
|
1164 | """ | |
1165 | from rhodecode.lib.helpers import email, author_name |
|
1165 | from rhodecode.lib.helpers import email, author_name | |
1166 | # Valid email in the attribute passed, see if they're in the system |
|
1166 | # Valid email in the attribute passed, see if they're in the system | |
1167 | _email = email(author) |
|
1167 | _email = email(author) | |
1168 | if _email: |
|
1168 | if _email: | |
1169 | user = cls.get_by_email(_email, case_insensitive=True) |
|
1169 | user = cls.get_by_email(_email, case_insensitive=True) | |
1170 | if user: |
|
1170 | if user: | |
1171 | return user |
|
1171 | return user | |
1172 | # Maybe we can match by username? |
|
1172 | # Maybe we can match by username? | |
1173 | _author = author_name(author) |
|
1173 | _author = author_name(author) | |
1174 | user = cls.get_by_username(_author, case_insensitive=True) |
|
1174 | user = cls.get_by_username(_author, case_insensitive=True) | |
1175 | if user: |
|
1175 | if user: | |
1176 | return user |
|
1176 | return user | |
1177 |
|
1177 | |||
1178 | def update_userdata(self, **kwargs): |
|
1178 | def update_userdata(self, **kwargs): | |
1179 | usr = self |
|
1179 | usr = self | |
1180 | old = usr.user_data |
|
1180 | old = usr.user_data | |
1181 | old.update(**kwargs) |
|
1181 | old.update(**kwargs) | |
1182 | usr.user_data = old |
|
1182 | usr.user_data = old | |
1183 | Session().add(usr) |
|
1183 | Session().add(usr) | |
1184 | log.debug('updated userdata with %s', kwargs) |
|
1184 | log.debug('updated userdata with %s', kwargs) | |
1185 |
|
1185 | |||
1186 | def update_lastlogin(self): |
|
1186 | def update_lastlogin(self): | |
1187 | """Update user lastlogin""" |
|
1187 | """Update user lastlogin""" | |
1188 | self.last_login = datetime.datetime.now() |
|
1188 | self.last_login = datetime.datetime.now() | |
1189 | Session().add(self) |
|
1189 | Session().add(self) | |
1190 | log.debug('updated user %s lastlogin', self.username) |
|
1190 | log.debug('updated user %s lastlogin', self.username) | |
1191 |
|
1191 | |||
1192 | def update_password(self, new_password): |
|
1192 | def update_password(self, new_password): | |
1193 | from rhodecode.lib.auth import get_crypt_password |
|
1193 | from rhodecode.lib.auth import get_crypt_password | |
1194 |
|
1194 | |||
1195 | self.password = get_crypt_password(new_password) |
|
1195 | self.password = get_crypt_password(new_password) | |
1196 | Session().add(self) |
|
1196 | Session().add(self) | |
1197 |
|
1197 | |||
1198 | @classmethod |
|
1198 | @classmethod | |
1199 | def get_first_super_admin(cls): |
|
1199 | def get_first_super_admin(cls): | |
1200 | stmt = cls.select().where(User.admin == true()).order_by(User.user_id.asc()) |
|
1200 | stmt = cls.select().where(User.admin == true()).order_by(User.user_id.asc()) | |
1201 | user = cls.scalars(stmt).first() |
|
1201 | user = cls.scalars(stmt).first() | |
1202 |
|
1202 | |||
1203 | if user is None: |
|
1203 | if user is None: | |
1204 | raise Exception('FATAL: Missing administrative account!') |
|
1204 | raise Exception('FATAL: Missing administrative account!') | |
1205 | return user |
|
1205 | return user | |
1206 |
|
1206 | |||
1207 | @classmethod |
|
1207 | @classmethod | |
1208 | def get_all_super_admins(cls, only_active=False): |
|
1208 | def get_all_super_admins(cls, only_active=False): | |
1209 | """ |
|
1209 | """ | |
1210 | Returns all admin accounts sorted by username |
|
1210 | Returns all admin accounts sorted by username | |
1211 | """ |
|
1211 | """ | |
1212 | qry = User.query().filter(User.admin == true()).order_by(User.username.asc()) |
|
1212 | qry = User.query().filter(User.admin == true()).order_by(User.username.asc()) | |
1213 | if only_active: |
|
1213 | if only_active: | |
1214 | qry = qry.filter(User.active == true()) |
|
1214 | qry = qry.filter(User.active == true()) | |
1215 | return qry.all() |
|
1215 | return qry.all() | |
1216 |
|
1216 | |||
1217 | @classmethod |
|
1217 | @classmethod | |
1218 | def get_all_user_ids(cls, only_active=True): |
|
1218 | def get_all_user_ids(cls, only_active=True): | |
1219 | """ |
|
1219 | """ | |
1220 | Returns all users IDs |
|
1220 | Returns all users IDs | |
1221 | """ |
|
1221 | """ | |
1222 | qry = Session().query(User.user_id) |
|
1222 | qry = Session().query(User.user_id) | |
1223 |
|
1223 | |||
1224 | if only_active: |
|
1224 | if only_active: | |
1225 | qry = qry.filter(User.active == true()) |
|
1225 | qry = qry.filter(User.active == true()) | |
1226 | return [x.user_id for x in qry] |
|
1226 | return [x.user_id for x in qry] | |
1227 |
|
1227 | |||
1228 | @classmethod |
|
1228 | @classmethod | |
1229 | def get_default_user(cls, cache=False, refresh=False): |
|
1229 | def get_default_user(cls, cache=False, refresh=False): | |
1230 | user = User.get_by_username(User.DEFAULT_USER, cache=cache) |
|
1230 | user = User.get_by_username(User.DEFAULT_USER, cache=cache) | |
1231 | if user is None: |
|
1231 | if user is None: | |
1232 | raise Exception('FATAL: Missing default account!') |
|
1232 | raise Exception('FATAL: Missing default account!') | |
1233 | if refresh: |
|
1233 | if refresh: | |
1234 | # The default user might be based on outdated state which |
|
1234 | # The default user might be based on outdated state which | |
1235 | # has been loaded from the cache. |
|
1235 | # has been loaded from the cache. | |
1236 | # A call to refresh() ensures that the |
|
1236 | # A call to refresh() ensures that the | |
1237 | # latest state from the database is used. |
|
1237 | # latest state from the database is used. | |
1238 | Session().refresh(user) |
|
1238 | Session().refresh(user) | |
1239 |
|
1239 | |||
1240 | return user |
|
1240 | return user | |
1241 |
|
1241 | |||
1242 | @classmethod |
|
1242 | @classmethod | |
1243 | def get_default_user_id(cls): |
|
1243 | def get_default_user_id(cls): | |
1244 | import rhodecode |
|
1244 | import rhodecode | |
1245 | return rhodecode.CONFIG['default_user_id'] |
|
1245 | return rhodecode.CONFIG['default_user_id'] | |
1246 |
|
1246 | |||
1247 | def _get_default_perms(self, user, suffix=''): |
|
1247 | def _get_default_perms(self, user, suffix=''): | |
1248 | from rhodecode.model.permission import PermissionModel |
|
1248 | from rhodecode.model.permission import PermissionModel | |
1249 | return PermissionModel().get_default_perms(user.user_perms, suffix) |
|
1249 | return PermissionModel().get_default_perms(user.user_perms, suffix) | |
1250 |
|
1250 | |||
1251 | def get_default_perms(self, suffix=''): |
|
1251 | def get_default_perms(self, suffix=''): | |
1252 | return self._get_default_perms(self, suffix) |
|
1252 | return self._get_default_perms(self, suffix) | |
1253 |
|
1253 | |||
1254 | def get_api_data(self, include_secrets=False, details='full'): |
|
1254 | def get_api_data(self, include_secrets=False, details='full'): | |
1255 | """ |
|
1255 | """ | |
1256 | Common function for generating user related data for API |
|
1256 | Common function for generating user related data for API | |
1257 |
|
1257 | |||
1258 | :param include_secrets: By default secrets in the API data will be replaced |
|
1258 | :param include_secrets: By default secrets in the API data will be replaced | |
1259 | by a placeholder value to prevent exposing this data by accident. In case |
|
1259 | by a placeholder value to prevent exposing this data by accident. In case | |
1260 | this data shall be exposed, set this flag to ``True``. |
|
1260 | this data shall be exposed, set this flag to ``True``. | |
1261 |
|
1261 | |||
1262 | :param details: details can be 'basic|full' basic gives only a subset of |
|
1262 | :param details: details can be 'basic|full' basic gives only a subset of | |
1263 | the available user information that includes user_id, name and emails. |
|
1263 | the available user information that includes user_id, name and emails. | |
1264 | """ |
|
1264 | """ | |
1265 | user = self |
|
1265 | user = self | |
1266 | user_data = self.user_data |
|
1266 | user_data = self.user_data | |
1267 | data = { |
|
1267 | data = { | |
1268 | 'user_id': user.user_id, |
|
1268 | 'user_id': user.user_id, | |
1269 | 'username': user.username, |
|
1269 | 'username': user.username, | |
1270 | 'firstname': user.name, |
|
1270 | 'firstname': user.name, | |
1271 | 'lastname': user.lastname, |
|
1271 | 'lastname': user.lastname, | |
1272 | 'description': user.description, |
|
1272 | 'description': user.description, | |
1273 | 'email': user.email, |
|
1273 | 'email': user.email, | |
1274 | 'emails': user.emails, |
|
1274 | 'emails': user.emails, | |
1275 | } |
|
1275 | } | |
1276 | if details == 'basic': |
|
1276 | if details == 'basic': | |
1277 | return data |
|
1277 | return data | |
1278 |
|
1278 | |||
1279 | auth_token_length = 40 |
|
1279 | auth_token_length = 40 | |
1280 | auth_token_replacement = '*' * auth_token_length |
|
1280 | auth_token_replacement = '*' * auth_token_length | |
1281 |
|
1281 | |||
1282 | extras = { |
|
1282 | extras = { | |
1283 | 'auth_tokens': [auth_token_replacement], |
|
1283 | 'auth_tokens': [auth_token_replacement], | |
1284 | 'active': user.active, |
|
1284 | 'active': user.active, | |
1285 | 'admin': user.admin, |
|
1285 | 'admin': user.admin, | |
1286 | 'extern_type': user.extern_type, |
|
1286 | 'extern_type': user.extern_type, | |
1287 | 'extern_name': user.extern_name, |
|
1287 | 'extern_name': user.extern_name, | |
1288 | 'last_login': user.last_login, |
|
1288 | 'last_login': user.last_login, | |
1289 | 'last_activity': user.last_activity, |
|
1289 | 'last_activity': user.last_activity, | |
1290 | 'ip_addresses': user.ip_addresses, |
|
1290 | 'ip_addresses': user.ip_addresses, | |
1291 | 'language': user_data.get('language') |
|
1291 | 'language': user_data.get('language') | |
1292 | } |
|
1292 | } | |
1293 | data.update(extras) |
|
1293 | data.update(extras) | |
1294 |
|
1294 | |||
1295 | if include_secrets: |
|
1295 | if include_secrets: | |
1296 | data['auth_tokens'] = user.auth_tokens |
|
1296 | data['auth_tokens'] = user.auth_tokens | |
1297 | return data |
|
1297 | return data | |
1298 |
|
1298 | |||
1299 | def __json__(self): |
|
1299 | def __json__(self): | |
1300 | data = { |
|
1300 | data = { | |
1301 | 'full_name': self.full_name, |
|
1301 | 'full_name': self.full_name, | |
1302 | 'full_name_or_username': self.full_name_or_username, |
|
1302 | 'full_name_or_username': self.full_name_or_username, | |
1303 | 'short_contact': self.short_contact, |
|
1303 | 'short_contact': self.short_contact, | |
1304 | 'full_contact': self.full_contact, |
|
1304 | 'full_contact': self.full_contact, | |
1305 | } |
|
1305 | } | |
1306 | data.update(self.get_api_data()) |
|
1306 | data.update(self.get_api_data()) | |
1307 | return data |
|
1307 | return data | |
1308 |
|
1308 | |||
1309 |
|
1309 | |||
1310 | class UserApiKeys(Base, BaseModel): |
|
1310 | class UserApiKeys(Base, BaseModel): | |
1311 | __tablename__ = 'user_api_keys' |
|
1311 | __tablename__ = 'user_api_keys' | |
1312 | __table_args__ = ( |
|
1312 | __table_args__ = ( | |
1313 | Index('uak_api_key_idx', 'api_key'), |
|
1313 | Index('uak_api_key_idx', 'api_key'), | |
1314 | Index('uak_api_key_expires_idx', 'api_key', 'expires'), |
|
1314 | Index('uak_api_key_expires_idx', 'api_key', 'expires'), | |
1315 | base_table_args |
|
1315 | base_table_args | |
1316 | ) |
|
1316 | ) | |
1317 |
|
1317 | |||
1318 | # ApiKey role |
|
1318 | # ApiKey role | |
1319 | ROLE_ALL = 'token_role_all' |
|
1319 | ROLE_ALL = 'token_role_all' | |
1320 | ROLE_VCS = 'token_role_vcs' |
|
1320 | ROLE_VCS = 'token_role_vcs' | |
1321 | ROLE_API = 'token_role_api' |
|
1321 | ROLE_API = 'token_role_api' | |
1322 | ROLE_HTTP = 'token_role_http' |
|
1322 | ROLE_HTTP = 'token_role_http' | |
1323 | ROLE_FEED = 'token_role_feed' |
|
1323 | ROLE_FEED = 'token_role_feed' | |
1324 | ROLE_ARTIFACT_DOWNLOAD = 'role_artifact_download' |
|
1324 | ROLE_ARTIFACT_DOWNLOAD = 'role_artifact_download' | |
1325 | # The last one is ignored in the list as we only |
|
1325 | # The last one is ignored in the list as we only | |
1326 | # use it for one action, and cannot be created by users |
|
1326 | # use it for one action, and cannot be created by users | |
1327 | ROLE_PASSWORD_RESET = 'token_password_reset' |
|
1327 | ROLE_PASSWORD_RESET = 'token_password_reset' | |
1328 |
|
1328 | |||
1329 | ROLES = [ROLE_ALL, ROLE_VCS, ROLE_API, ROLE_HTTP, ROLE_FEED, ROLE_ARTIFACT_DOWNLOAD] |
|
1329 | ROLES = [ROLE_ALL, ROLE_VCS, ROLE_API, ROLE_HTTP, ROLE_FEED, ROLE_ARTIFACT_DOWNLOAD] | |
1330 |
|
1330 | |||
1331 | user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
1331 | user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
1332 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) |
|
1332 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) | |
1333 | api_key = Column("api_key", String(255), nullable=False, unique=True) |
|
1333 | api_key = Column("api_key", String(255), nullable=False, unique=True) | |
1334 | description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql')) |
|
1334 | description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql')) | |
1335 | expires = Column('expires', Float(53), nullable=False) |
|
1335 | expires = Column('expires', Float(53), nullable=False) | |
1336 | role = Column('role', String(255), nullable=True) |
|
1336 | role = Column('role', String(255), nullable=True) | |
1337 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
1337 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
1338 |
|
1338 | |||
1339 | # scope columns |
|
1339 | # scope columns | |
1340 | repo_id = Column( |
|
1340 | repo_id = Column( | |
1341 | 'repo_id', Integer(), ForeignKey('repositories.repo_id'), |
|
1341 | 'repo_id', Integer(), ForeignKey('repositories.repo_id'), | |
1342 | nullable=True, unique=None, default=None) |
|
1342 | nullable=True, unique=None, default=None) | |
1343 | repo = relationship('Repository', lazy='joined', back_populates='scoped_tokens') |
|
1343 | repo = relationship('Repository', lazy='joined', back_populates='scoped_tokens') | |
1344 |
|
1344 | |||
1345 | repo_group_id = Column( |
|
1345 | repo_group_id = Column( | |
1346 | 'repo_group_id', Integer(), ForeignKey('groups.group_id'), |
|
1346 | 'repo_group_id', Integer(), ForeignKey('groups.group_id'), | |
1347 | nullable=True, unique=None, default=None) |
|
1347 | nullable=True, unique=None, default=None) | |
1348 | repo_group = relationship('RepoGroup', lazy='joined') |
|
1348 | repo_group = relationship('RepoGroup', lazy='joined') | |
1349 |
|
1349 | |||
1350 | user = relationship('User', lazy='joined', back_populates='user_auth_tokens') |
|
1350 | user = relationship('User', lazy='joined', back_populates='user_auth_tokens') | |
1351 |
|
1351 | |||
1352 | def __repr__(self): |
|
1352 | def __repr__(self): | |
1353 | return f"<{self.cls_name}('{self.role}')>" |
|
1353 | return f"<{self.cls_name}('{self.role}')>" | |
1354 |
|
1354 | |||
1355 | def __json__(self): |
|
1355 | def __json__(self): | |
1356 | data = { |
|
1356 | data = { | |
1357 | 'auth_token': self.api_key, |
|
1357 | 'auth_token': self.api_key, | |
1358 | 'role': self.role, |
|
1358 | 'role': self.role, | |
1359 | 'scope': self.scope_humanized, |
|
1359 | 'scope': self.scope_humanized, | |
1360 | 'expired': self.expired |
|
1360 | 'expired': self.expired | |
1361 | } |
|
1361 | } | |
1362 | return data |
|
1362 | return data | |
1363 |
|
1363 | |||
1364 | def get_api_data(self, include_secrets=False): |
|
1364 | def get_api_data(self, include_secrets=False): | |
1365 | data = self.__json__() |
|
1365 | data = self.__json__() | |
1366 | if include_secrets: |
|
1366 | if include_secrets: | |
1367 | return data |
|
1367 | return data | |
1368 | else: |
|
1368 | else: | |
1369 | data['auth_token'] = self.token_obfuscated |
|
1369 | data['auth_token'] = self.token_obfuscated | |
1370 | return data |
|
1370 | return data | |
1371 |
|
1371 | |||
1372 | @hybrid_property |
|
1372 | @hybrid_property | |
1373 | def description_safe(self): |
|
1373 | def description_safe(self): | |
1374 | return description_escaper(self.description) |
|
1374 | return description_escaper(self.description) | |
1375 |
|
1375 | |||
1376 | @property |
|
1376 | @property | |
1377 | def expired(self): |
|
1377 | def expired(self): | |
1378 | if self.expires == -1: |
|
1378 | if self.expires == -1: | |
1379 | return False |
|
1379 | return False | |
1380 | return time.time() > self.expires |
|
1380 | return time.time() > self.expires | |
1381 |
|
1381 | |||
1382 | @classmethod |
|
1382 | @classmethod | |
1383 | def _get_role_name(cls, role): |
|
1383 | def _get_role_name(cls, role): | |
1384 | return { |
|
1384 | return { | |
1385 | cls.ROLE_ALL: _('all'), |
|
1385 | cls.ROLE_ALL: _('all'), | |
1386 | cls.ROLE_HTTP: _('http/web interface'), |
|
1386 | cls.ROLE_HTTP: _('http/web interface'), | |
1387 | cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'), |
|
1387 | cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'), | |
1388 | cls.ROLE_API: _('api calls'), |
|
1388 | cls.ROLE_API: _('api calls'), | |
1389 | cls.ROLE_FEED: _('feed access'), |
|
1389 | cls.ROLE_FEED: _('feed access'), | |
1390 | cls.ROLE_ARTIFACT_DOWNLOAD: _('artifacts downloads'), |
|
1390 | cls.ROLE_ARTIFACT_DOWNLOAD: _('artifacts downloads'), | |
1391 | }.get(role, role) |
|
1391 | }.get(role, role) | |
1392 |
|
1392 | |||
1393 | @classmethod |
|
1393 | @classmethod | |
1394 | def _get_role_description(cls, role): |
|
1394 | def _get_role_description(cls, role): | |
1395 | return { |
|
1395 | return { | |
1396 | cls.ROLE_ALL: _('Token for all actions.'), |
|
1396 | cls.ROLE_ALL: _('Token for all actions.'), | |
1397 | cls.ROLE_HTTP: _('Token to access RhodeCode pages via web interface without ' |
|
1397 | cls.ROLE_HTTP: _('Token to access RhodeCode pages via web interface without ' | |
1398 | 'login using `api_access_controllers_whitelist` functionality.'), |
|
1398 | 'login using `api_access_controllers_whitelist` functionality.'), | |
1399 | cls.ROLE_VCS: _('Token to interact over git/hg/svn protocols. ' |
|
1399 | cls.ROLE_VCS: _('Token to interact over git/hg/svn protocols. ' | |
1400 | 'Requires auth_token authentication plugin to be active. <br/>' |
|
1400 | 'Requires auth_token authentication plugin to be active. <br/>' | |
1401 | 'Such Token should be used then instead of a password to ' |
|
1401 | 'Such Token should be used then instead of a password to ' | |
1402 | 'interact with a repository, and additionally can be ' |
|
1402 | 'interact with a repository, and additionally can be ' | |
1403 | 'limited to single repository using repo scope.'), |
|
1403 | 'limited to single repository using repo scope.'), | |
1404 | cls.ROLE_API: _('Token limited to api calls.'), |
|
1404 | cls.ROLE_API: _('Token limited to api calls.'), | |
1405 | cls.ROLE_FEED: _('Token to read RSS/ATOM feed.'), |
|
1405 | cls.ROLE_FEED: _('Token to read RSS/ATOM feed.'), | |
1406 | cls.ROLE_ARTIFACT_DOWNLOAD: _('Token for artifacts downloads.'), |
|
1406 | cls.ROLE_ARTIFACT_DOWNLOAD: _('Token for artifacts downloads.'), | |
1407 | }.get(role, role) |
|
1407 | }.get(role, role) | |
1408 |
|
1408 | |||
1409 | @property |
|
1409 | @property | |
1410 | def role_humanized(self): |
|
1410 | def role_humanized(self): | |
1411 | return self._get_role_name(self.role) |
|
1411 | return self._get_role_name(self.role) | |
1412 |
|
1412 | |||
1413 | def _get_scope(self): |
|
1413 | def _get_scope(self): | |
1414 | if self.repo: |
|
1414 | if self.repo: | |
1415 | return 'Repository: {}'.format(self.repo.repo_name) |
|
1415 | return 'Repository: {}'.format(self.repo.repo_name) | |
1416 | if self.repo_group: |
|
1416 | if self.repo_group: | |
1417 | return 'RepositoryGroup: {} (recursive)'.format(self.repo_group.group_name) |
|
1417 | return 'RepositoryGroup: {} (recursive)'.format(self.repo_group.group_name) | |
1418 | return 'Global' |
|
1418 | return 'Global' | |
1419 |
|
1419 | |||
1420 | @property |
|
1420 | @property | |
1421 | def scope_humanized(self): |
|
1421 | def scope_humanized(self): | |
1422 | return self._get_scope() |
|
1422 | return self._get_scope() | |
1423 |
|
1423 | |||
1424 | @property |
|
1424 | @property | |
1425 | def token_obfuscated(self): |
|
1425 | def token_obfuscated(self): | |
1426 | if self.api_key: |
|
1426 | if self.api_key: | |
1427 | return self.api_key[:4] + "****" |
|
1427 | return self.api_key[:4] + "****" | |
1428 |
|
1428 | |||
1429 |
|
1429 | |||
1430 | class UserEmailMap(Base, BaseModel): |
|
1430 | class UserEmailMap(Base, BaseModel): | |
1431 | __tablename__ = 'user_email_map' |
|
1431 | __tablename__ = 'user_email_map' | |
1432 | __table_args__ = ( |
|
1432 | __table_args__ = ( | |
1433 | Index('uem_email_idx', 'email'), |
|
1433 | Index('uem_email_idx', 'email'), | |
1434 | Index('uem_user_id_idx', 'user_id'), |
|
1434 | Index('uem_user_id_idx', 'user_id'), | |
1435 | UniqueConstraint('email'), |
|
1435 | UniqueConstraint('email'), | |
1436 | base_table_args |
|
1436 | base_table_args | |
1437 | ) |
|
1437 | ) | |
1438 |
|
1438 | |||
1439 | email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
1439 | email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
1440 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) |
|
1440 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) | |
1441 | _email = Column("email", String(255), nullable=True, unique=False, default=None) |
|
1441 | _email = Column("email", String(255), nullable=True, unique=False, default=None) | |
1442 | user = relationship('User', lazy='joined', back_populates='user_emails') |
|
1442 | user = relationship('User', lazy='joined', back_populates='user_emails') | |
1443 |
|
1443 | |||
1444 | @validates('_email') |
|
1444 | @validates('_email') | |
1445 | def validate_email(self, key, email): |
|
1445 | def validate_email(self, key, email): | |
1446 | # check if this email is not main one |
|
1446 | # check if this email is not main one | |
1447 | main_email = Session().query(User).filter(User.email == email).scalar() |
|
1447 | main_email = Session().query(User).filter(User.email == email).scalar() | |
1448 | if main_email is not None: |
|
1448 | if main_email is not None: | |
1449 | raise AttributeError('email %s is present is user table' % email) |
|
1449 | raise AttributeError('email %s is present is user table' % email) | |
1450 | return email |
|
1450 | return email | |
1451 |
|
1451 | |||
1452 | @hybrid_property |
|
1452 | @hybrid_property | |
1453 | def email(self): |
|
1453 | def email(self): | |
1454 | return self._email |
|
1454 | return self._email | |
1455 |
|
1455 | |||
1456 | @email.setter |
|
1456 | @email.setter | |
1457 | def email(self, val): |
|
1457 | def email(self, val): | |
1458 | self._email = val.lower() if val else None |
|
1458 | self._email = val.lower() if val else None | |
1459 |
|
1459 | |||
1460 |
|
1460 | |||
1461 | class UserIpMap(Base, BaseModel): |
|
1461 | class UserIpMap(Base, BaseModel): | |
1462 | __tablename__ = 'user_ip_map' |
|
1462 | __tablename__ = 'user_ip_map' | |
1463 | __table_args__ = ( |
|
1463 | __table_args__ = ( | |
1464 | UniqueConstraint('user_id', 'ip_addr'), |
|
1464 | UniqueConstraint('user_id', 'ip_addr'), | |
1465 | base_table_args |
|
1465 | base_table_args | |
1466 | ) |
|
1466 | ) | |
1467 |
|
1467 | |||
1468 | ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
1468 | ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
1469 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) |
|
1469 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) | |
1470 | ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None) |
|
1470 | ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None) | |
1471 | active = Column("active", Boolean(), nullable=True, unique=None, default=True) |
|
1471 | active = Column("active", Boolean(), nullable=True, unique=None, default=True) | |
1472 | description = Column("description", String(10000), nullable=True, unique=None, default=None) |
|
1472 | description = Column("description", String(10000), nullable=True, unique=None, default=None) | |
1473 | user = relationship('User', lazy='joined', back_populates='user_ip_map') |
|
1473 | user = relationship('User', lazy='joined', back_populates='user_ip_map') | |
1474 |
|
1474 | |||
1475 | @hybrid_property |
|
1475 | @hybrid_property | |
1476 | def description_safe(self): |
|
1476 | def description_safe(self): | |
1477 | return description_escaper(self.description) |
|
1477 | return description_escaper(self.description) | |
1478 |
|
1478 | |||
1479 | @classmethod |
|
1479 | @classmethod | |
1480 | def _get_ip_range(cls, ip_addr): |
|
1480 | def _get_ip_range(cls, ip_addr): | |
1481 | net = ipaddress.ip_network(safe_str(ip_addr), strict=False) |
|
1481 | net = ipaddress.ip_network(safe_str(ip_addr), strict=False) | |
1482 | return [str(net.network_address), str(net.broadcast_address)] |
|
1482 | return [str(net.network_address), str(net.broadcast_address)] | |
1483 |
|
1483 | |||
1484 | def __json__(self): |
|
1484 | def __json__(self): | |
1485 | return { |
|
1485 | return { | |
1486 | 'ip_addr': self.ip_addr, |
|
1486 | 'ip_addr': self.ip_addr, | |
1487 | 'ip_range': self._get_ip_range(self.ip_addr), |
|
1487 | 'ip_range': self._get_ip_range(self.ip_addr), | |
1488 | } |
|
1488 | } | |
1489 |
|
1489 | |||
1490 | def __repr__(self): |
|
1490 | def __repr__(self): | |
1491 | return f"<{self.cls_name}('user_id={self.user_id} => ip={self.ip_addr}')>" |
|
1491 | return f"<{self.cls_name}('user_id={self.user_id} => ip={self.ip_addr}')>" | |
1492 |
|
1492 | |||
1493 |
|
1493 | |||
1494 | class UserSshKeys(Base, BaseModel): |
|
1494 | class UserSshKeys(Base, BaseModel): | |
1495 | __tablename__ = 'user_ssh_keys' |
|
1495 | __tablename__ = 'user_ssh_keys' | |
1496 | __table_args__ = ( |
|
1496 | __table_args__ = ( | |
1497 | Index('usk_ssh_key_fingerprint_idx', 'ssh_key_fingerprint'), |
|
1497 | Index('usk_ssh_key_fingerprint_idx', 'ssh_key_fingerprint'), | |
1498 |
|
1498 | |||
1499 | UniqueConstraint('ssh_key_fingerprint'), |
|
1499 | UniqueConstraint('ssh_key_fingerprint'), | |
1500 |
|
1500 | |||
1501 | base_table_args |
|
1501 | base_table_args | |
1502 | ) |
|
1502 | ) | |
1503 |
|
1503 | |||
1504 | ssh_key_id = Column('ssh_key_id', Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
1504 | ssh_key_id = Column('ssh_key_id', Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
1505 | ssh_key_data = Column('ssh_key_data', String(10240), nullable=False, unique=None, default=None) |
|
1505 | ssh_key_data = Column('ssh_key_data', String(10240), nullable=False, unique=None, default=None) | |
1506 | ssh_key_fingerprint = Column('ssh_key_fingerprint', String(255), nullable=False, unique=None, default=None) |
|
1506 | ssh_key_fingerprint = Column('ssh_key_fingerprint', String(255), nullable=False, unique=None, default=None) | |
1507 |
|
1507 | |||
1508 | description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql')) |
|
1508 | description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql')) | |
1509 |
|
1509 | |||
1510 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
1510 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
1511 | accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True, default=None) |
|
1511 | accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True, default=None) | |
1512 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) |
|
1512 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) | |
1513 |
|
1513 | |||
1514 | user = relationship('User', lazy='joined', back_populates='user_ssh_keys') |
|
1514 | user = relationship('User', lazy='joined', back_populates='user_ssh_keys') | |
1515 |
|
1515 | |||
1516 | def __json__(self): |
|
1516 | def __json__(self): | |
1517 | data = { |
|
1517 | data = { | |
1518 | 'ssh_fingerprint': self.ssh_key_fingerprint, |
|
1518 | 'ssh_fingerprint': self.ssh_key_fingerprint, | |
1519 | 'description': self.description, |
|
1519 | 'description': self.description, | |
1520 | 'created_on': self.created_on |
|
1520 | 'created_on': self.created_on | |
1521 | } |
|
1521 | } | |
1522 | return data |
|
1522 | return data | |
1523 |
|
1523 | |||
1524 | def get_api_data(self): |
|
1524 | def get_api_data(self): | |
1525 | data = self.__json__() |
|
1525 | data = self.__json__() | |
1526 | return data |
|
1526 | return data | |
1527 |
|
1527 | |||
1528 |
|
1528 | |||
1529 | class UserLog(Base, BaseModel): |
|
1529 | class UserLog(Base, BaseModel): | |
1530 | __tablename__ = 'user_logs' |
|
1530 | __tablename__ = 'user_logs' | |
1531 | __table_args__ = ( |
|
1531 | __table_args__ = ( | |
1532 | base_table_args, |
|
1532 | base_table_args, | |
1533 | ) |
|
1533 | ) | |
1534 |
|
1534 | |||
1535 | VERSION_1 = 'v1' |
|
1535 | VERSION_1 = 'v1' | |
1536 | VERSION_2 = 'v2' |
|
1536 | VERSION_2 = 'v2' | |
1537 | VERSIONS = [VERSION_1, VERSION_2] |
|
1537 | VERSIONS = [VERSION_1, VERSION_2] | |
1538 |
|
1538 | |||
1539 | user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
1539 | user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
1540 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id',ondelete='SET NULL'), nullable=True, unique=None, default=None) |
|
1540 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id',ondelete='SET NULL'), nullable=True, unique=None, default=None) | |
1541 | username = Column("username", String(255), nullable=True, unique=None, default=None) |
|
1541 | username = Column("username", String(255), nullable=True, unique=None, default=None) | |
1542 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id', ondelete='SET NULL'), nullable=True, unique=None, default=None) |
|
1542 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id', ondelete='SET NULL'), nullable=True, unique=None, default=None) | |
1543 | repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None) |
|
1543 | repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None) | |
1544 | user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None) |
|
1544 | user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None) | |
1545 | action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None) |
|
1545 | action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None) | |
1546 | action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None) |
|
1546 | action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None) | |
1547 |
|
1547 | |||
1548 | version = Column("version", String(255), nullable=True, default=VERSION_1) |
|
1548 | version = Column("version", String(255), nullable=True, default=VERSION_1) | |
1549 | user_data = Column('user_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT())))) |
|
1549 | user_data = Column('user_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT())))) | |
1550 | action_data = Column('action_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT())))) |
|
1550 | action_data = Column('action_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT())))) | |
1551 | user = relationship('User', cascade='', back_populates='user_log') |
|
1551 | user = relationship('User', cascade='', back_populates='user_log') | |
1552 | repository = relationship('Repository', cascade='', back_populates='logs') |
|
1552 | repository = relationship('Repository', cascade='', back_populates='logs') | |
1553 |
|
1553 | |||
1554 | def __repr__(self): |
|
1554 | def __repr__(self): | |
1555 | return f"<{self.cls_name}('id:{self.repository_name}:{self.action}')>" |
|
1555 | return f"<{self.cls_name}('id:{self.repository_name}:{self.action}')>" | |
1556 |
|
1556 | |||
1557 | def __json__(self): |
|
1557 | def __json__(self): | |
1558 | return { |
|
1558 | return { | |
1559 | 'user_id': self.user_id, |
|
1559 | 'user_id': self.user_id, | |
1560 | 'username': self.username, |
|
1560 | 'username': self.username, | |
1561 | 'repository_id': self.repository_id, |
|
1561 | 'repository_id': self.repository_id, | |
1562 | 'repository_name': self.repository_name, |
|
1562 | 'repository_name': self.repository_name, | |
1563 | 'user_ip': self.user_ip, |
|
1563 | 'user_ip': self.user_ip, | |
1564 | 'action_date': self.action_date, |
|
1564 | 'action_date': self.action_date, | |
1565 | 'action': self.action, |
|
1565 | 'action': self.action, | |
1566 | } |
|
1566 | } | |
1567 |
|
1567 | |||
1568 | @hybrid_property |
|
1568 | @hybrid_property | |
1569 | def entry_id(self): |
|
1569 | def entry_id(self): | |
1570 | return self.user_log_id |
|
1570 | return self.user_log_id | |
1571 |
|
1571 | |||
1572 | @property |
|
1572 | @property | |
1573 | def action_as_day(self): |
|
1573 | def action_as_day(self): | |
1574 | return datetime.date(*self.action_date.timetuple()[:3]) |
|
1574 | return datetime.date(*self.action_date.timetuple()[:3]) | |
1575 |
|
1575 | |||
1576 |
|
1576 | |||
1577 | class UserGroup(Base, BaseModel): |
|
1577 | class UserGroup(Base, BaseModel): | |
1578 | __tablename__ = 'users_groups' |
|
1578 | __tablename__ = 'users_groups' | |
1579 | __table_args__ = ( |
|
1579 | __table_args__ = ( | |
1580 | base_table_args, |
|
1580 | base_table_args, | |
1581 | ) |
|
1581 | ) | |
1582 |
|
1582 | |||
1583 | users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
1583 | users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
1584 | users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None) |
|
1584 | users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None) | |
1585 | user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None) |
|
1585 | user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None) | |
1586 | users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None) |
|
1586 | users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None) | |
1587 | inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True) |
|
1587 | inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True) | |
1588 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None) |
|
1588 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None) | |
1589 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
1589 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
1590 | _group_data = Column("group_data", LargeBinary(), nullable=True) # JSON data |
|
1590 | _group_data = Column("group_data", LargeBinary(), nullable=True) # JSON data | |
1591 |
|
1591 | |||
1592 | members = relationship('UserGroupMember', cascade="all, delete-orphan", lazy="joined", back_populates='users_group') |
|
1592 | members = relationship('UserGroupMember', cascade="all, delete-orphan", lazy="joined", back_populates='users_group') | |
1593 | users_group_to_perm = relationship('UserGroupToPerm', cascade='all', back_populates='users_group') |
|
1593 | users_group_to_perm = relationship('UserGroupToPerm', cascade='all', back_populates='users_group') | |
1594 | users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all', back_populates='users_group') |
|
1594 | users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all', back_populates='users_group') | |
1595 | users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all', back_populates='users_group') |
|
1595 | users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all', back_populates='users_group') | |
1596 | user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all', back_populates='user_group') |
|
1596 | user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all', back_populates='user_group') | |
1597 |
|
1597 | |||
1598 | user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all', back_populates='target_user_group') |
|
1598 | user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all', back_populates='target_user_group') | |
1599 |
|
1599 | |||
1600 | user_group_review_rules = relationship('RepoReviewRuleUserGroup', cascade='all', back_populates='users_group') |
|
1600 | user_group_review_rules = relationship('RepoReviewRuleUserGroup', cascade='all', back_populates='users_group') | |
1601 | user = relationship('User', primaryjoin="User.user_id==UserGroup.user_id", back_populates='user_groups') |
|
1601 | user = relationship('User', primaryjoin="User.user_id==UserGroup.user_id", back_populates='user_groups') | |
1602 |
|
1602 | |||
1603 | @classmethod |
|
1603 | @classmethod | |
1604 | def _load_group_data(cls, column): |
|
1604 | def _load_group_data(cls, column): | |
1605 | if not column: |
|
1605 | if not column: | |
1606 | return {} |
|
1606 | return {} | |
1607 |
|
1607 | |||
1608 | try: |
|
1608 | try: | |
1609 | return json.loads(column) or {} |
|
1609 | return json.loads(column) or {} | |
1610 | except TypeError: |
|
1610 | except TypeError: | |
1611 | return {} |
|
1611 | return {} | |
1612 |
|
1612 | |||
1613 | @hybrid_property |
|
1613 | @hybrid_property | |
1614 | def description_safe(self): |
|
1614 | def description_safe(self): | |
1615 | return description_escaper(self.user_group_description) |
|
1615 | return description_escaper(self.user_group_description) | |
1616 |
|
1616 | |||
1617 | @hybrid_property |
|
1617 | @hybrid_property | |
1618 | def group_data(self): |
|
1618 | def group_data(self): | |
1619 | return self._load_group_data(self._group_data) |
|
1619 | return self._load_group_data(self._group_data) | |
1620 |
|
1620 | |||
1621 | @group_data.expression |
|
1621 | @group_data.expression | |
1622 | def group_data(self, **kwargs): |
|
1622 | def group_data(self, **kwargs): | |
1623 | return self._group_data |
|
1623 | return self._group_data | |
1624 |
|
1624 | |||
1625 | @group_data.setter |
|
1625 | @group_data.setter | |
1626 | def group_data(self, val): |
|
1626 | def group_data(self, val): | |
1627 | try: |
|
1627 | try: | |
1628 | self._group_data = json.dumps(val) |
|
1628 | self._group_data = json.dumps(val) | |
1629 | except Exception: |
|
1629 | except Exception: | |
1630 | log.error(traceback.format_exc()) |
|
1630 | log.error(traceback.format_exc()) | |
1631 |
|
1631 | |||
1632 | @classmethod |
|
1632 | @classmethod | |
1633 | def _load_sync(cls, group_data): |
|
1633 | def _load_sync(cls, group_data): | |
1634 | if group_data: |
|
1634 | if group_data: | |
1635 | return group_data.get('extern_type') |
|
1635 | return group_data.get('extern_type') | |
1636 |
|
1636 | |||
1637 | @property |
|
1637 | @property | |
1638 | def sync(self): |
|
1638 | def sync(self): | |
1639 | return self._load_sync(self.group_data) |
|
1639 | return self._load_sync(self.group_data) | |
1640 |
|
1640 | |||
1641 | def __repr__(self): |
|
1641 | def __repr__(self): | |
1642 | return f"<{self.cls_name}('id:{self.users_group_id}:{self.users_group_name}')>" |
|
1642 | return f"<{self.cls_name}('id:{self.users_group_id}:{self.users_group_name}')>" | |
1643 |
|
1643 | |||
1644 | @classmethod |
|
1644 | @classmethod | |
1645 | def get_by_group_name(cls, group_name, cache=False, |
|
1645 | def get_by_group_name(cls, group_name, cache=False, | |
1646 | case_insensitive=False): |
|
1646 | case_insensitive=False): | |
1647 | if case_insensitive: |
|
1647 | if case_insensitive: | |
1648 | q = cls.query().filter(func.lower(cls.users_group_name) == |
|
1648 | q = cls.query().filter(func.lower(cls.users_group_name) == | |
1649 | func.lower(group_name)) |
|
1649 | func.lower(group_name)) | |
1650 |
|
1650 | |||
1651 | else: |
|
1651 | else: | |
1652 | q = cls.query().filter(cls.users_group_name == group_name) |
|
1652 | q = cls.query().filter(cls.users_group_name == group_name) | |
1653 | if cache: |
|
1653 | if cache: | |
1654 | name_key = _hash_key(group_name) |
|
1654 | name_key = _hash_key(group_name) | |
1655 | q = q.options( |
|
1655 | q = q.options( | |
1656 | FromCache("sql_cache_short", f"get_group_{name_key}")) |
|
1656 | FromCache("sql_cache_short", f"get_group_{name_key}")) | |
1657 | return q.scalar() |
|
1657 | return q.scalar() | |
1658 |
|
1658 | |||
1659 | @classmethod |
|
1659 | @classmethod | |
1660 | def get(cls, user_group_id, cache=False): |
|
1660 | def get(cls, user_group_id, cache=False): | |
1661 | if not user_group_id: |
|
1661 | if not user_group_id: | |
1662 | return |
|
1662 | return | |
1663 |
|
1663 | |||
1664 | user_group = cls.query() |
|
1664 | user_group = cls.query() | |
1665 | if cache: |
|
1665 | if cache: | |
1666 | user_group = user_group.options( |
|
1666 | user_group = user_group.options( | |
1667 | FromCache("sql_cache_short", f"get_users_group_{user_group_id}")) |
|
1667 | FromCache("sql_cache_short", f"get_users_group_{user_group_id}")) | |
1668 | return user_group.get(user_group_id) |
|
1668 | return user_group.get(user_group_id) | |
1669 |
|
1669 | |||
1670 | def permissions(self, with_admins=True, with_owner=True, |
|
1670 | def permissions(self, with_admins=True, with_owner=True, | |
1671 | expand_from_user_groups=False): |
|
1671 | expand_from_user_groups=False): | |
1672 | """ |
|
1672 | """ | |
1673 | Permissions for user groups |
|
1673 | Permissions for user groups | |
1674 | """ |
|
1674 | """ | |
1675 | _admin_perm = 'usergroup.admin' |
|
1675 | _admin_perm = 'usergroup.admin' | |
1676 |
|
1676 | |||
1677 | owner_row = [] |
|
1677 | owner_row = [] | |
1678 | if with_owner: |
|
1678 | if with_owner: | |
1679 | usr = AttributeDict(self.user.get_dict()) |
|
1679 | usr = AttributeDict(self.user.get_dict()) | |
1680 | usr.owner_row = True |
|
1680 | usr.owner_row = True | |
1681 | usr.permission = _admin_perm |
|
1681 | usr.permission = _admin_perm | |
1682 | owner_row.append(usr) |
|
1682 | owner_row.append(usr) | |
1683 |
|
1683 | |||
1684 | super_admin_ids = [] |
|
1684 | super_admin_ids = [] | |
1685 | super_admin_rows = [] |
|
1685 | super_admin_rows = [] | |
1686 | if with_admins: |
|
1686 | if with_admins: | |
1687 | for usr in User.get_all_super_admins(): |
|
1687 | for usr in User.get_all_super_admins(): | |
1688 | super_admin_ids.append(usr.user_id) |
|
1688 | super_admin_ids.append(usr.user_id) | |
1689 | # if this admin is also owner, don't double the record |
|
1689 | # if this admin is also owner, don't double the record | |
1690 | if usr.user_id == owner_row[0].user_id: |
|
1690 | if usr.user_id == owner_row[0].user_id: | |
1691 | owner_row[0].admin_row = True |
|
1691 | owner_row[0].admin_row = True | |
1692 | else: |
|
1692 | else: | |
1693 | usr = AttributeDict(usr.get_dict()) |
|
1693 | usr = AttributeDict(usr.get_dict()) | |
1694 | usr.admin_row = True |
|
1694 | usr.admin_row = True | |
1695 | usr.permission = _admin_perm |
|
1695 | usr.permission = _admin_perm | |
1696 | super_admin_rows.append(usr) |
|
1696 | super_admin_rows.append(usr) | |
1697 |
|
1697 | |||
1698 | q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self) |
|
1698 | q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self) | |
1699 | q = q.options(joinedload(UserUserGroupToPerm.user_group), |
|
1699 | q = q.options(joinedload(UserUserGroupToPerm.user_group), | |
1700 | joinedload(UserUserGroupToPerm.user), |
|
1700 | joinedload(UserUserGroupToPerm.user), | |
1701 | joinedload(UserUserGroupToPerm.permission),) |
|
1701 | joinedload(UserUserGroupToPerm.permission),) | |
1702 |
|
1702 | |||
1703 | # get owners and admins and permissions. We do a trick of re-writing |
|
1703 | # get owners and admins and permissions. We do a trick of re-writing | |
1704 | # objects from sqlalchemy to named-tuples due to sqlalchemy session |
|
1704 | # objects from sqlalchemy to named-tuples due to sqlalchemy session | |
1705 | # has a global reference and changing one object propagates to all |
|
1705 | # has a global reference and changing one object propagates to all | |
1706 | # others. This means if admin is also an owner admin_row that change |
|
1706 | # others. This means if admin is also an owner admin_row that change | |
1707 | # would propagate to both objects |
|
1707 | # would propagate to both objects | |
1708 | perm_rows = [] |
|
1708 | perm_rows = [] | |
1709 | for _usr in q.all(): |
|
1709 | for _usr in q.all(): | |
1710 | usr = AttributeDict(_usr.user.get_dict()) |
|
1710 | usr = AttributeDict(_usr.user.get_dict()) | |
1711 | # if this user is also owner/admin, mark as duplicate record |
|
1711 | # if this user is also owner/admin, mark as duplicate record | |
1712 | if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids: |
|
1712 | if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids: | |
1713 | usr.duplicate_perm = True |
|
1713 | usr.duplicate_perm = True | |
1714 | usr.permission = _usr.permission.permission_name |
|
1714 | usr.permission = _usr.permission.permission_name | |
1715 | perm_rows.append(usr) |
|
1715 | perm_rows.append(usr) | |
1716 |
|
1716 | |||
1717 | # filter the perm rows by 'default' first and then sort them by |
|
1717 | # filter the perm rows by 'default' first and then sort them by | |
1718 | # admin,write,read,none permissions sorted again alphabetically in |
|
1718 | # admin,write,read,none permissions sorted again alphabetically in | |
1719 | # each group |
|
1719 | # each group | |
1720 | perm_rows = sorted(perm_rows, key=display_user_sort) |
|
1720 | perm_rows = sorted(perm_rows, key=display_user_sort) | |
1721 |
|
1721 | |||
1722 | user_groups_rows = [] |
|
1722 | user_groups_rows = [] | |
1723 | if expand_from_user_groups: |
|
1723 | if expand_from_user_groups: | |
1724 | for ug in self.permission_user_groups(with_members=True): |
|
1724 | for ug in self.permission_user_groups(with_members=True): | |
1725 | for user_data in ug.members: |
|
1725 | for user_data in ug.members: | |
1726 | user_groups_rows.append(user_data) |
|
1726 | user_groups_rows.append(user_data) | |
1727 |
|
1727 | |||
1728 | return super_admin_rows + owner_row + perm_rows + user_groups_rows |
|
1728 | return super_admin_rows + owner_row + perm_rows + user_groups_rows | |
1729 |
|
1729 | |||
1730 | def permission_user_groups(self, with_members=False): |
|
1730 | def permission_user_groups(self, with_members=False): | |
1731 | q = UserGroupUserGroupToPerm.query()\ |
|
1731 | q = UserGroupUserGroupToPerm.query()\ | |
1732 | .filter(UserGroupUserGroupToPerm.target_user_group == self) |
|
1732 | .filter(UserGroupUserGroupToPerm.target_user_group == self) | |
1733 | q = q.options(joinedload(UserGroupUserGroupToPerm.user_group), |
|
1733 | q = q.options(joinedload(UserGroupUserGroupToPerm.user_group), | |
1734 | joinedload(UserGroupUserGroupToPerm.target_user_group), |
|
1734 | joinedload(UserGroupUserGroupToPerm.target_user_group), | |
1735 | joinedload(UserGroupUserGroupToPerm.permission),) |
|
1735 | joinedload(UserGroupUserGroupToPerm.permission),) | |
1736 |
|
1736 | |||
1737 | perm_rows = [] |
|
1737 | perm_rows = [] | |
1738 | for _user_group in q.all(): |
|
1738 | for _user_group in q.all(): | |
1739 | entry = AttributeDict(_user_group.user_group.get_dict()) |
|
1739 | entry = AttributeDict(_user_group.user_group.get_dict()) | |
1740 | entry.permission = _user_group.permission.permission_name |
|
1740 | entry.permission = _user_group.permission.permission_name | |
1741 | if with_members: |
|
1741 | if with_members: | |
1742 | entry.members = [x.user.get_dict() |
|
1742 | entry.members = [x.user.get_dict() | |
1743 | for x in _user_group.user_group.members] |
|
1743 | for x in _user_group.user_group.members] | |
1744 | perm_rows.append(entry) |
|
1744 | perm_rows.append(entry) | |
1745 |
|
1745 | |||
1746 | perm_rows = sorted(perm_rows, key=display_user_group_sort) |
|
1746 | perm_rows = sorted(perm_rows, key=display_user_group_sort) | |
1747 | return perm_rows |
|
1747 | return perm_rows | |
1748 |
|
1748 | |||
1749 | def _get_default_perms(self, user_group, suffix=''): |
|
1749 | def _get_default_perms(self, user_group, suffix=''): | |
1750 | from rhodecode.model.permission import PermissionModel |
|
1750 | from rhodecode.model.permission import PermissionModel | |
1751 | return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix) |
|
1751 | return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix) | |
1752 |
|
1752 | |||
1753 | def get_default_perms(self, suffix=''): |
|
1753 | def get_default_perms(self, suffix=''): | |
1754 | return self._get_default_perms(self, suffix) |
|
1754 | return self._get_default_perms(self, suffix) | |
1755 |
|
1755 | |||
1756 | def get_api_data(self, with_group_members=True, include_secrets=False): |
|
1756 | def get_api_data(self, with_group_members=True, include_secrets=False): | |
1757 | """ |
|
1757 | """ | |
1758 | :param include_secrets: See :meth:`User.get_api_data`, this parameter is |
|
1758 | :param include_secrets: See :meth:`User.get_api_data`, this parameter is | |
1759 | basically forwarded. |
|
1759 | basically forwarded. | |
1760 |
|
1760 | |||
1761 | """ |
|
1761 | """ | |
1762 | user_group = self |
|
1762 | user_group = self | |
1763 | data = { |
|
1763 | data = { | |
1764 | 'users_group_id': user_group.users_group_id, |
|
1764 | 'users_group_id': user_group.users_group_id, | |
1765 | 'group_name': user_group.users_group_name, |
|
1765 | 'group_name': user_group.users_group_name, | |
1766 | 'group_description': user_group.user_group_description, |
|
1766 | 'group_description': user_group.user_group_description, | |
1767 | 'active': user_group.users_group_active, |
|
1767 | 'active': user_group.users_group_active, | |
1768 | 'owner': user_group.user.username, |
|
1768 | 'owner': user_group.user.username, | |
1769 | 'sync': user_group.sync, |
|
1769 | 'sync': user_group.sync, | |
1770 | 'owner_email': user_group.user.email, |
|
1770 | 'owner_email': user_group.user.email, | |
1771 | } |
|
1771 | } | |
1772 |
|
1772 | |||
1773 | if with_group_members: |
|
1773 | if with_group_members: | |
1774 | users = [] |
|
1774 | users = [] | |
1775 | for user in user_group.members: |
|
1775 | for user in user_group.members: | |
1776 | user = user.user |
|
1776 | user = user.user | |
1777 | users.append(user.get_api_data(include_secrets=include_secrets)) |
|
1777 | users.append(user.get_api_data(include_secrets=include_secrets)) | |
1778 | data['users'] = users |
|
1778 | data['users'] = users | |
1779 |
|
1779 | |||
1780 | return data |
|
1780 | return data | |
1781 |
|
1781 | |||
1782 |
|
1782 | |||
1783 | class UserGroupMember(Base, BaseModel): |
|
1783 | class UserGroupMember(Base, BaseModel): | |
1784 | __tablename__ = 'users_groups_members' |
|
1784 | __tablename__ = 'users_groups_members' | |
1785 | __table_args__ = ( |
|
1785 | __table_args__ = ( | |
1786 | base_table_args, |
|
1786 | base_table_args, | |
1787 | ) |
|
1787 | ) | |
1788 |
|
1788 | |||
1789 | users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
1789 | users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
1790 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) |
|
1790 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
1791 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) |
|
1791 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
1792 |
|
1792 | |||
1793 | user = relationship('User', lazy='joined', back_populates='group_member') |
|
1793 | user = relationship('User', lazy='joined', back_populates='group_member') | |
1794 | users_group = relationship('UserGroup', back_populates='members') |
|
1794 | users_group = relationship('UserGroup', back_populates='members') | |
1795 |
|
1795 | |||
1796 | def __init__(self, gr_id='', u_id=''): |
|
1796 | def __init__(self, gr_id='', u_id=''): | |
1797 | self.users_group_id = gr_id |
|
1797 | self.users_group_id = gr_id | |
1798 | self.user_id = u_id |
|
1798 | self.user_id = u_id | |
1799 |
|
1799 | |||
1800 |
|
1800 | |||
1801 | class RepositoryField(Base, BaseModel): |
|
1801 | class RepositoryField(Base, BaseModel): | |
1802 | __tablename__ = 'repositories_fields' |
|
1802 | __tablename__ = 'repositories_fields' | |
1803 | __table_args__ = ( |
|
1803 | __table_args__ = ( | |
1804 | UniqueConstraint('repository_id', 'field_key'), # no-multi field |
|
1804 | UniqueConstraint('repository_id', 'field_key'), # no-multi field | |
1805 | base_table_args, |
|
1805 | base_table_args, | |
1806 | ) |
|
1806 | ) | |
1807 |
|
1807 | |||
1808 | PREFIX = 'ex_' # prefix used in form to not conflict with already existing fields |
|
1808 | PREFIX = 'ex_' # prefix used in form to not conflict with already existing fields | |
1809 |
|
1809 | |||
1810 | repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
1810 | repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
1811 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) |
|
1811 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) | |
1812 | field_key = Column("field_key", String(250)) |
|
1812 | field_key = Column("field_key", String(250)) | |
1813 | field_label = Column("field_label", String(1024), nullable=False) |
|
1813 | field_label = Column("field_label", String(1024), nullable=False) | |
1814 | field_value = Column("field_value", String(10000), nullable=False) |
|
1814 | field_value = Column("field_value", String(10000), nullable=False) | |
1815 | field_desc = Column("field_desc", String(1024), nullable=False) |
|
1815 | field_desc = Column("field_desc", String(1024), nullable=False) | |
1816 | field_type = Column("field_type", String(255), nullable=False, unique=None) |
|
1816 | field_type = Column("field_type", String(255), nullable=False, unique=None) | |
1817 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
1817 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
1818 |
|
1818 | |||
1819 | repository = relationship('Repository', back_populates='extra_fields') |
|
1819 | repository = relationship('Repository', back_populates='extra_fields') | |
1820 |
|
1820 | |||
1821 | @property |
|
1821 | @property | |
1822 | def field_key_prefixed(self): |
|
1822 | def field_key_prefixed(self): | |
1823 | return 'ex_%s' % self.field_key |
|
1823 | return 'ex_%s' % self.field_key | |
1824 |
|
1824 | |||
1825 | @classmethod |
|
1825 | @classmethod | |
1826 | def un_prefix_key(cls, key): |
|
1826 | def un_prefix_key(cls, key): | |
1827 | if key.startswith(cls.PREFIX): |
|
1827 | if key.startswith(cls.PREFIX): | |
1828 | return key[len(cls.PREFIX):] |
|
1828 | return key[len(cls.PREFIX):] | |
1829 | return key |
|
1829 | return key | |
1830 |
|
1830 | |||
1831 | @classmethod |
|
1831 | @classmethod | |
1832 | def get_by_key_name(cls, key, repo): |
|
1832 | def get_by_key_name(cls, key, repo): | |
1833 | row = cls.query()\ |
|
1833 | row = cls.query()\ | |
1834 | .filter(cls.repository == repo)\ |
|
1834 | .filter(cls.repository == repo)\ | |
1835 | .filter(cls.field_key == key).scalar() |
|
1835 | .filter(cls.field_key == key).scalar() | |
1836 | return row |
|
1836 | return row | |
1837 |
|
1837 | |||
1838 |
|
1838 | |||
1839 | class Repository(Base, BaseModel): |
|
1839 | class Repository(Base, BaseModel): | |
1840 | __tablename__ = 'repositories' |
|
1840 | __tablename__ = 'repositories' | |
1841 | __table_args__ = ( |
|
1841 | __table_args__ = ( | |
1842 | Index('r_repo_name_idx', 'repo_name', mysql_length=255), |
|
1842 | Index('r_repo_name_idx', 'repo_name', mysql_length=255), | |
1843 | base_table_args, |
|
1843 | base_table_args, | |
1844 | ) |
|
1844 | ) | |
1845 | DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}' |
|
1845 | DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}' | |
1846 | DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}' |
|
1846 | DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}' | |
1847 | DEFAULT_CLONE_URI_SSH = 'ssh://{sys_user}@{hostname}/{repo}' |
|
1847 | DEFAULT_CLONE_URI_SSH = 'ssh://{sys_user}@{hostname}/{repo}' | |
1848 |
|
1848 | |||
1849 | STATE_CREATED = 'repo_state_created' |
|
1849 | STATE_CREATED = 'repo_state_created' | |
1850 | STATE_PENDING = 'repo_state_pending' |
|
1850 | STATE_PENDING = 'repo_state_pending' | |
1851 | STATE_ERROR = 'repo_state_error' |
|
1851 | STATE_ERROR = 'repo_state_error' | |
1852 |
|
1852 | |||
1853 | LOCK_AUTOMATIC = 'lock_auto' |
|
1853 | LOCK_AUTOMATIC = 'lock_auto' | |
1854 | LOCK_API = 'lock_api' |
|
1854 | LOCK_API = 'lock_api' | |
1855 | LOCK_WEB = 'lock_web' |
|
1855 | LOCK_WEB = 'lock_web' | |
1856 | LOCK_PULL = 'lock_pull' |
|
1856 | LOCK_PULL = 'lock_pull' | |
1857 |
|
1857 | |||
1858 | NAME_SEP = URL_SEP |
|
1858 | NAME_SEP = URL_SEP | |
1859 |
|
1859 | |||
1860 | repo_id = Column( |
|
1860 | repo_id = Column( | |
1861 | "repo_id", Integer(), nullable=False, unique=True, default=None, |
|
1861 | "repo_id", Integer(), nullable=False, unique=True, default=None, | |
1862 | primary_key=True) |
|
1862 | primary_key=True) | |
1863 | _repo_name = Column( |
|
1863 | _repo_name = Column( | |
1864 | "repo_name", Text(), nullable=False, default=None) |
|
1864 | "repo_name", Text(), nullable=False, default=None) | |
1865 | repo_name_hash = Column( |
|
1865 | repo_name_hash = Column( | |
1866 | "repo_name_hash", String(255), nullable=False, unique=True) |
|
1866 | "repo_name_hash", String(255), nullable=False, unique=True) | |
1867 | repo_state = Column("repo_state", String(255), nullable=True) |
|
1867 | repo_state = Column("repo_state", String(255), nullable=True) | |
1868 |
|
1868 | |||
1869 | clone_uri = Column( |
|
1869 | clone_uri = Column( | |
1870 | "clone_uri", EncryptedTextValue(), nullable=True, unique=False, |
|
1870 | "clone_uri", EncryptedTextValue(), nullable=True, unique=False, | |
1871 | default=None) |
|
1871 | default=None) | |
1872 | push_uri = Column( |
|
1872 | push_uri = Column( | |
1873 | "push_uri", EncryptedTextValue(), nullable=True, unique=False, |
|
1873 | "push_uri", EncryptedTextValue(), nullable=True, unique=False, | |
1874 | default=None) |
|
1874 | default=None) | |
1875 | repo_type = Column( |
|
1875 | repo_type = Column( | |
1876 | "repo_type", String(255), nullable=False, unique=False, default=None) |
|
1876 | "repo_type", String(255), nullable=False, unique=False, default=None) | |
1877 | user_id = Column( |
|
1877 | user_id = Column( | |
1878 | "user_id", Integer(), ForeignKey('users.user_id'), nullable=False, |
|
1878 | "user_id", Integer(), ForeignKey('users.user_id'), nullable=False, | |
1879 | unique=False, default=None) |
|
1879 | unique=False, default=None) | |
1880 | private = Column( |
|
1880 | private = Column( | |
1881 | "private", Boolean(), nullable=True, unique=None, default=None) |
|
1881 | "private", Boolean(), nullable=True, unique=None, default=None) | |
1882 | archived = Column( |
|
1882 | archived = Column( | |
1883 | "archived", Boolean(), nullable=True, unique=None, default=None) |
|
1883 | "archived", Boolean(), nullable=True, unique=None, default=None) | |
1884 | enable_statistics = Column( |
|
1884 | enable_statistics = Column( | |
1885 | "statistics", Boolean(), nullable=True, unique=None, default=True) |
|
1885 | "statistics", Boolean(), nullable=True, unique=None, default=True) | |
1886 | enable_downloads = Column( |
|
1886 | enable_downloads = Column( | |
1887 | "downloads", Boolean(), nullable=True, unique=None, default=True) |
|
1887 | "downloads", Boolean(), nullable=True, unique=None, default=True) | |
1888 | description = Column( |
|
1888 | description = Column( | |
1889 | "description", String(10000), nullable=True, unique=None, default=None) |
|
1889 | "description", String(10000), nullable=True, unique=None, default=None) | |
1890 | created_on = Column( |
|
1890 | created_on = Column( | |
1891 | 'created_on', DateTime(timezone=False), nullable=True, unique=None, |
|
1891 | 'created_on', DateTime(timezone=False), nullable=True, unique=None, | |
1892 | default=datetime.datetime.now) |
|
1892 | default=datetime.datetime.now) | |
1893 | updated_on = Column( |
|
1893 | updated_on = Column( | |
1894 | 'updated_on', DateTime(timezone=False), nullable=True, unique=None, |
|
1894 | 'updated_on', DateTime(timezone=False), nullable=True, unique=None, | |
1895 | default=datetime.datetime.now) |
|
1895 | default=datetime.datetime.now) | |
1896 | _landing_revision = Column( |
|
1896 | _landing_revision = Column( | |
1897 | "landing_revision", String(255), nullable=False, unique=False, |
|
1897 | "landing_revision", String(255), nullable=False, unique=False, | |
1898 | default=None) |
|
1898 | default=None) | |
1899 | enable_locking = Column( |
|
1899 | enable_locking = Column( | |
1900 | "enable_locking", Boolean(), nullable=False, unique=None, |
|
1900 | "enable_locking", Boolean(), nullable=False, unique=None, | |
1901 | default=False) |
|
1901 | default=False) | |
1902 | _locked = Column( |
|
1902 | _locked = Column( | |
1903 | "locked", String(255), nullable=True, unique=False, default=None) |
|
1903 | "locked", String(255), nullable=True, unique=False, default=None) | |
1904 | _changeset_cache = Column( |
|
1904 | _changeset_cache = Column( | |
1905 | "changeset_cache", LargeBinary(), nullable=True) # JSON data |
|
1905 | "changeset_cache", LargeBinary(), nullable=True) # JSON data | |
1906 |
|
1906 | |||
1907 | fork_id = Column( |
|
1907 | fork_id = Column( | |
1908 | "fork_id", Integer(), ForeignKey('repositories.repo_id'), |
|
1908 | "fork_id", Integer(), ForeignKey('repositories.repo_id'), | |
1909 | nullable=True, unique=False, default=None) |
|
1909 | nullable=True, unique=False, default=None) | |
1910 | group_id = Column( |
|
1910 | group_id = Column( | |
1911 | "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True, |
|
1911 | "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True, | |
1912 | unique=False, default=None) |
|
1912 | unique=False, default=None) | |
1913 |
|
1913 | |||
1914 | user = relationship('User', lazy='joined', back_populates='repositories') |
|
1914 | user = relationship('User', lazy='joined', back_populates='repositories') | |
1915 | fork = relationship('Repository', remote_side=repo_id, lazy='joined') |
|
1915 | fork = relationship('Repository', remote_side=repo_id, lazy='joined') | |
1916 | group = relationship('RepoGroup', lazy='joined') |
|
1916 | group = relationship('RepoGroup', lazy='joined') | |
1917 | repo_to_perm = relationship('UserRepoToPerm', cascade='all', order_by='UserRepoToPerm.repo_to_perm_id') |
|
1917 | repo_to_perm = relationship('UserRepoToPerm', cascade='all', order_by='UserRepoToPerm.repo_to_perm_id') | |
1918 | users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all', back_populates='repository') |
|
1918 | users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all', back_populates='repository') | |
1919 | stats = relationship('Statistics', cascade='all', uselist=False) |
|
1919 | stats = relationship('Statistics', cascade='all', uselist=False) | |
1920 |
|
1920 | |||
1921 | followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', cascade='all', back_populates='follows_repository') |
|
1921 | followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', cascade='all', back_populates='follows_repository') | |
1922 | extra_fields = relationship('RepositoryField', cascade="all, delete-orphan", back_populates='repository') |
|
1922 | extra_fields = relationship('RepositoryField', cascade="all, delete-orphan", back_populates='repository') | |
1923 |
|
1923 | |||
1924 | logs = relationship('UserLog', back_populates='repository') |
|
1924 | logs = relationship('UserLog', back_populates='repository') | |
1925 |
|
1925 | |||
1926 | comments = relationship('ChangesetComment', cascade="all, delete-orphan", back_populates='repo') |
|
1926 | comments = relationship('ChangesetComment', cascade="all, delete-orphan", back_populates='repo') | |
1927 |
|
1927 | |||
1928 | pull_requests_source = relationship( |
|
1928 | pull_requests_source = relationship( | |
1929 | 'PullRequest', |
|
1929 | 'PullRequest', | |
1930 | primaryjoin='PullRequest.source_repo_id==Repository.repo_id', |
|
1930 | primaryjoin='PullRequest.source_repo_id==Repository.repo_id', | |
1931 | cascade="all, delete-orphan", |
|
1931 | cascade="all, delete-orphan", | |
1932 | overlaps="source_repo" |
|
1932 | overlaps="source_repo" | |
1933 | ) |
|
1933 | ) | |
1934 | pull_requests_target = relationship( |
|
1934 | pull_requests_target = relationship( | |
1935 | 'PullRequest', |
|
1935 | 'PullRequest', | |
1936 | primaryjoin='PullRequest.target_repo_id==Repository.repo_id', |
|
1936 | primaryjoin='PullRequest.target_repo_id==Repository.repo_id', | |
1937 | cascade="all, delete-orphan", |
|
1937 | cascade="all, delete-orphan", | |
1938 | overlaps="target_repo" |
|
1938 | overlaps="target_repo" | |
1939 | ) |
|
1939 | ) | |
1940 |
|
1940 | |||
1941 | ui = relationship('RepoRhodeCodeUi', cascade="all") |
|
1941 | ui = relationship('RepoRhodeCodeUi', cascade="all") | |
1942 | settings = relationship('RepoRhodeCodeSetting', cascade="all") |
|
1942 | settings = relationship('RepoRhodeCodeSetting', cascade="all") | |
1943 | integrations = relationship('Integration', cascade="all, delete-orphan", back_populates='repo') |
|
1943 | integrations = relationship('Integration', cascade="all, delete-orphan", back_populates='repo') | |
1944 |
|
1944 | |||
1945 | scoped_tokens = relationship('UserApiKeys', cascade="all", back_populates='repo') |
|
1945 | scoped_tokens = relationship('UserApiKeys', cascade="all", back_populates='repo') | |
1946 |
|
1946 | |||
1947 | # no cascade, set NULL |
|
1947 | # no cascade, set NULL | |
1948 | artifacts = relationship('FileStore', primaryjoin='FileStore.scope_repo_id==Repository.repo_id', viewonly=True) |
|
1948 | artifacts = relationship('FileStore', primaryjoin='FileStore.scope_repo_id==Repository.repo_id', viewonly=True) | |
1949 |
|
1949 | |||
1950 | review_rules = relationship('RepoReviewRule') |
|
1950 | review_rules = relationship('RepoReviewRule') | |
1951 | user_branch_perms = relationship('UserToRepoBranchPermission') |
|
1951 | user_branch_perms = relationship('UserToRepoBranchPermission') | |
1952 | user_group_branch_perms = relationship('UserGroupToRepoBranchPermission') |
|
1952 | user_group_branch_perms = relationship('UserGroupToRepoBranchPermission') | |
1953 |
|
1953 | |||
1954 | def __repr__(self): |
|
1954 | def __repr__(self): | |
1955 | return "<%s('%s:%s')>" % (self.cls_name, self.repo_id, self.repo_name) |
|
1955 | return "<%s('%s:%s')>" % (self.cls_name, self.repo_id, self.repo_name) | |
1956 |
|
1956 | |||
1957 | @hybrid_property |
|
1957 | @hybrid_property | |
1958 | def description_safe(self): |
|
1958 | def description_safe(self): | |
1959 | return description_escaper(self.description) |
|
1959 | return description_escaper(self.description) | |
1960 |
|
1960 | |||
1961 | @hybrid_property |
|
1961 | @hybrid_property | |
1962 | def landing_rev(self): |
|
1962 | def landing_rev(self): | |
1963 | # always should return [rev_type, rev], e.g ['branch', 'master'] |
|
1963 | # always should return [rev_type, rev], e.g ['branch', 'master'] | |
1964 | if self._landing_revision: |
|
1964 | if self._landing_revision: | |
1965 | _rev_info = self._landing_revision.split(':') |
|
1965 | _rev_info = self._landing_revision.split(':') | |
1966 | if len(_rev_info) < 2: |
|
1966 | if len(_rev_info) < 2: | |
1967 | _rev_info.insert(0, 'rev') |
|
1967 | _rev_info.insert(0, 'rev') | |
1968 | return [_rev_info[0], _rev_info[1]] |
|
1968 | return [_rev_info[0], _rev_info[1]] | |
1969 | return [None, None] |
|
1969 | return [None, None] | |
1970 |
|
1970 | |||
1971 | @property |
|
1971 | @property | |
1972 | def landing_ref_type(self): |
|
1972 | def landing_ref_type(self): | |
1973 | return self.landing_rev[0] |
|
1973 | return self.landing_rev[0] | |
1974 |
|
1974 | |||
1975 | @property |
|
1975 | @property | |
1976 | def landing_ref_name(self): |
|
1976 | def landing_ref_name(self): | |
1977 | return self.landing_rev[1] |
|
1977 | return self.landing_rev[1] | |
1978 |
|
1978 | |||
1979 | @landing_rev.setter |
|
1979 | @landing_rev.setter | |
1980 | def landing_rev(self, val): |
|
1980 | def landing_rev(self, val): | |
1981 | if ':' not in val: |
|
1981 | if ':' not in val: | |
1982 | raise ValueError('value must be delimited with `:` and consist ' |
|
1982 | raise ValueError('value must be delimited with `:` and consist ' | |
1983 | 'of <rev_type>:<rev>, got %s instead' % val) |
|
1983 | 'of <rev_type>:<rev>, got %s instead' % val) | |
1984 | self._landing_revision = val |
|
1984 | self._landing_revision = val | |
1985 |
|
1985 | |||
1986 | @hybrid_property |
|
1986 | @hybrid_property | |
1987 | def locked(self): |
|
1987 | def locked(self): | |
1988 | if self._locked: |
|
1988 | if self._locked: | |
1989 | user_id, timelocked, reason = self._locked.split(':') |
|
1989 | user_id, timelocked, reason = self._locked.split(':') | |
1990 | lock_values = int(user_id), timelocked, reason |
|
1990 | lock_values = int(user_id), timelocked, reason | |
1991 | else: |
|
1991 | else: | |
1992 | lock_values = [None, None, None] |
|
1992 | lock_values = [None, None, None] | |
1993 | return lock_values |
|
1993 | return lock_values | |
1994 |
|
1994 | |||
1995 | @locked.setter |
|
1995 | @locked.setter | |
1996 | def locked(self, val): |
|
1996 | def locked(self, val): | |
1997 | if val and isinstance(val, (list, tuple)): |
|
1997 | if val and isinstance(val, (list, tuple)): | |
1998 | self._locked = ':'.join(map(str, val)) |
|
1998 | self._locked = ':'.join(map(str, val)) | |
1999 | else: |
|
1999 | else: | |
2000 | self._locked = None |
|
2000 | self._locked = None | |
2001 |
|
2001 | |||
2002 | @classmethod |
|
2002 | @classmethod | |
2003 | def _load_changeset_cache(cls, repo_id, changeset_cache_raw): |
|
2003 | def _load_changeset_cache(cls, repo_id, changeset_cache_raw): | |
2004 | from rhodecode.lib.vcs.backends.base import EmptyCommit |
|
2004 | from rhodecode.lib.vcs.backends.base import EmptyCommit | |
2005 | dummy = EmptyCommit().__json__() |
|
2005 | dummy = EmptyCommit().__json__() | |
2006 | if not changeset_cache_raw: |
|
2006 | if not changeset_cache_raw: | |
2007 | dummy['source_repo_id'] = repo_id |
|
2007 | dummy['source_repo_id'] = repo_id | |
2008 | return json.loads(json.dumps(dummy)) |
|
2008 | return json.loads(json.dumps(dummy)) | |
2009 |
|
2009 | |||
2010 | try: |
|
2010 | try: | |
2011 | return json.loads(changeset_cache_raw) |
|
2011 | return json.loads(changeset_cache_raw) | |
2012 | except TypeError: |
|
2012 | except TypeError: | |
2013 | return dummy |
|
2013 | return dummy | |
2014 | except Exception: |
|
2014 | except Exception: | |
2015 | log.error(traceback.format_exc()) |
|
2015 | log.error(traceback.format_exc()) | |
2016 | return dummy |
|
2016 | return dummy | |
2017 |
|
2017 | |||
2018 | @hybrid_property |
|
2018 | @hybrid_property | |
2019 | def changeset_cache(self): |
|
2019 | def changeset_cache(self): | |
2020 | return self._load_changeset_cache(self.repo_id, self._changeset_cache) |
|
2020 | return self._load_changeset_cache(self.repo_id, self._changeset_cache) | |
2021 |
|
2021 | |||
2022 | @changeset_cache.setter |
|
2022 | @changeset_cache.setter | |
2023 | def changeset_cache(self, val): |
|
2023 | def changeset_cache(self, val): | |
2024 | try: |
|
2024 | try: | |
2025 | self._changeset_cache = json.dumps(val) |
|
2025 | self._changeset_cache = json.dumps(val) | |
2026 | except Exception: |
|
2026 | except Exception: | |
2027 | log.error(traceback.format_exc()) |
|
2027 | log.error(traceback.format_exc()) | |
2028 |
|
2028 | |||
2029 | @hybrid_property |
|
2029 | @hybrid_property | |
2030 | def repo_name(self): |
|
2030 | def repo_name(self): | |
2031 | return self._repo_name |
|
2031 | return self._repo_name | |
2032 |
|
2032 | |||
2033 | @repo_name.setter |
|
2033 | @repo_name.setter | |
2034 | def repo_name(self, value): |
|
2034 | def repo_name(self, value): | |
2035 | self._repo_name = value |
|
2035 | self._repo_name = value | |
2036 | self.repo_name_hash = sha1(safe_bytes(value)) |
|
2036 | self.repo_name_hash = sha1(safe_bytes(value)) | |
2037 |
|
2037 | |||
2038 | @classmethod |
|
2038 | @classmethod | |
2039 | def normalize_repo_name(cls, repo_name): |
|
2039 | def normalize_repo_name(cls, repo_name): | |
2040 | """ |
|
2040 | """ | |
2041 | Normalizes os specific repo_name to the format internally stored inside |
|
2041 | Normalizes os specific repo_name to the format internally stored inside | |
2042 | database using URL_SEP |
|
2042 | database using URL_SEP | |
2043 |
|
2043 | |||
2044 | :param cls: |
|
2044 | :param cls: | |
2045 | :param repo_name: |
|
2045 | :param repo_name: | |
2046 | """ |
|
2046 | """ | |
2047 | return cls.NAME_SEP.join(repo_name.split(os.sep)) |
|
2047 | return cls.NAME_SEP.join(repo_name.split(os.sep)) | |
2048 |
|
2048 | |||
2049 | @classmethod |
|
2049 | @classmethod | |
2050 | def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False): |
|
2050 | def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False): | |
2051 | session = Session() |
|
2051 | session = Session() | |
2052 | q = session.query(cls).filter(cls.repo_name == repo_name) |
|
2052 | q = session.query(cls).filter(cls.repo_name == repo_name) | |
2053 |
|
2053 | |||
2054 | if cache: |
|
2054 | if cache: | |
2055 | if identity_cache: |
|
2055 | if identity_cache: | |
2056 | val = cls.identity_cache(session, 'repo_name', repo_name) |
|
2056 | val = cls.identity_cache(session, 'repo_name', repo_name) | |
2057 | if val: |
|
2057 | if val: | |
2058 | return val |
|
2058 | return val | |
2059 | else: |
|
2059 | else: | |
2060 | cache_key = f"get_repo_by_name_{_hash_key(repo_name)}" |
|
2060 | cache_key = f"get_repo_by_name_{_hash_key(repo_name)}" | |
2061 | q = q.options( |
|
2061 | q = q.options( | |
2062 | FromCache("sql_cache_short", cache_key)) |
|
2062 | FromCache("sql_cache_short", cache_key)) | |
2063 |
|
2063 | |||
2064 | return q.scalar() |
|
2064 | return q.scalar() | |
2065 |
|
2065 | |||
2066 | @classmethod |
|
2066 | @classmethod | |
2067 | def get_by_id_or_repo_name(cls, repoid): |
|
2067 | def get_by_id_or_repo_name(cls, repoid): | |
2068 | if isinstance(repoid, int): |
|
2068 | if isinstance(repoid, int): | |
2069 | try: |
|
2069 | try: | |
2070 | repo = cls.get(repoid) |
|
2070 | repo = cls.get(repoid) | |
2071 | except ValueError: |
|
2071 | except ValueError: | |
2072 | repo = None |
|
2072 | repo = None | |
2073 | else: |
|
2073 | else: | |
2074 | repo = cls.get_by_repo_name(repoid) |
|
2074 | repo = cls.get_by_repo_name(repoid) | |
2075 | return repo |
|
2075 | return repo | |
2076 |
|
2076 | |||
2077 | @classmethod |
|
2077 | @classmethod | |
2078 | def get_by_full_path(cls, repo_full_path): |
|
2078 | def get_by_full_path(cls, repo_full_path): | |
2079 | repo_name = repo_full_path.split(cls.base_path(), 1)[-1] |
|
2079 | repo_name = repo_full_path.split(cls.base_path(), 1)[-1] | |
2080 | repo_name = cls.normalize_repo_name(repo_name) |
|
2080 | repo_name = cls.normalize_repo_name(repo_name) | |
2081 | return cls.get_by_repo_name(repo_name.strip(URL_SEP)) |
|
2081 | return cls.get_by_repo_name(repo_name.strip(URL_SEP)) | |
2082 |
|
2082 | |||
2083 | @classmethod |
|
2083 | @classmethod | |
2084 | def get_repo_forks(cls, repo_id): |
|
2084 | def get_repo_forks(cls, repo_id): | |
2085 | return cls.query().filter(Repository.fork_id == repo_id) |
|
2085 | return cls.query().filter(Repository.fork_id == repo_id) | |
2086 |
|
2086 | |||
2087 | @classmethod |
|
2087 | @classmethod | |
2088 | def base_path(cls): |
|
2088 | def base_path(cls): | |
2089 | """ |
|
2089 | """ | |
2090 | Returns base path when all repos are stored |
|
2090 | Returns base path when all repos are stored | |
2091 |
|
2091 | |||
2092 | :param cls: |
|
2092 | :param cls: | |
2093 | """ |
|
2093 | """ | |
2094 | from rhodecode.lib.utils import get_rhodecode_repo_store_path |
|
2094 | from rhodecode.lib.utils import get_rhodecode_repo_store_path | |
2095 | return get_rhodecode_repo_store_path() |
|
2095 | return get_rhodecode_repo_store_path() | |
2096 |
|
2096 | |||
2097 | @classmethod |
|
2097 | @classmethod | |
2098 | def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None), |
|
2098 | def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None), | |
2099 | case_insensitive=True, archived=False): |
|
2099 | case_insensitive=True, archived=False): | |
2100 | q = Repository.query() |
|
2100 | q = Repository.query() | |
2101 |
|
2101 | |||
2102 | if not archived: |
|
2102 | if not archived: | |
2103 | q = q.filter(Repository.archived.isnot(true())) |
|
2103 | q = q.filter(Repository.archived.isnot(true())) | |
2104 |
|
2104 | |||
2105 | if not isinstance(user_id, Optional): |
|
2105 | if not isinstance(user_id, Optional): | |
2106 | q = q.filter(Repository.user_id == user_id) |
|
2106 | q = q.filter(Repository.user_id == user_id) | |
2107 |
|
2107 | |||
2108 | if not isinstance(group_id, Optional): |
|
2108 | if not isinstance(group_id, Optional): | |
2109 | q = q.filter(Repository.group_id == group_id) |
|
2109 | q = q.filter(Repository.group_id == group_id) | |
2110 |
|
2110 | |||
2111 | if case_insensitive: |
|
2111 | if case_insensitive: | |
2112 | q = q.order_by(func.lower(Repository.repo_name)) |
|
2112 | q = q.order_by(func.lower(Repository.repo_name)) | |
2113 | else: |
|
2113 | else: | |
2114 | q = q.order_by(Repository.repo_name) |
|
2114 | q = q.order_by(Repository.repo_name) | |
2115 |
|
2115 | |||
2116 | return q.all() |
|
2116 | return q.all() | |
2117 |
|
2117 | |||
2118 | @property |
|
2118 | @property | |
2119 | def repo_uid(self): |
|
2119 | def repo_uid(self): | |
2120 | return '_{}'.format(self.repo_id) |
|
2120 | return '_{}'.format(self.repo_id) | |
2121 |
|
2121 | |||
2122 | @property |
|
2122 | @property | |
2123 | def forks(self): |
|
2123 | def forks(self): | |
2124 | """ |
|
2124 | """ | |
2125 | Return forks of this repo |
|
2125 | Return forks of this repo | |
2126 | """ |
|
2126 | """ | |
2127 | return Repository.get_repo_forks(self.repo_id) |
|
2127 | return Repository.get_repo_forks(self.repo_id) | |
2128 |
|
2128 | |||
2129 | @property |
|
2129 | @property | |
2130 | def parent(self): |
|
2130 | def parent(self): | |
2131 | """ |
|
2131 | """ | |
2132 | Returns fork parent |
|
2132 | Returns fork parent | |
2133 | """ |
|
2133 | """ | |
2134 | return self.fork |
|
2134 | return self.fork | |
2135 |
|
2135 | |||
2136 | @property |
|
2136 | @property | |
2137 | def just_name(self): |
|
2137 | def just_name(self): | |
2138 | return self.repo_name.split(self.NAME_SEP)[-1] |
|
2138 | return self.repo_name.split(self.NAME_SEP)[-1] | |
2139 |
|
2139 | |||
2140 | @property |
|
2140 | @property | |
2141 | def groups_with_parents(self): |
|
2141 | def groups_with_parents(self): | |
2142 | groups = [] |
|
2142 | groups = [] | |
2143 | if self.group is None: |
|
2143 | if self.group is None: | |
2144 | return groups |
|
2144 | return groups | |
2145 |
|
2145 | |||
2146 | cur_gr = self.group |
|
2146 | cur_gr = self.group | |
2147 | groups.insert(0, cur_gr) |
|
2147 | groups.insert(0, cur_gr) | |
2148 | while 1: |
|
2148 | while 1: | |
2149 | gr = getattr(cur_gr, 'parent_group', None) |
|
2149 | gr = getattr(cur_gr, 'parent_group', None) | |
2150 | cur_gr = cur_gr.parent_group |
|
2150 | cur_gr = cur_gr.parent_group | |
2151 | if gr is None: |
|
2151 | if gr is None: | |
2152 | break |
|
2152 | break | |
2153 | groups.insert(0, gr) |
|
2153 | groups.insert(0, gr) | |
2154 |
|
2154 | |||
2155 | return groups |
|
2155 | return groups | |
2156 |
|
2156 | |||
2157 | @property |
|
2157 | @property | |
2158 | def groups_and_repo(self): |
|
2158 | def groups_and_repo(self): | |
2159 | return self.groups_with_parents, self |
|
2159 | return self.groups_with_parents, self | |
2160 |
|
2160 | |||
2161 | @property |
|
2161 | @property | |
2162 | def repo_path(self): |
|
2162 | def repo_path(self): | |
2163 | """ |
|
2163 | """ | |
2164 | Returns base full path for that repository means where it actually |
|
2164 | Returns base full path for that repository means where it actually | |
2165 | exists on a filesystem |
|
2165 | exists on a filesystem | |
2166 | """ |
|
2166 | """ | |
2167 | return self.base_path() |
|
2167 | return self.base_path() | |
2168 |
|
2168 | |||
2169 | @property |
|
2169 | @property | |
2170 | def repo_full_path(self): |
|
2170 | def repo_full_path(self): | |
2171 | p = [self.repo_path] |
|
2171 | p = [self.repo_path] | |
2172 | # we need to split the name by / since this is how we store the |
|
2172 | # we need to split the name by / since this is how we store the | |
2173 | # names in the database, but that eventually needs to be converted |
|
2173 | # names in the database, but that eventually needs to be converted | |
2174 | # into a valid system path |
|
2174 | # into a valid system path | |
2175 | p += self.repo_name.split(self.NAME_SEP) |
|
2175 | p += self.repo_name.split(self.NAME_SEP) | |
2176 | return os.path.join(*map(safe_str, p)) |
|
2176 | return os.path.join(*map(safe_str, p)) | |
2177 |
|
2177 | |||
2178 | @property |
|
2178 | @property | |
2179 | def cache_keys(self): |
|
2179 | def cache_keys(self): | |
2180 | """ |
|
2180 | """ | |
2181 | Returns associated cache keys for that repo |
|
2181 | Returns associated cache keys for that repo | |
2182 | """ |
|
2182 | """ | |
2183 | repo_namespace_key = CacheKey.REPO_INVALIDATION_NAMESPACE.format(repo_id=self.repo_id) |
|
2183 | repo_namespace_key = CacheKey.REPO_INVALIDATION_NAMESPACE.format(repo_id=self.repo_id) | |
2184 | return CacheKey.query()\ |
|
2184 | return CacheKey.query()\ | |
2185 | .filter(CacheKey.cache_key == repo_namespace_key)\ |
|
2185 | .filter(CacheKey.cache_key == repo_namespace_key)\ | |
2186 | .order_by(CacheKey.cache_key)\ |
|
2186 | .order_by(CacheKey.cache_key)\ | |
2187 | .all() |
|
2187 | .all() | |
2188 |
|
2188 | |||
2189 | @property |
|
2189 | @property | |
2190 | def cached_diffs_relative_dir(self): |
|
2190 | def cached_diffs_relative_dir(self): | |
2191 | """ |
|
2191 | """ | |
2192 | Return a relative to the repository store path of cached diffs |
|
2192 | Return a relative to the repository store path of cached diffs | |
2193 | used for safe display for users, who shouldn't know the absolute store |
|
2193 | used for safe display for users, who shouldn't know the absolute store | |
2194 | path |
|
2194 | path | |
2195 | """ |
|
2195 | """ | |
2196 | return os.path.join( |
|
2196 | return os.path.join( | |
2197 | os.path.dirname(self.repo_name), |
|
2197 | os.path.dirname(self.repo_name), | |
2198 | self.cached_diffs_dir.split(os.path.sep)[-1]) |
|
2198 | self.cached_diffs_dir.split(os.path.sep)[-1]) | |
2199 |
|
2199 | |||
2200 | @property |
|
2200 | @property | |
2201 | def cached_diffs_dir(self): |
|
2201 | def cached_diffs_dir(self): | |
2202 | path = self.repo_full_path |
|
2202 | path = self.repo_full_path | |
2203 | return os.path.join( |
|
2203 | return os.path.join( | |
2204 | os.path.dirname(path), |
|
2204 | os.path.dirname(path), | |
2205 | f'.__shadow_diff_cache_repo_{self.repo_id}') |
|
2205 | f'.__shadow_diff_cache_repo_{self.repo_id}') | |
2206 |
|
2206 | |||
2207 | def cached_diffs(self): |
|
2207 | def cached_diffs(self): | |
2208 | diff_cache_dir = self.cached_diffs_dir |
|
2208 | diff_cache_dir = self.cached_diffs_dir | |
2209 | if os.path.isdir(diff_cache_dir): |
|
2209 | if os.path.isdir(diff_cache_dir): | |
2210 | return os.listdir(diff_cache_dir) |
|
2210 | return os.listdir(diff_cache_dir) | |
2211 | return [] |
|
2211 | return [] | |
2212 |
|
2212 | |||
2213 | def shadow_repos(self): |
|
2213 | def shadow_repos(self): | |
2214 | shadow_repos_pattern = f'.__shadow_repo_{self.repo_id}' |
|
2214 | shadow_repos_pattern = f'.__shadow_repo_{self.repo_id}' | |
2215 | return [ |
|
2215 | return [ | |
2216 | x for x in os.listdir(os.path.dirname(self.repo_full_path)) |
|
2216 | x for x in os.listdir(os.path.dirname(self.repo_full_path)) | |
2217 | if x.startswith(shadow_repos_pattern) |
|
2217 | if x.startswith(shadow_repos_pattern) | |
2218 | ] |
|
2218 | ] | |
2219 |
|
2219 | |||
2220 | def get_new_name(self, repo_name): |
|
2220 | def get_new_name(self, repo_name): | |
2221 | """ |
|
2221 | """ | |
2222 | returns new full repository name based on assigned group and new new |
|
2222 | returns new full repository name based on assigned group and new new | |
2223 |
|
2223 | |||
2224 | :param repo_name: |
|
2224 | :param repo_name: | |
2225 | """ |
|
2225 | """ | |
2226 | path_prefix = self.group.full_path_splitted if self.group else [] |
|
2226 | path_prefix = self.group.full_path_splitted if self.group else [] | |
2227 | return self.NAME_SEP.join(path_prefix + [repo_name]) |
|
2227 | return self.NAME_SEP.join(path_prefix + [repo_name]) | |
2228 |
|
2228 | |||
2229 | @property |
|
2229 | @property | |
2230 | def _config(self): |
|
2230 | def _config(self): | |
2231 | """ |
|
2231 | """ | |
2232 | Returns db based config object. |
|
2232 | Returns db based config object. | |
2233 | """ |
|
2233 | """ | |
2234 | from rhodecode.lib.utils import make_db_config |
|
2234 | from rhodecode.lib.utils import make_db_config | |
2235 | return make_db_config(clear_session=False, repo=self) |
|
2235 | return make_db_config(clear_session=False, repo=self) | |
2236 |
|
2236 | |||
2237 | def permissions(self, with_admins=True, with_owner=True, |
|
2237 | def permissions(self, with_admins=True, with_owner=True, | |
2238 | expand_from_user_groups=False): |
|
2238 | expand_from_user_groups=False): | |
2239 | """ |
|
2239 | """ | |
2240 | Permissions for repositories |
|
2240 | Permissions for repositories | |
2241 | """ |
|
2241 | """ | |
2242 | _admin_perm = 'repository.admin' |
|
2242 | _admin_perm = 'repository.admin' | |
2243 |
|
2243 | |||
2244 | owner_row = [] |
|
2244 | owner_row = [] | |
2245 | if with_owner: |
|
2245 | if with_owner: | |
2246 | usr = AttributeDict(self.user.get_dict()) |
|
2246 | usr = AttributeDict(self.user.get_dict()) | |
2247 | usr.owner_row = True |
|
2247 | usr.owner_row = True | |
2248 | usr.permission = _admin_perm |
|
2248 | usr.permission = _admin_perm | |
2249 | usr.permission_id = None |
|
2249 | usr.permission_id = None | |
2250 | owner_row.append(usr) |
|
2250 | owner_row.append(usr) | |
2251 |
|
2251 | |||
2252 | super_admin_ids = [] |
|
2252 | super_admin_ids = [] | |
2253 | super_admin_rows = [] |
|
2253 | super_admin_rows = [] | |
2254 | if with_admins: |
|
2254 | if with_admins: | |
2255 | for usr in User.get_all_super_admins(): |
|
2255 | for usr in User.get_all_super_admins(): | |
2256 | super_admin_ids.append(usr.user_id) |
|
2256 | super_admin_ids.append(usr.user_id) | |
2257 | # if this admin is also owner, don't double the record |
|
2257 | # if this admin is also owner, don't double the record | |
2258 | if usr.user_id == owner_row[0].user_id: |
|
2258 | if usr.user_id == owner_row[0].user_id: | |
2259 | owner_row[0].admin_row = True |
|
2259 | owner_row[0].admin_row = True | |
2260 | else: |
|
2260 | else: | |
2261 | usr = AttributeDict(usr.get_dict()) |
|
2261 | usr = AttributeDict(usr.get_dict()) | |
2262 | usr.admin_row = True |
|
2262 | usr.admin_row = True | |
2263 | usr.permission = _admin_perm |
|
2263 | usr.permission = _admin_perm | |
2264 | usr.permission_id = None |
|
2264 | usr.permission_id = None | |
2265 | super_admin_rows.append(usr) |
|
2265 | super_admin_rows.append(usr) | |
2266 |
|
2266 | |||
2267 | q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self) |
|
2267 | q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self) | |
2268 | q = q.options(joinedload(UserRepoToPerm.repository), |
|
2268 | q = q.options(joinedload(UserRepoToPerm.repository), | |
2269 | joinedload(UserRepoToPerm.user), |
|
2269 | joinedload(UserRepoToPerm.user), | |
2270 | joinedload(UserRepoToPerm.permission),) |
|
2270 | joinedload(UserRepoToPerm.permission),) | |
2271 |
|
2271 | |||
2272 | # get owners and admins and permissions. We do a trick of re-writing |
|
2272 | # get owners and admins and permissions. We do a trick of re-writing | |
2273 | # objects from sqlalchemy to named-tuples due to sqlalchemy session |
|
2273 | # objects from sqlalchemy to named-tuples due to sqlalchemy session | |
2274 | # has a global reference and changing one object propagates to all |
|
2274 | # has a global reference and changing one object propagates to all | |
2275 | # others. This means if admin is also an owner admin_row that change |
|
2275 | # others. This means if admin is also an owner admin_row that change | |
2276 | # would propagate to both objects |
|
2276 | # would propagate to both objects | |
2277 | perm_rows = [] |
|
2277 | perm_rows = [] | |
2278 | for _usr in q.all(): |
|
2278 | for _usr in q.all(): | |
2279 | usr = AttributeDict(_usr.user.get_dict()) |
|
2279 | usr = AttributeDict(_usr.user.get_dict()) | |
2280 | # if this user is also owner/admin, mark as duplicate record |
|
2280 | # if this user is also owner/admin, mark as duplicate record | |
2281 | if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids: |
|
2281 | if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids: | |
2282 | usr.duplicate_perm = True |
|
2282 | usr.duplicate_perm = True | |
2283 | # also check if this permission is maybe used by branch_permissions |
|
2283 | # also check if this permission is maybe used by branch_permissions | |
2284 | if _usr.branch_perm_entry: |
|
2284 | if _usr.branch_perm_entry: | |
2285 | usr.branch_rules = [x.branch_rule_id for x in _usr.branch_perm_entry] |
|
2285 | usr.branch_rules = [x.branch_rule_id for x in _usr.branch_perm_entry] | |
2286 |
|
2286 | |||
2287 | usr.permission = _usr.permission.permission_name |
|
2287 | usr.permission = _usr.permission.permission_name | |
2288 | usr.permission_id = _usr.repo_to_perm_id |
|
2288 | usr.permission_id = _usr.repo_to_perm_id | |
2289 | perm_rows.append(usr) |
|
2289 | perm_rows.append(usr) | |
2290 |
|
2290 | |||
2291 | # filter the perm rows by 'default' first and then sort them by |
|
2291 | # filter the perm rows by 'default' first and then sort them by | |
2292 | # admin,write,read,none permissions sorted again alphabetically in |
|
2292 | # admin,write,read,none permissions sorted again alphabetically in | |
2293 | # each group |
|
2293 | # each group | |
2294 | perm_rows = sorted(perm_rows, key=display_user_sort) |
|
2294 | perm_rows = sorted(perm_rows, key=display_user_sort) | |
2295 |
|
2295 | |||
2296 | user_groups_rows = [] |
|
2296 | user_groups_rows = [] | |
2297 | if expand_from_user_groups: |
|
2297 | if expand_from_user_groups: | |
2298 | for ug in self.permission_user_groups(with_members=True): |
|
2298 | for ug in self.permission_user_groups(with_members=True): | |
2299 | for user_data in ug.members: |
|
2299 | for user_data in ug.members: | |
2300 | user_groups_rows.append(user_data) |
|
2300 | user_groups_rows.append(user_data) | |
2301 |
|
2301 | |||
2302 | return super_admin_rows + owner_row + perm_rows + user_groups_rows |
|
2302 | return super_admin_rows + owner_row + perm_rows + user_groups_rows | |
2303 |
|
2303 | |||
2304 | def permission_user_groups(self, with_members=True): |
|
2304 | def permission_user_groups(self, with_members=True): | |
2305 | q = UserGroupRepoToPerm.query()\ |
|
2305 | q = UserGroupRepoToPerm.query()\ | |
2306 | .filter(UserGroupRepoToPerm.repository == self) |
|
2306 | .filter(UserGroupRepoToPerm.repository == self) | |
2307 | q = q.options(joinedload(UserGroupRepoToPerm.repository), |
|
2307 | q = q.options(joinedload(UserGroupRepoToPerm.repository), | |
2308 | joinedload(UserGroupRepoToPerm.users_group), |
|
2308 | joinedload(UserGroupRepoToPerm.users_group), | |
2309 | joinedload(UserGroupRepoToPerm.permission),) |
|
2309 | joinedload(UserGroupRepoToPerm.permission),) | |
2310 |
|
2310 | |||
2311 | perm_rows = [] |
|
2311 | perm_rows = [] | |
2312 | for _user_group in q.all(): |
|
2312 | for _user_group in q.all(): | |
2313 | entry = AttributeDict(_user_group.users_group.get_dict()) |
|
2313 | entry = AttributeDict(_user_group.users_group.get_dict()) | |
2314 | entry.permission = _user_group.permission.permission_name |
|
2314 | entry.permission = _user_group.permission.permission_name | |
2315 | if with_members: |
|
2315 | if with_members: | |
2316 | entry.members = [x.user.get_dict() |
|
2316 | entry.members = [x.user.get_dict() | |
2317 | for x in _user_group.users_group.members] |
|
2317 | for x in _user_group.users_group.members] | |
2318 | perm_rows.append(entry) |
|
2318 | perm_rows.append(entry) | |
2319 |
|
2319 | |||
2320 | perm_rows = sorted(perm_rows, key=display_user_group_sort) |
|
2320 | perm_rows = sorted(perm_rows, key=display_user_group_sort) | |
2321 | return perm_rows |
|
2321 | return perm_rows | |
2322 |
|
2322 | |||
2323 | def get_api_data(self, include_secrets=False): |
|
2323 | def get_api_data(self, include_secrets=False): | |
2324 | """ |
|
2324 | """ | |
2325 | Common function for generating repo api data |
|
2325 | Common function for generating repo api data | |
2326 |
|
2326 | |||
2327 | :param include_secrets: See :meth:`User.get_api_data`. |
|
2327 | :param include_secrets: See :meth:`User.get_api_data`. | |
2328 |
|
2328 | |||
2329 | """ |
|
2329 | """ | |
2330 | # TODO: mikhail: Here there is an anti-pattern, we probably need to |
|
2330 | # TODO: mikhail: Here there is an anti-pattern, we probably need to | |
2331 | # move this methods on models level. |
|
2331 | # move this methods on models level. | |
2332 | from rhodecode.model.settings import SettingsModel |
|
2332 | from rhodecode.model.settings import SettingsModel | |
2333 | from rhodecode.model.repo import RepoModel |
|
2333 | from rhodecode.model.repo import RepoModel | |
2334 |
|
2334 | |||
2335 | repo = self |
|
2335 | repo = self | |
2336 | _user_id, _time, _reason = self.locked |
|
2336 | _user_id, _time, _reason = self.locked | |
2337 |
|
2337 | |||
2338 | data = { |
|
2338 | data = { | |
2339 | 'repo_id': repo.repo_id, |
|
2339 | 'repo_id': repo.repo_id, | |
2340 | 'repo_name': repo.repo_name, |
|
2340 | 'repo_name': repo.repo_name, | |
2341 | 'repo_type': repo.repo_type, |
|
2341 | 'repo_type': repo.repo_type, | |
2342 | 'clone_uri': repo.clone_uri or '', |
|
2342 | 'clone_uri': repo.clone_uri or '', | |
2343 | 'push_uri': repo.push_uri or '', |
|
2343 | 'push_uri': repo.push_uri or '', | |
2344 | 'url': RepoModel().get_url(self), |
|
2344 | 'url': RepoModel().get_url(self), | |
2345 | 'private': repo.private, |
|
2345 | 'private': repo.private, | |
2346 | 'created_on': repo.created_on, |
|
2346 | 'created_on': repo.created_on, | |
2347 | 'description': repo.description_safe, |
|
2347 | 'description': repo.description_safe, | |
2348 | 'landing_rev': repo.landing_rev, |
|
2348 | 'landing_rev': repo.landing_rev, | |
2349 | 'owner': repo.user.username, |
|
2349 | 'owner': repo.user.username, | |
2350 | 'fork_of': repo.fork.repo_name if repo.fork else None, |
|
2350 | 'fork_of': repo.fork.repo_name if repo.fork else None, | |
2351 | 'fork_of_id': repo.fork.repo_id if repo.fork else None, |
|
2351 | 'fork_of_id': repo.fork.repo_id if repo.fork else None, | |
2352 | 'enable_statistics': repo.enable_statistics, |
|
2352 | 'enable_statistics': repo.enable_statistics, | |
2353 | 'enable_locking': repo.enable_locking, |
|
2353 | 'enable_locking': repo.enable_locking, | |
2354 | 'enable_downloads': repo.enable_downloads, |
|
2354 | 'enable_downloads': repo.enable_downloads, | |
2355 | 'last_changeset': repo.changeset_cache, |
|
2355 | 'last_changeset': repo.changeset_cache, | |
2356 | 'locked_by': User.get(_user_id).get_api_data( |
|
2356 | 'locked_by': User.get(_user_id).get_api_data( | |
2357 | include_secrets=include_secrets) if _user_id else None, |
|
2357 | include_secrets=include_secrets) if _user_id else None, | |
2358 | 'locked_date': time_to_datetime(_time) if _time else None, |
|
2358 | 'locked_date': time_to_datetime(_time) if _time else None, | |
2359 | 'lock_reason': _reason if _reason else None, |
|
2359 | 'lock_reason': _reason if _reason else None, | |
2360 | } |
|
2360 | } | |
2361 |
|
2361 | |||
2362 | # TODO: mikhail: should be per-repo settings here |
|
2362 | # TODO: mikhail: should be per-repo settings here | |
2363 | rc_config = SettingsModel().get_all_settings() |
|
2363 | rc_config = SettingsModel().get_all_settings() | |
2364 | repository_fields = str2bool( |
|
2364 | repository_fields = str2bool( | |
2365 | rc_config.get('rhodecode_repository_fields')) |
|
2365 | rc_config.get('rhodecode_repository_fields')) | |
2366 | if repository_fields: |
|
2366 | if repository_fields: | |
2367 | for f in self.extra_fields: |
|
2367 | for f in self.extra_fields: | |
2368 | data[f.field_key_prefixed] = f.field_value |
|
2368 | data[f.field_key_prefixed] = f.field_value | |
2369 |
|
2369 | |||
2370 | return data |
|
2370 | return data | |
2371 |
|
2371 | |||
2372 | @classmethod |
|
2372 | @classmethod | |
2373 | def lock(cls, repo, user_id, lock_time=None, lock_reason=None): |
|
2373 | def lock(cls, repo, user_id, lock_time=None, lock_reason=None): | |
2374 | if not lock_time: |
|
2374 | if not lock_time: | |
2375 | lock_time = time.time() |
|
2375 | lock_time = time.time() | |
2376 | if not lock_reason: |
|
2376 | if not lock_reason: | |
2377 | lock_reason = cls.LOCK_AUTOMATIC |
|
2377 | lock_reason = cls.LOCK_AUTOMATIC | |
2378 | repo.locked = [user_id, lock_time, lock_reason] |
|
2378 | repo.locked = [user_id, lock_time, lock_reason] | |
2379 | Session().add(repo) |
|
2379 | Session().add(repo) | |
2380 | Session().commit() |
|
2380 | Session().commit() | |
2381 |
|
2381 | |||
2382 | @classmethod |
|
2382 | @classmethod | |
2383 | def unlock(cls, repo): |
|
2383 | def unlock(cls, repo): | |
2384 | repo.locked = None |
|
2384 | repo.locked = None | |
2385 | Session().add(repo) |
|
2385 | Session().add(repo) | |
2386 | Session().commit() |
|
2386 | Session().commit() | |
2387 |
|
2387 | |||
2388 | @classmethod |
|
2388 | @classmethod | |
2389 | def getlock(cls, repo): |
|
2389 | def getlock(cls, repo): | |
2390 | return repo.locked |
|
2390 | return repo.locked | |
2391 |
|
2391 | |||
2392 | def get_locking_state(self, action, user_id, only_when_enabled=True): |
|
2392 | def get_locking_state(self, action, user_id, only_when_enabled=True): | |
2393 | """ |
|
2393 | """ | |
2394 | Checks locking on this repository, if locking is enabled and lock is |
|
2394 | Checks locking on this repository, if locking is enabled and lock is | |
2395 | present returns a tuple of make_lock, locked, locked_by. |
|
2395 | present returns a tuple of make_lock, locked, locked_by. | |
2396 | make_lock can have 3 states None (do nothing) True, make lock |
|
2396 | make_lock can have 3 states None (do nothing) True, make lock | |
2397 | False release lock, This value is later propagated to hooks, which |
|
2397 | False release lock, This value is later propagated to hooks, which | |
2398 | do the locking. Think about this as signals passed to hooks what to do. |
|
2398 | do the locking. Think about this as signals passed to hooks what to do. | |
2399 |
|
2399 | |||
2400 | """ |
|
2400 | """ | |
2401 | # TODO: johbo: This is part of the business logic and should be moved |
|
2401 | # TODO: johbo: This is part of the business logic and should be moved | |
2402 | # into the RepositoryModel. |
|
2402 | # into the RepositoryModel. | |
2403 |
|
2403 | |||
2404 | if action not in ('push', 'pull'): |
|
2404 | if action not in ('push', 'pull'): | |
2405 | raise ValueError("Invalid action value: %s" % repr(action)) |
|
2405 | raise ValueError("Invalid action value: %s" % repr(action)) | |
2406 |
|
2406 | |||
2407 | # defines if locked error should be thrown to user |
|
2407 | # defines if locked error should be thrown to user | |
2408 | currently_locked = False |
|
2408 | currently_locked = False | |
2409 | # defines if new lock should be made, tri-state |
|
2409 | # defines if new lock should be made, tri-state | |
2410 | make_lock = None |
|
2410 | make_lock = None | |
2411 | repo = self |
|
2411 | repo = self | |
2412 | user = User.get(user_id) |
|
2412 | user = User.get(user_id) | |
2413 |
|
2413 | |||
2414 | lock_info = repo.locked |
|
2414 | lock_info = repo.locked | |
2415 |
|
2415 | |||
2416 | if repo and (repo.enable_locking or not only_when_enabled): |
|
2416 | if repo and (repo.enable_locking or not only_when_enabled): | |
2417 | if action == 'push': |
|
2417 | if action == 'push': | |
2418 | # check if it's already locked !, if it is compare users |
|
2418 | # check if it's already locked !, if it is compare users | |
2419 | locked_by_user_id = lock_info[0] |
|
2419 | locked_by_user_id = lock_info[0] | |
2420 | if user.user_id == locked_by_user_id: |
|
2420 | if user.user_id == locked_by_user_id: | |
2421 | log.debug( |
|
2421 | log.debug( | |
2422 | 'Got `push` action from user %s, now unlocking', user) |
|
2422 | 'Got `push` action from user %s, now unlocking', user) | |
2423 | # unlock if we have push from user who locked |
|
2423 | # unlock if we have push from user who locked | |
2424 | make_lock = False |
|
2424 | make_lock = False | |
2425 | else: |
|
2425 | else: | |
2426 | # we're not the same user who locked, ban with |
|
2426 | # we're not the same user who locked, ban with | |
2427 | # code defined in settings (default is 423 HTTP Locked) ! |
|
2427 | # code defined in settings (default is 423 HTTP Locked) ! | |
2428 | log.debug('Repo %s is currently locked by %s', repo, user) |
|
2428 | log.debug('Repo %s is currently locked by %s', repo, user) | |
2429 | currently_locked = True |
|
2429 | currently_locked = True | |
2430 | elif action == 'pull': |
|
2430 | elif action == 'pull': | |
2431 | # [0] user [1] date |
|
2431 | # [0] user [1] date | |
2432 | if lock_info[0] and lock_info[1]: |
|
2432 | if lock_info[0] and lock_info[1]: | |
2433 | log.debug('Repo %s is currently locked by %s', repo, user) |
|
2433 | log.debug('Repo %s is currently locked by %s', repo, user) | |
2434 | currently_locked = True |
|
2434 | currently_locked = True | |
2435 | else: |
|
2435 | else: | |
2436 | log.debug('Setting lock on repo %s by %s', repo, user) |
|
2436 | log.debug('Setting lock on repo %s by %s', repo, user) | |
2437 | make_lock = True |
|
2437 | make_lock = True | |
2438 |
|
2438 | |||
2439 | else: |
|
2439 | else: | |
2440 | log.debug('Repository %s do not have locking enabled', repo) |
|
2440 | log.debug('Repository %s do not have locking enabled', repo) | |
2441 |
|
2441 | |||
2442 | log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s', |
|
2442 | log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s', | |
2443 | make_lock, currently_locked, lock_info) |
|
2443 | make_lock, currently_locked, lock_info) | |
2444 |
|
2444 | |||
2445 | from rhodecode.lib.auth import HasRepoPermissionAny |
|
2445 | from rhodecode.lib.auth import HasRepoPermissionAny | |
2446 | perm_check = HasRepoPermissionAny('repository.write', 'repository.admin') |
|
2446 | perm_check = HasRepoPermissionAny('repository.write', 'repository.admin') | |
2447 | if make_lock and not perm_check(repo_name=repo.repo_name, user=user): |
|
2447 | if make_lock and not perm_check(repo_name=repo.repo_name, user=user): | |
2448 | # if we don't have at least write permission we cannot make a lock |
|
2448 | # if we don't have at least write permission we cannot make a lock | |
2449 | log.debug('lock state reset back to FALSE due to lack ' |
|
2449 | log.debug('lock state reset back to FALSE due to lack ' | |
2450 | 'of at least read permission') |
|
2450 | 'of at least read permission') | |
2451 | make_lock = False |
|
2451 | make_lock = False | |
2452 |
|
2452 | |||
2453 | return make_lock, currently_locked, lock_info |
|
2453 | return make_lock, currently_locked, lock_info | |
2454 |
|
2454 | |||
2455 | @property |
|
2455 | @property | |
2456 | def last_commit_cache_update_diff(self): |
|
2456 | def last_commit_cache_update_diff(self): | |
2457 | return time.time() - (safe_int(self.changeset_cache.get('updated_on')) or 0) |
|
2457 | return time.time() - (safe_int(self.changeset_cache.get('updated_on')) or 0) | |
2458 |
|
2458 | |||
2459 | @classmethod |
|
2459 | @classmethod | |
2460 | def _load_commit_change(cls, last_commit_cache): |
|
2460 | def _load_commit_change(cls, last_commit_cache): | |
2461 | from rhodecode.lib.vcs.utils.helpers import parse_datetime |
|
2461 | from rhodecode.lib.vcs.utils.helpers import parse_datetime | |
2462 | empty_date = datetime.datetime.fromtimestamp(0) |
|
2462 | empty_date = datetime.datetime.fromtimestamp(0) | |
2463 | date_latest = last_commit_cache.get('date', empty_date) |
|
2463 | date_latest = last_commit_cache.get('date', empty_date) | |
2464 | try: |
|
2464 | try: | |
2465 | return parse_datetime(date_latest) |
|
2465 | return parse_datetime(date_latest) | |
2466 | except Exception: |
|
2466 | except Exception: | |
2467 | return empty_date |
|
2467 | return empty_date | |
2468 |
|
2468 | |||
2469 | @property |
|
2469 | @property | |
2470 | def last_commit_change(self): |
|
2470 | def last_commit_change(self): | |
2471 | return self._load_commit_change(self.changeset_cache) |
|
2471 | return self._load_commit_change(self.changeset_cache) | |
2472 |
|
2472 | |||
2473 | @property |
|
2473 | @property | |
2474 | def last_db_change(self): |
|
2474 | def last_db_change(self): | |
2475 | return self.updated_on |
|
2475 | return self.updated_on | |
2476 |
|
2476 | |||
2477 | @property |
|
2477 | @property | |
2478 | def clone_uri_hidden(self): |
|
2478 | def clone_uri_hidden(self): | |
2479 | clone_uri = self.clone_uri |
|
2479 | clone_uri = self.clone_uri | |
2480 | if clone_uri: |
|
2480 | if clone_uri: | |
2481 | import urlobject |
|
2481 | import urlobject | |
2482 | url_obj = urlobject.URLObject(cleaned_uri(clone_uri)) |
|
2482 | url_obj = urlobject.URLObject(cleaned_uri(clone_uri)) | |
2483 | if url_obj.password: |
|
2483 | if url_obj.password: | |
2484 | clone_uri = url_obj.with_password('*****') |
|
2484 | clone_uri = url_obj.with_password('*****') | |
2485 | return clone_uri |
|
2485 | return clone_uri | |
2486 |
|
2486 | |||
2487 | @property |
|
2487 | @property | |
2488 | def push_uri_hidden(self): |
|
2488 | def push_uri_hidden(self): | |
2489 | push_uri = self.push_uri |
|
2489 | push_uri = self.push_uri | |
2490 | if push_uri: |
|
2490 | if push_uri: | |
2491 | import urlobject |
|
2491 | import urlobject | |
2492 | url_obj = urlobject.URLObject(cleaned_uri(push_uri)) |
|
2492 | url_obj = urlobject.URLObject(cleaned_uri(push_uri)) | |
2493 | if url_obj.password: |
|
2493 | if url_obj.password: | |
2494 | push_uri = url_obj.with_password('*****') |
|
2494 | push_uri = url_obj.with_password('*****') | |
2495 | return push_uri |
|
2495 | return push_uri | |
2496 |
|
2496 | |||
2497 | def clone_url(self, **override): |
|
2497 | def clone_url(self, **override): | |
2498 | from rhodecode.model.settings import SettingsModel |
|
2498 | from rhodecode.model.settings import SettingsModel | |
2499 |
|
2499 | |||
2500 | uri_tmpl = None |
|
2500 | uri_tmpl = None | |
2501 | if 'with_id' in override: |
|
2501 | if 'with_id' in override: | |
2502 | uri_tmpl = self.DEFAULT_CLONE_URI_ID |
|
2502 | uri_tmpl = self.DEFAULT_CLONE_URI_ID | |
2503 | del override['with_id'] |
|
2503 | del override['with_id'] | |
2504 |
|
2504 | |||
2505 | if 'uri_tmpl' in override: |
|
2505 | if 'uri_tmpl' in override: | |
2506 | uri_tmpl = override['uri_tmpl'] |
|
2506 | uri_tmpl = override['uri_tmpl'] | |
2507 | del override['uri_tmpl'] |
|
2507 | del override['uri_tmpl'] | |
2508 |
|
2508 | |||
2509 | ssh = False |
|
2509 | ssh = False | |
2510 | if 'ssh' in override: |
|
2510 | if 'ssh' in override: | |
2511 | ssh = True |
|
2511 | ssh = True | |
2512 | del override['ssh'] |
|
2512 | del override['ssh'] | |
2513 |
|
2513 | |||
2514 | # we didn't override our tmpl from **overrides |
|
2514 | # we didn't override our tmpl from **overrides | |
2515 | request = get_current_request() |
|
2515 | request = get_current_request() | |
2516 | if not uri_tmpl: |
|
2516 | if not uri_tmpl: | |
2517 | if hasattr(request, 'call_context') and hasattr(request.call_context, 'rc_config'): |
|
2517 | if hasattr(request, 'call_context') and hasattr(request.call_context, 'rc_config'): | |
2518 | rc_config = request.call_context.rc_config |
|
2518 | rc_config = request.call_context.rc_config | |
2519 | else: |
|
2519 | else: | |
2520 | rc_config = SettingsModel().get_all_settings(cache=True) |
|
2520 | rc_config = SettingsModel().get_all_settings(cache=True) | |
2521 |
|
2521 | |||
2522 | if ssh: |
|
2522 | if ssh: | |
2523 | uri_tmpl = rc_config.get( |
|
2523 | uri_tmpl = rc_config.get( | |
2524 | 'rhodecode_clone_uri_ssh_tmpl') or self.DEFAULT_CLONE_URI_SSH |
|
2524 | 'rhodecode_clone_uri_ssh_tmpl') or self.DEFAULT_CLONE_URI_SSH | |
2525 |
|
2525 | |||
2526 | else: |
|
2526 | else: | |
2527 | uri_tmpl = rc_config.get( |
|
2527 | uri_tmpl = rc_config.get( | |
2528 | 'rhodecode_clone_uri_tmpl') or self.DEFAULT_CLONE_URI |
|
2528 | 'rhodecode_clone_uri_tmpl') or self.DEFAULT_CLONE_URI | |
2529 |
|
2529 | |||
2530 | return get_clone_url(request=request, |
|
2530 | return get_clone_url(request=request, | |
2531 | uri_tmpl=uri_tmpl, |
|
2531 | uri_tmpl=uri_tmpl, | |
2532 | repo_name=self.repo_name, |
|
2532 | repo_name=self.repo_name, | |
2533 | repo_id=self.repo_id, |
|
2533 | repo_id=self.repo_id, | |
2534 | repo_type=self.repo_type, |
|
2534 | repo_type=self.repo_type, | |
2535 | **override) |
|
2535 | **override) | |
2536 |
|
2536 | |||
2537 | def set_state(self, state): |
|
2537 | def set_state(self, state): | |
2538 | self.repo_state = state |
|
2538 | self.repo_state = state | |
2539 | Session().add(self) |
|
2539 | Session().add(self) | |
2540 | #========================================================================== |
|
2540 | #========================================================================== | |
2541 | # SCM PROPERTIES |
|
2541 | # SCM PROPERTIES | |
2542 | #========================================================================== |
|
2542 | #========================================================================== | |
2543 |
|
2543 | |||
2544 | def get_commit(self, commit_id=None, commit_idx=None, pre_load=None, maybe_unreachable=False, reference_obj=None): |
|
2544 | def get_commit(self, commit_id=None, commit_idx=None, pre_load=None, maybe_unreachable=False, reference_obj=None): | |
2545 | return get_commit_safe( |
|
2545 | return get_commit_safe( | |
2546 | self.scm_instance(), commit_id, commit_idx, pre_load=pre_load, |
|
2546 | self.scm_instance(), commit_id, commit_idx, pre_load=pre_load, | |
2547 | maybe_unreachable=maybe_unreachable, reference_obj=reference_obj) |
|
2547 | maybe_unreachable=maybe_unreachable, reference_obj=reference_obj) | |
2548 |
|
2548 | |||
2549 | def get_changeset(self, rev=None, pre_load=None): |
|
2549 | def get_changeset(self, rev=None, pre_load=None): | |
2550 | warnings.warn("Use get_commit", DeprecationWarning) |
|
2550 | warnings.warn("Use get_commit", DeprecationWarning) | |
2551 | commit_id = None |
|
2551 | commit_id = None | |
2552 | commit_idx = None |
|
2552 | commit_idx = None | |
2553 | if isinstance(rev, str): |
|
2553 | if isinstance(rev, str): | |
2554 | commit_id = rev |
|
2554 | commit_id = rev | |
2555 | else: |
|
2555 | else: | |
2556 | commit_idx = rev |
|
2556 | commit_idx = rev | |
2557 | return self.get_commit(commit_id=commit_id, commit_idx=commit_idx, |
|
2557 | return self.get_commit(commit_id=commit_id, commit_idx=commit_idx, | |
2558 | pre_load=pre_load) |
|
2558 | pre_load=pre_load) | |
2559 |
|
2559 | |||
2560 | def get_landing_commit(self): |
|
2560 | def get_landing_commit(self): | |
2561 | """ |
|
2561 | """ | |
2562 | Returns landing commit, or if that doesn't exist returns the tip |
|
2562 | Returns landing commit, or if that doesn't exist returns the tip | |
2563 | """ |
|
2563 | """ | |
2564 | _rev_type, _rev = self.landing_rev |
|
2564 | _rev_type, _rev = self.landing_rev | |
2565 | commit = self.get_commit(_rev) |
|
2565 | commit = self.get_commit(_rev) | |
2566 | if isinstance(commit, EmptyCommit): |
|
2566 | if isinstance(commit, EmptyCommit): | |
2567 | return self.get_commit() |
|
2567 | return self.get_commit() | |
2568 | return commit |
|
2568 | return commit | |
2569 |
|
2569 | |||
2570 | def flush_commit_cache(self): |
|
2570 | def flush_commit_cache(self): | |
2571 | self.update_commit_cache(cs_cache={'raw_id':'0'}) |
|
2571 | self.update_commit_cache(cs_cache={'raw_id':'0'}) | |
2572 | self.update_commit_cache() |
|
2572 | self.update_commit_cache() | |
2573 |
|
2573 | |||
2574 | def update_commit_cache(self, cs_cache=None, config=None): |
|
2574 | def update_commit_cache(self, cs_cache=None, config=None): | |
2575 | """ |
|
2575 | """ | |
2576 | Update cache of last commit for repository |
|
2576 | Update cache of last commit for repository | |
2577 | cache_keys should be:: |
|
2577 | cache_keys should be:: | |
2578 |
|
2578 | |||
2579 | source_repo_id |
|
2579 | source_repo_id | |
2580 | short_id |
|
2580 | short_id | |
2581 | raw_id |
|
2581 | raw_id | |
2582 | revision |
|
2582 | revision | |
2583 | parents |
|
2583 | parents | |
2584 | message |
|
2584 | message | |
2585 | date |
|
2585 | date | |
2586 | author |
|
2586 | author | |
2587 | updated_on |
|
2587 | updated_on | |
2588 |
|
2588 | |||
2589 | """ |
|
2589 | """ | |
2590 | from rhodecode.lib.vcs.backends.base import BaseCommit |
|
2590 | from rhodecode.lib.vcs.backends.base import BaseCommit | |
2591 | from rhodecode.lib.vcs.utils.helpers import parse_datetime |
|
2591 | from rhodecode.lib.vcs.utils.helpers import parse_datetime | |
2592 | empty_date = datetime.datetime.fromtimestamp(0) |
|
2592 | empty_date = datetime.datetime.fromtimestamp(0) | |
2593 | repo_commit_count = 0 |
|
2593 | repo_commit_count = 0 | |
2594 |
|
2594 | |||
2595 | if cs_cache is None: |
|
2595 | if cs_cache is None: | |
2596 | # use no-cache version here |
|
2596 | # use no-cache version here | |
2597 | try: |
|
2597 | try: | |
2598 | scm_repo = self.scm_instance(cache=False, config=config) |
|
2598 | scm_repo = self.scm_instance(cache=False, config=config) | |
2599 | except VCSError: |
|
2599 | except VCSError: | |
2600 | scm_repo = None |
|
2600 | scm_repo = None | |
2601 | empty = scm_repo is None or scm_repo.is_empty() |
|
2601 | empty = scm_repo is None or scm_repo.is_empty() | |
2602 |
|
2602 | |||
2603 | if not empty: |
|
2603 | if not empty: | |
2604 | cs_cache = scm_repo.get_commit( |
|
2604 | cs_cache = scm_repo.get_commit( | |
2605 | pre_load=["author", "date", "message", "parents", "branch"]) |
|
2605 | pre_load=["author", "date", "message", "parents", "branch"]) | |
2606 | repo_commit_count = scm_repo.count() |
|
2606 | repo_commit_count = scm_repo.count() | |
2607 | else: |
|
2607 | else: | |
2608 | cs_cache = EmptyCommit() |
|
2608 | cs_cache = EmptyCommit() | |
2609 |
|
2609 | |||
2610 | if isinstance(cs_cache, BaseCommit): |
|
2610 | if isinstance(cs_cache, BaseCommit): | |
2611 | cs_cache = cs_cache.__json__() |
|
2611 | cs_cache = cs_cache.__json__() | |
2612 |
|
2612 | |||
2613 | def is_outdated(new_cs_cache): |
|
2613 | def is_outdated(new_cs_cache): | |
2614 | if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or |
|
2614 | if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or | |
2615 | new_cs_cache['revision'] != self.changeset_cache['revision']): |
|
2615 | new_cs_cache['revision'] != self.changeset_cache['revision']): | |
2616 | return True |
|
2616 | return True | |
2617 | return False |
|
2617 | return False | |
2618 |
|
2618 | |||
2619 | # check if we have maybe already latest cached revision |
|
2619 | # check if we have maybe already latest cached revision | |
2620 | if is_outdated(cs_cache) or not self.changeset_cache: |
|
2620 | if is_outdated(cs_cache) or not self.changeset_cache: | |
2621 | _current_datetime = datetime.datetime.utcnow() |
|
2621 | _current_datetime = datetime.datetime.utcnow() | |
2622 | last_change = cs_cache.get('date') or _current_datetime |
|
2622 | last_change = cs_cache.get('date') or _current_datetime | |
2623 | # we check if last update is newer than the new value |
|
2623 | # we check if last update is newer than the new value | |
2624 | # if yes, we use the current timestamp instead. Imagine you get |
|
2624 | # if yes, we use the current timestamp instead. Imagine you get | |
2625 | # old commit pushed 1y ago, we'd set last update 1y to ago. |
|
2625 | # old commit pushed 1y ago, we'd set last update 1y to ago. | |
2626 | last_change_timestamp = datetime_to_time(last_change) |
|
2626 | last_change_timestamp = datetime_to_time(last_change) | |
2627 | current_timestamp = datetime_to_time(last_change) |
|
2627 | current_timestamp = datetime_to_time(last_change) | |
2628 | if last_change_timestamp > current_timestamp and not empty: |
|
2628 | if last_change_timestamp > current_timestamp and not empty: | |
2629 | cs_cache['date'] = _current_datetime |
|
2629 | cs_cache['date'] = _current_datetime | |
2630 |
|
2630 | |||
2631 | # also store size of repo |
|
2631 | # also store size of repo | |
2632 | cs_cache['repo_commit_count'] = repo_commit_count |
|
2632 | cs_cache['repo_commit_count'] = repo_commit_count | |
2633 |
|
2633 | |||
2634 | _date_latest = parse_datetime(cs_cache.get('date') or empty_date) |
|
2634 | _date_latest = parse_datetime(cs_cache.get('date') or empty_date) | |
2635 | cs_cache['updated_on'] = time.time() |
|
2635 | cs_cache['updated_on'] = time.time() | |
2636 | self.changeset_cache = cs_cache |
|
2636 | self.changeset_cache = cs_cache | |
2637 | self.updated_on = last_change |
|
2637 | self.updated_on = last_change | |
2638 | Session().add(self) |
|
2638 | Session().add(self) | |
2639 | Session().commit() |
|
2639 | Session().commit() | |
2640 |
|
2640 | |||
2641 | else: |
|
2641 | else: | |
2642 | if empty: |
|
2642 | if empty: | |
2643 | cs_cache = EmptyCommit().__json__() |
|
2643 | cs_cache = EmptyCommit().__json__() | |
2644 | else: |
|
2644 | else: | |
2645 | cs_cache = self.changeset_cache |
|
2645 | cs_cache = self.changeset_cache | |
2646 |
|
2646 | |||
2647 | _date_latest = parse_datetime(cs_cache.get('date') or empty_date) |
|
2647 | _date_latest = parse_datetime(cs_cache.get('date') or empty_date) | |
2648 |
|
2648 | |||
2649 | cs_cache['updated_on'] = time.time() |
|
2649 | cs_cache['updated_on'] = time.time() | |
2650 | self.changeset_cache = cs_cache |
|
2650 | self.changeset_cache = cs_cache | |
2651 | self.updated_on = _date_latest |
|
2651 | self.updated_on = _date_latest | |
2652 | Session().add(self) |
|
2652 | Session().add(self) | |
2653 | Session().commit() |
|
2653 | Session().commit() | |
2654 |
|
2654 | |||
2655 | log.debug('updated repo `%s` with new commit cache %s, and last update_date: %s', |
|
2655 | log.debug('updated repo `%s` with new commit cache %s, and last update_date: %s', | |
2656 | self.repo_name, cs_cache, _date_latest) |
|
2656 | self.repo_name, cs_cache, _date_latest) | |
2657 |
|
2657 | |||
2658 | @property |
|
2658 | @property | |
2659 | def tip(self): |
|
2659 | def tip(self): | |
2660 | return self.get_commit('tip') |
|
2660 | return self.get_commit('tip') | |
2661 |
|
2661 | |||
2662 | @property |
|
2662 | @property | |
2663 | def author(self): |
|
2663 | def author(self): | |
2664 | return self.tip.author |
|
2664 | return self.tip.author | |
2665 |
|
2665 | |||
2666 | @property |
|
2666 | @property | |
2667 | def last_change(self): |
|
2667 | def last_change(self): | |
2668 | return self.scm_instance().last_change |
|
2668 | return self.scm_instance().last_change | |
2669 |
|
2669 | |||
2670 | def get_comments(self, revisions=None): |
|
2670 | def get_comments(self, revisions=None): | |
2671 | """ |
|
2671 | """ | |
2672 | Returns comments for this repository grouped by revisions |
|
2672 | Returns comments for this repository grouped by revisions | |
2673 |
|
2673 | |||
2674 | :param revisions: filter query by revisions only |
|
2674 | :param revisions: filter query by revisions only | |
2675 | """ |
|
2675 | """ | |
2676 | cmts = ChangesetComment.query()\ |
|
2676 | cmts = ChangesetComment.query()\ | |
2677 | .filter(ChangesetComment.repo == self) |
|
2677 | .filter(ChangesetComment.repo == self) | |
2678 | if revisions: |
|
2678 | if revisions: | |
2679 | cmts = cmts.filter(ChangesetComment.revision.in_(revisions)) |
|
2679 | cmts = cmts.filter(ChangesetComment.revision.in_(revisions)) | |
2680 | grouped = collections.defaultdict(list) |
|
2680 | grouped = collections.defaultdict(list) | |
2681 | for cmt in cmts.all(): |
|
2681 | for cmt in cmts.all(): | |
2682 | grouped[cmt.revision].append(cmt) |
|
2682 | grouped[cmt.revision].append(cmt) | |
2683 | return grouped |
|
2683 | return grouped | |
2684 |
|
2684 | |||
2685 | def statuses(self, revisions=None): |
|
2685 | def statuses(self, revisions=None): | |
2686 | """ |
|
2686 | """ | |
2687 | Returns statuses for this repository |
|
2687 | Returns statuses for this repository | |
2688 |
|
2688 | |||
2689 | :param revisions: list of revisions to get statuses for |
|
2689 | :param revisions: list of revisions to get statuses for | |
2690 | """ |
|
2690 | """ | |
2691 | statuses = ChangesetStatus.query()\ |
|
2691 | statuses = ChangesetStatus.query()\ | |
2692 | .filter(ChangesetStatus.repo == self)\ |
|
2692 | .filter(ChangesetStatus.repo == self)\ | |
2693 | .filter(ChangesetStatus.version == 0) |
|
2693 | .filter(ChangesetStatus.version == 0) | |
2694 |
|
2694 | |||
2695 | if revisions: |
|
2695 | if revisions: | |
2696 | # Try doing the filtering in chunks to avoid hitting limits |
|
2696 | # Try doing the filtering in chunks to avoid hitting limits | |
2697 | size = 500 |
|
2697 | size = 500 | |
2698 | status_results = [] |
|
2698 | status_results = [] | |
2699 | for chunk in range(0, len(revisions), size): |
|
2699 | for chunk in range(0, len(revisions), size): | |
2700 | status_results += statuses.filter( |
|
2700 | status_results += statuses.filter( | |
2701 | ChangesetStatus.revision.in_( |
|
2701 | ChangesetStatus.revision.in_( | |
2702 | revisions[chunk: chunk+size]) |
|
2702 | revisions[chunk: chunk+size]) | |
2703 | ).all() |
|
2703 | ).all() | |
2704 | else: |
|
2704 | else: | |
2705 | status_results = statuses.all() |
|
2705 | status_results = statuses.all() | |
2706 |
|
2706 | |||
2707 | grouped = {} |
|
2707 | grouped = {} | |
2708 |
|
2708 | |||
2709 | # maybe we have open new pullrequest without a status? |
|
2709 | # maybe we have open new pullrequest without a status? | |
2710 | stat = ChangesetStatus.STATUS_UNDER_REVIEW |
|
2710 | stat = ChangesetStatus.STATUS_UNDER_REVIEW | |
2711 | status_lbl = ChangesetStatus.get_status_lbl(stat) |
|
2711 | status_lbl = ChangesetStatus.get_status_lbl(stat) | |
2712 | for pr in PullRequest.query().filter(PullRequest.source_repo == self).all(): |
|
2712 | for pr in PullRequest.query().filter(PullRequest.source_repo == self).all(): | |
2713 | for rev in pr.revisions: |
|
2713 | for rev in pr.revisions: | |
2714 | pr_id = pr.pull_request_id |
|
2714 | pr_id = pr.pull_request_id | |
2715 | pr_repo = pr.target_repo.repo_name |
|
2715 | pr_repo = pr.target_repo.repo_name | |
2716 | grouped[rev] = [stat, status_lbl, pr_id, pr_repo] |
|
2716 | grouped[rev] = [stat, status_lbl, pr_id, pr_repo] | |
2717 |
|
2717 | |||
2718 | for stat in status_results: |
|
2718 | for stat in status_results: | |
2719 | pr_id = pr_repo = None |
|
2719 | pr_id = pr_repo = None | |
2720 | if stat.pull_request: |
|
2720 | if stat.pull_request: | |
2721 | pr_id = stat.pull_request.pull_request_id |
|
2721 | pr_id = stat.pull_request.pull_request_id | |
2722 | pr_repo = stat.pull_request.target_repo.repo_name |
|
2722 | pr_repo = stat.pull_request.target_repo.repo_name | |
2723 | grouped[stat.revision] = [str(stat.status), stat.status_lbl, |
|
2723 | grouped[stat.revision] = [str(stat.status), stat.status_lbl, | |
2724 | pr_id, pr_repo] |
|
2724 | pr_id, pr_repo] | |
2725 | return grouped |
|
2725 | return grouped | |
2726 |
|
2726 | |||
2727 | # ========================================================================== |
|
2727 | # ========================================================================== | |
2728 | # SCM CACHE INSTANCE |
|
2728 | # SCM CACHE INSTANCE | |
2729 | # ========================================================================== |
|
2729 | # ========================================================================== | |
2730 |
|
2730 | |||
2731 | def scm_instance(self, **kwargs): |
|
2731 | def scm_instance(self, **kwargs): | |
2732 | import rhodecode |
|
2732 | import rhodecode | |
2733 |
|
2733 | |||
2734 | # Passing a config will not hit the cache currently only used |
|
2734 | # Passing a config will not hit the cache currently only used | |
2735 | # for repo2dbmapper |
|
2735 | # for repo2dbmapper | |
2736 | config = kwargs.pop('config', None) |
|
2736 | config = kwargs.pop('config', None) | |
2737 | cache = kwargs.pop('cache', None) |
|
2737 | cache = kwargs.pop('cache', None) | |
2738 | vcs_full_cache = kwargs.pop('vcs_full_cache', None) |
|
2738 | vcs_full_cache = kwargs.pop('vcs_full_cache', None) | |
2739 | if vcs_full_cache is not None: |
|
2739 | if vcs_full_cache is not None: | |
2740 | # allows override global config |
|
2740 | # allows override global config | |
2741 | full_cache = vcs_full_cache |
|
2741 | full_cache = vcs_full_cache | |
2742 | else: |
|
2742 | else: | |
2743 | full_cache = rhodecode.ConfigGet().get_bool('vcs_full_cache') |
|
2743 | full_cache = rhodecode.ConfigGet().get_bool('vcs_full_cache') | |
2744 | # if cache is NOT defined use default global, else we have a full |
|
2744 | # if cache is NOT defined use default global, else we have a full | |
2745 | # control over cache behaviour |
|
2745 | # control over cache behaviour | |
2746 | if cache is None and full_cache and not config: |
|
2746 | if cache is None and full_cache and not config: | |
2747 | log.debug('Initializing pure cached instance for %s', self.repo_path) |
|
2747 | log.debug('Initializing pure cached instance for %s', self.repo_path) | |
2748 | return self._get_instance_cached() |
|
2748 | return self._get_instance_cached() | |
2749 |
|
2749 | |||
2750 | # cache here is sent to the "vcs server" |
|
2750 | # cache here is sent to the "vcs server" | |
2751 | return self._get_instance(cache=bool(cache), config=config) |
|
2751 | return self._get_instance(cache=bool(cache), config=config) | |
2752 |
|
2752 | |||
2753 | def _get_instance_cached(self): |
|
2753 | def _get_instance_cached(self): | |
2754 | from rhodecode.lib import rc_cache |
|
2754 | from rhodecode.lib import rc_cache | |
2755 |
|
2755 | |||
2756 | cache_namespace_uid = f'repo_instance.{self.repo_id}' |
|
2756 | cache_namespace_uid = f'repo_instance.{self.repo_id}' | |
2757 | region = rc_cache.get_or_create_region('cache_repo_longterm', cache_namespace_uid) |
|
2757 | region = rc_cache.get_or_create_region('cache_repo_longterm', cache_namespace_uid) | |
2758 |
|
2758 | |||
2759 | # we must use thread scoped cache here, |
|
2759 | # we must use thread scoped cache here, | |
2760 | # because each thread of gevent needs it's own not shared connection and cache |
|
2760 | # because each thread of gevent needs it's own not shared connection and cache | |
2761 | # we also alter `args` so the cache key is individual for every green thread. |
|
2761 | # we also alter `args` so the cache key is individual for every green thread. | |
2762 | repo_namespace_key = CacheKey.REPO_INVALIDATION_NAMESPACE.format(repo_id=self.repo_id) |
|
2762 | repo_namespace_key = CacheKey.REPO_INVALIDATION_NAMESPACE.format(repo_id=self.repo_id) | |
2763 | inv_context_manager = rc_cache.InvalidationContext(key=repo_namespace_key, thread_scoped=True) |
|
2763 | inv_context_manager = rc_cache.InvalidationContext(key=repo_namespace_key, thread_scoped=True) | |
2764 |
|
2764 | |||
2765 | # our wrapped caching function that takes state_uid to save the previous state in |
|
2765 | # our wrapped caching function that takes state_uid to save the previous state in | |
2766 | def cache_generator(_state_uid): |
|
2766 | def cache_generator(_state_uid): | |
2767 |
|
2767 | |||
2768 | @region.conditional_cache_on_arguments(namespace=cache_namespace_uid) |
|
2768 | @region.conditional_cache_on_arguments(namespace=cache_namespace_uid) | |
2769 | def get_instance_cached(_repo_id, _process_context_id): |
|
2769 | def get_instance_cached(_repo_id, _process_context_id): | |
2770 | # we save in cached func the generation state so we can detect a change and invalidate caches |
|
2770 | # we save in cached func the generation state so we can detect a change and invalidate caches | |
2771 | return _state_uid, self._get_instance(repo_state_uid=_state_uid) |
|
2771 | return _state_uid, self._get_instance(repo_state_uid=_state_uid) | |
2772 |
|
2772 | |||
2773 | return get_instance_cached |
|
2773 | return get_instance_cached | |
2774 |
|
2774 | |||
2775 | with inv_context_manager as invalidation_context: |
|
2775 | with inv_context_manager as invalidation_context: | |
2776 | cache_state_uid = invalidation_context.state_uid |
|
2776 | cache_state_uid = invalidation_context.state_uid | |
2777 | cache_func = cache_generator(cache_state_uid) |
|
2777 | cache_func = cache_generator(cache_state_uid) | |
2778 |
|
2778 | |||
2779 | args = self.repo_id, inv_context_manager.proc_key |
|
2779 | args = self.repo_id, inv_context_manager.proc_key | |
2780 |
|
2780 | |||
2781 | previous_state_uid, instance = cache_func(*args) |
|
2781 | previous_state_uid, instance = cache_func(*args) | |
2782 |
|
2782 | |||
2783 | # now compare keys, the "cache" state vs expected state. |
|
2783 | # now compare keys, the "cache" state vs expected state. | |
2784 | if previous_state_uid != cache_state_uid: |
|
2784 | if previous_state_uid != cache_state_uid: | |
2785 | log.warning('Cached state uid %s is different than current state uid %s', |
|
2785 | log.warning('Cached state uid %s is different than current state uid %s', | |
2786 | previous_state_uid, cache_state_uid) |
|
2786 | previous_state_uid, cache_state_uid) | |
2787 | _, instance = cache_func.refresh(*args) |
|
2787 | _, instance = cache_func.refresh(*args) | |
2788 |
|
2788 | |||
2789 | log.debug('Repo instance fetched in %.4fs', inv_context_manager.compute_time) |
|
2789 | log.debug('Repo instance fetched in %.4fs', inv_context_manager.compute_time) | |
2790 | return instance |
|
2790 | return instance | |
2791 |
|
2791 | |||
2792 | def _get_instance(self, cache=True, config=None, repo_state_uid=None): |
|
2792 | def _get_instance(self, cache=True, config=None, repo_state_uid=None): | |
2793 | log.debug('Initializing %s instance `%s` with cache flag set to: %s', |
|
2793 | log.debug('Initializing %s instance `%s` with cache flag set to: %s', | |
2794 | self.repo_type, self.repo_path, cache) |
|
2794 | self.repo_type, self.repo_path, cache) | |
2795 | config = config or self._config |
|
2795 | config = config or self._config | |
2796 | custom_wire = { |
|
2796 | custom_wire = { | |
2797 | 'cache': cache, # controls the vcs.remote cache |
|
2797 | 'cache': cache, # controls the vcs.remote cache | |
2798 | 'repo_state_uid': repo_state_uid |
|
2798 | 'repo_state_uid': repo_state_uid | |
2799 | } |
|
2799 | } | |
2800 |
|
2800 | |||
2801 | repo = get_vcs_instance( |
|
2801 | repo = get_vcs_instance( | |
2802 | repo_path=safe_str(self.repo_full_path), |
|
2802 | repo_path=safe_str(self.repo_full_path), | |
2803 | config=config, |
|
2803 | config=config, | |
2804 | with_wire=custom_wire, |
|
2804 | with_wire=custom_wire, | |
2805 | create=False, |
|
2805 | create=False, | |
2806 | _vcs_alias=self.repo_type) |
|
2806 | _vcs_alias=self.repo_type) | |
2807 | if repo is not None: |
|
2807 | if repo is not None: | |
2808 | repo.count() # cache rebuild |
|
2808 | repo.count() # cache rebuild | |
2809 |
|
2809 | |||
2810 | return repo |
|
2810 | return repo | |
2811 |
|
2811 | |||
2812 | def get_shadow_repository_path(self, workspace_id): |
|
2812 | def get_shadow_repository_path(self, workspace_id): | |
2813 | from rhodecode.lib.vcs.backends.base import BaseRepository |
|
2813 | from rhodecode.lib.vcs.backends.base import BaseRepository | |
2814 | shadow_repo_path = BaseRepository._get_shadow_repository_path( |
|
2814 | shadow_repo_path = BaseRepository._get_shadow_repository_path( | |
2815 | self.repo_full_path, self.repo_id, workspace_id) |
|
2815 | self.repo_full_path, self.repo_id, workspace_id) | |
2816 | return shadow_repo_path |
|
2816 | return shadow_repo_path | |
2817 |
|
2817 | |||
2818 | def __json__(self): |
|
2818 | def __json__(self): | |
2819 | return {'landing_rev': self.landing_rev} |
|
2819 | return {'landing_rev': self.landing_rev} | |
2820 |
|
2820 | |||
2821 | def get_dict(self): |
|
2821 | def get_dict(self): | |
2822 |
|
2822 | |||
2823 | # Since we transformed `repo_name` to a hybrid property, we need to |
|
2823 | # Since we transformed `repo_name` to a hybrid property, we need to | |
2824 | # keep compatibility with the code which uses `repo_name` field. |
|
2824 | # keep compatibility with the code which uses `repo_name` field. | |
2825 |
|
2825 | |||
2826 | result = super(Repository, self).get_dict() |
|
2826 | result = super(Repository, self).get_dict() | |
2827 | result['repo_name'] = result.pop('_repo_name', None) |
|
2827 | result['repo_name'] = result.pop('_repo_name', None) | |
2828 | result.pop('_changeset_cache', '') |
|
2828 | result.pop('_changeset_cache', '') | |
2829 | return result |
|
2829 | return result | |
2830 |
|
2830 | |||
2831 |
|
2831 | |||
2832 | class RepoGroup(Base, BaseModel): |
|
2832 | class RepoGroup(Base, BaseModel): | |
2833 | __tablename__ = 'groups' |
|
2833 | __tablename__ = 'groups' | |
2834 | __table_args__ = ( |
|
2834 | __table_args__ = ( | |
2835 | UniqueConstraint('group_name', 'group_parent_id'), |
|
2835 | UniqueConstraint('group_name', 'group_parent_id'), | |
2836 | base_table_args, |
|
2836 | base_table_args, | |
2837 | ) |
|
2837 | ) | |
2838 |
|
2838 | |||
2839 | CHOICES_SEPARATOR = '/' # used to generate select2 choices for nested groups |
|
2839 | CHOICES_SEPARATOR = '/' # used to generate select2 choices for nested groups | |
2840 |
|
2840 | |||
2841 | group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
2841 | group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
2842 | _group_name = Column("group_name", String(255), nullable=False, unique=True, default=None) |
|
2842 | _group_name = Column("group_name", String(255), nullable=False, unique=True, default=None) | |
2843 | group_name_hash = Column("repo_group_name_hash", String(1024), nullable=False, unique=False) |
|
2843 | group_name_hash = Column("repo_group_name_hash", String(1024), nullable=False, unique=False) | |
2844 | group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None) |
|
2844 | group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None) | |
2845 | group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None) |
|
2845 | group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None) | |
2846 | enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False) |
|
2846 | enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False) | |
2847 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None) |
|
2847 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None) | |
2848 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
2848 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
2849 | updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now) |
|
2849 | updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now) | |
2850 | personal = Column('personal', Boolean(), nullable=True, unique=None, default=None) |
|
2850 | personal = Column('personal', Boolean(), nullable=True, unique=None, default=None) | |
2851 | _changeset_cache = Column("changeset_cache", LargeBinary(), nullable=True) # JSON data |
|
2851 | _changeset_cache = Column("changeset_cache", LargeBinary(), nullable=True) # JSON data | |
2852 |
|
2852 | |||
2853 | repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id', back_populates='group') |
|
2853 | repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id', back_populates='group') | |
2854 | users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all', back_populates='group') |
|
2854 | users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all', back_populates='group') | |
2855 | parent_group = relationship('RepoGroup', remote_side=group_id) |
|
2855 | parent_group = relationship('RepoGroup', remote_side=group_id) | |
2856 | user = relationship('User', back_populates='repository_groups') |
|
2856 | user = relationship('User', back_populates='repository_groups') | |
2857 | integrations = relationship('Integration', cascade="all, delete-orphan", back_populates='repo_group') |
|
2857 | integrations = relationship('Integration', cascade="all, delete-orphan", back_populates='repo_group') | |
2858 |
|
2858 | |||
2859 | # no cascade, set NULL |
|
2859 | # no cascade, set NULL | |
2860 | scope_artifacts = relationship('FileStore', primaryjoin='FileStore.scope_repo_group_id==RepoGroup.group_id', viewonly=True) |
|
2860 | scope_artifacts = relationship('FileStore', primaryjoin='FileStore.scope_repo_group_id==RepoGroup.group_id', viewonly=True) | |
2861 |
|
2861 | |||
2862 | def __init__(self, group_name='', parent_group=None): |
|
2862 | def __init__(self, group_name='', parent_group=None): | |
2863 | self.group_name = group_name |
|
2863 | self.group_name = group_name | |
2864 | self.parent_group = parent_group |
|
2864 | self.parent_group = parent_group | |
2865 |
|
2865 | |||
2866 | def __repr__(self): |
|
2866 | def __repr__(self): | |
2867 | return f"<{self.cls_name}('id:{self.group_id}:{self.group_name}')>" |
|
2867 | return f"<{self.cls_name}('id:{self.group_id}:{self.group_name}')>" | |
2868 |
|
2868 | |||
2869 | @hybrid_property |
|
2869 | @hybrid_property | |
2870 | def group_name(self): |
|
2870 | def group_name(self): | |
2871 | return self._group_name |
|
2871 | return self._group_name | |
2872 |
|
2872 | |||
2873 | @group_name.setter |
|
2873 | @group_name.setter | |
2874 | def group_name(self, value): |
|
2874 | def group_name(self, value): | |
2875 | self._group_name = value |
|
2875 | self._group_name = value | |
2876 | self.group_name_hash = self.hash_repo_group_name(value) |
|
2876 | self.group_name_hash = self.hash_repo_group_name(value) | |
2877 |
|
2877 | |||
2878 | @classmethod |
|
2878 | @classmethod | |
2879 | def _load_changeset_cache(cls, repo_id, changeset_cache_raw): |
|
2879 | def _load_changeset_cache(cls, repo_id, changeset_cache_raw): | |
2880 | from rhodecode.lib.vcs.backends.base import EmptyCommit |
|
2880 | from rhodecode.lib.vcs.backends.base import EmptyCommit | |
2881 | dummy = EmptyCommit().__json__() |
|
2881 | dummy = EmptyCommit().__json__() | |
2882 | if not changeset_cache_raw: |
|
2882 | if not changeset_cache_raw: | |
2883 | dummy['source_repo_id'] = repo_id |
|
2883 | dummy['source_repo_id'] = repo_id | |
2884 | return json.loads(json.dumps(dummy)) |
|
2884 | return json.loads(json.dumps(dummy)) | |
2885 |
|
2885 | |||
2886 | try: |
|
2886 | try: | |
2887 | return json.loads(changeset_cache_raw) |
|
2887 | return json.loads(changeset_cache_raw) | |
2888 | except TypeError: |
|
2888 | except TypeError: | |
2889 | return dummy |
|
2889 | return dummy | |
2890 | except Exception: |
|
2890 | except Exception: | |
2891 | log.error(traceback.format_exc()) |
|
2891 | log.error(traceback.format_exc()) | |
2892 | return dummy |
|
2892 | return dummy | |
2893 |
|
2893 | |||
2894 | @hybrid_property |
|
2894 | @hybrid_property | |
2895 | def changeset_cache(self): |
|
2895 | def changeset_cache(self): | |
2896 | return self._load_changeset_cache('', self._changeset_cache) |
|
2896 | return self._load_changeset_cache('', self._changeset_cache) | |
2897 |
|
2897 | |||
2898 | @changeset_cache.setter |
|
2898 | @changeset_cache.setter | |
2899 | def changeset_cache(self, val): |
|
2899 | def changeset_cache(self, val): | |
2900 | try: |
|
2900 | try: | |
2901 | self._changeset_cache = json.dumps(val) |
|
2901 | self._changeset_cache = json.dumps(val) | |
2902 | except Exception: |
|
2902 | except Exception: | |
2903 | log.error(traceback.format_exc()) |
|
2903 | log.error(traceback.format_exc()) | |
2904 |
|
2904 | |||
2905 | @validates('group_parent_id') |
|
2905 | @validates('group_parent_id') | |
2906 | def validate_group_parent_id(self, key, val): |
|
2906 | def validate_group_parent_id(self, key, val): | |
2907 | """ |
|
2907 | """ | |
2908 | Check cycle references for a parent group to self |
|
2908 | Check cycle references for a parent group to self | |
2909 | """ |
|
2909 | """ | |
2910 | if self.group_id and val: |
|
2910 | if self.group_id and val: | |
2911 | assert val != self.group_id |
|
2911 | assert val != self.group_id | |
2912 |
|
2912 | |||
2913 | return val |
|
2913 | return val | |
2914 |
|
2914 | |||
2915 | @hybrid_property |
|
2915 | @hybrid_property | |
2916 | def description_safe(self): |
|
2916 | def description_safe(self): | |
2917 | return description_escaper(self.group_description) |
|
2917 | return description_escaper(self.group_description) | |
2918 |
|
2918 | |||
2919 | @classmethod |
|
2919 | @classmethod | |
2920 | def hash_repo_group_name(cls, repo_group_name): |
|
2920 | def hash_repo_group_name(cls, repo_group_name): | |
2921 | val = remove_formatting(repo_group_name) |
|
2921 | val = remove_formatting(repo_group_name) | |
2922 | val = safe_str(val).lower() |
|
2922 | val = safe_str(val).lower() | |
2923 | chars = [] |
|
2923 | chars = [] | |
2924 | for c in val: |
|
2924 | for c in val: | |
2925 | if c not in string.ascii_letters: |
|
2925 | if c not in string.ascii_letters: | |
2926 | c = str(ord(c)) |
|
2926 | c = str(ord(c)) | |
2927 | chars.append(c) |
|
2927 | chars.append(c) | |
2928 |
|
2928 | |||
2929 | return ''.join(chars) |
|
2929 | return ''.join(chars) | |
2930 |
|
2930 | |||
2931 | @classmethod |
|
2931 | @classmethod | |
2932 | def _generate_choice(cls, repo_group): |
|
2932 | def _generate_choice(cls, repo_group): | |
2933 | from webhelpers2.html import literal as _literal |
|
2933 | from webhelpers2.html import literal as _literal | |
2934 |
|
2934 | |||
2935 | def _name(k): |
|
2935 | def _name(k): | |
2936 | return _literal(cls.CHOICES_SEPARATOR.join(k)) |
|
2936 | return _literal(cls.CHOICES_SEPARATOR.join(k)) | |
2937 |
|
2937 | |||
2938 | return repo_group.group_id, _name(repo_group.full_path_splitted) |
|
2938 | return repo_group.group_id, _name(repo_group.full_path_splitted) | |
2939 |
|
2939 | |||
2940 | @classmethod |
|
2940 | @classmethod | |
2941 | def groups_choices(cls, groups=None, show_empty_group=True): |
|
2941 | def groups_choices(cls, groups=None, show_empty_group=True): | |
2942 | if not groups: |
|
2942 | if not groups: | |
2943 | groups = cls.query().all() |
|
2943 | groups = cls.query().all() | |
2944 |
|
2944 | |||
2945 | repo_groups = [] |
|
2945 | repo_groups = [] | |
2946 | if show_empty_group: |
|
2946 | if show_empty_group: | |
2947 | repo_groups = [(-1, '-- %s --' % _('No parent'))] |
|
2947 | repo_groups = [(-1, '-- %s --' % _('No parent'))] | |
2948 |
|
2948 | |||
2949 | repo_groups.extend([cls._generate_choice(x) for x in groups]) |
|
2949 | repo_groups.extend([cls._generate_choice(x) for x in groups]) | |
2950 |
|
2950 | |||
2951 | repo_groups = sorted( |
|
2951 | repo_groups = sorted( | |
2952 | repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0]) |
|
2952 | repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0]) | |
2953 | return repo_groups |
|
2953 | return repo_groups | |
2954 |
|
2954 | |||
2955 | @classmethod |
|
2955 | @classmethod | |
2956 | def url_sep(cls): |
|
2956 | def url_sep(cls): | |
2957 | return URL_SEP |
|
2957 | return URL_SEP | |
2958 |
|
2958 | |||
2959 | @classmethod |
|
2959 | @classmethod | |
2960 | def get_by_group_name(cls, group_name, cache=False, case_insensitive=False): |
|
2960 | def get_by_group_name(cls, group_name, cache=False, case_insensitive=False): | |
2961 | if case_insensitive: |
|
2961 | if case_insensitive: | |
2962 | gr = cls.query().filter(func.lower(cls.group_name) |
|
2962 | gr = cls.query().filter(func.lower(cls.group_name) | |
2963 | == func.lower(group_name)) |
|
2963 | == func.lower(group_name)) | |
2964 | else: |
|
2964 | else: | |
2965 | gr = cls.query().filter(cls.group_name == group_name) |
|
2965 | gr = cls.query().filter(cls.group_name == group_name) | |
2966 | if cache: |
|
2966 | if cache: | |
2967 | name_key = _hash_key(group_name) |
|
2967 | name_key = _hash_key(group_name) | |
2968 | gr = gr.options( |
|
2968 | gr = gr.options( | |
2969 | FromCache("sql_cache_short", f"get_group_{name_key}")) |
|
2969 | FromCache("sql_cache_short", f"get_group_{name_key}")) | |
2970 | return gr.scalar() |
|
2970 | return gr.scalar() | |
2971 |
|
2971 | |||
2972 | @classmethod |
|
2972 | @classmethod | |
2973 | def get_user_personal_repo_group(cls, user_id): |
|
2973 | def get_user_personal_repo_group(cls, user_id): | |
2974 | user = User.get(user_id) |
|
2974 | user = User.get(user_id) | |
2975 | if user.username == User.DEFAULT_USER: |
|
2975 | if user.username == User.DEFAULT_USER: | |
2976 | return None |
|
2976 | return None | |
2977 |
|
2977 | |||
2978 | return cls.query()\ |
|
2978 | return cls.query()\ | |
2979 | .filter(cls.personal == true()) \ |
|
2979 | .filter(cls.personal == true()) \ | |
2980 | .filter(cls.user == user) \ |
|
2980 | .filter(cls.user == user) \ | |
2981 | .order_by(cls.group_id.asc()) \ |
|
2981 | .order_by(cls.group_id.asc()) \ | |
2982 | .first() |
|
2982 | .first() | |
2983 |
|
2983 | |||
2984 | @classmethod |
|
2984 | @classmethod | |
2985 | def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None), |
|
2985 | def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None), | |
2986 | case_insensitive=True): |
|
2986 | case_insensitive=True): | |
2987 | q = RepoGroup.query() |
|
2987 | q = RepoGroup.query() | |
2988 |
|
2988 | |||
2989 | if not isinstance(user_id, Optional): |
|
2989 | if not isinstance(user_id, Optional): | |
2990 | q = q.filter(RepoGroup.user_id == user_id) |
|
2990 | q = q.filter(RepoGroup.user_id == user_id) | |
2991 |
|
2991 | |||
2992 | if not isinstance(group_id, Optional): |
|
2992 | if not isinstance(group_id, Optional): | |
2993 | q = q.filter(RepoGroup.group_parent_id == group_id) |
|
2993 | q = q.filter(RepoGroup.group_parent_id == group_id) | |
2994 |
|
2994 | |||
2995 | if case_insensitive: |
|
2995 | if case_insensitive: | |
2996 | q = q.order_by(func.lower(RepoGroup.group_name)) |
|
2996 | q = q.order_by(func.lower(RepoGroup.group_name)) | |
2997 | else: |
|
2997 | else: | |
2998 | q = q.order_by(RepoGroup.group_name) |
|
2998 | q = q.order_by(RepoGroup.group_name) | |
2999 | return q.all() |
|
2999 | return q.all() | |
3000 |
|
3000 | |||
3001 | @property |
|
3001 | @property | |
3002 | def parents(self, parents_recursion_limit=10): |
|
3002 | def parents(self, parents_recursion_limit=10): | |
3003 | groups = [] |
|
3003 | groups = [] | |
3004 | if self.parent_group is None: |
|
3004 | if self.parent_group is None: | |
3005 | return groups |
|
3005 | return groups | |
3006 | cur_gr = self.parent_group |
|
3006 | cur_gr = self.parent_group | |
3007 | groups.insert(0, cur_gr) |
|
3007 | groups.insert(0, cur_gr) | |
3008 | cnt = 0 |
|
3008 | cnt = 0 | |
3009 | while 1: |
|
3009 | while 1: | |
3010 | cnt += 1 |
|
3010 | cnt += 1 | |
3011 | gr = getattr(cur_gr, 'parent_group', None) |
|
3011 | gr = getattr(cur_gr, 'parent_group', None) | |
3012 | cur_gr = cur_gr.parent_group |
|
3012 | cur_gr = cur_gr.parent_group | |
3013 | if gr is None: |
|
3013 | if gr is None: | |
3014 | break |
|
3014 | break | |
3015 | if cnt == parents_recursion_limit: |
|
3015 | if cnt == parents_recursion_limit: | |
3016 | # this will prevent accidental infinit loops |
|
3016 | # this will prevent accidental infinit loops | |
3017 | log.error('more than %s parents found for group %s, stopping ' |
|
3017 | log.error('more than %s parents found for group %s, stopping ' | |
3018 | 'recursive parent fetching', parents_recursion_limit, self) |
|
3018 | 'recursive parent fetching', parents_recursion_limit, self) | |
3019 | break |
|
3019 | break | |
3020 |
|
3020 | |||
3021 | groups.insert(0, gr) |
|
3021 | groups.insert(0, gr) | |
3022 | return groups |
|
3022 | return groups | |
3023 |
|
3023 | |||
3024 | @property |
|
3024 | @property | |
3025 | def last_commit_cache_update_diff(self): |
|
3025 | def last_commit_cache_update_diff(self): | |
3026 | return time.time() - (safe_int(self.changeset_cache.get('updated_on')) or 0) |
|
3026 | return time.time() - (safe_int(self.changeset_cache.get('updated_on')) or 0) | |
3027 |
|
3027 | |||
3028 | @classmethod |
|
3028 | @classmethod | |
3029 | def _load_commit_change(cls, last_commit_cache): |
|
3029 | def _load_commit_change(cls, last_commit_cache): | |
3030 | from rhodecode.lib.vcs.utils.helpers import parse_datetime |
|
3030 | from rhodecode.lib.vcs.utils.helpers import parse_datetime | |
3031 | empty_date = datetime.datetime.fromtimestamp(0) |
|
3031 | empty_date = datetime.datetime.fromtimestamp(0) | |
3032 | date_latest = last_commit_cache.get('date', empty_date) |
|
3032 | date_latest = last_commit_cache.get('date', empty_date) | |
3033 | try: |
|
3033 | try: | |
3034 | return parse_datetime(date_latest) |
|
3034 | return parse_datetime(date_latest) | |
3035 | except Exception: |
|
3035 | except Exception: | |
3036 | return empty_date |
|
3036 | return empty_date | |
3037 |
|
3037 | |||
3038 | @property |
|
3038 | @property | |
3039 | def last_commit_change(self): |
|
3039 | def last_commit_change(self): | |
3040 | return self._load_commit_change(self.changeset_cache) |
|
3040 | return self._load_commit_change(self.changeset_cache) | |
3041 |
|
3041 | |||
3042 | @property |
|
3042 | @property | |
3043 | def last_db_change(self): |
|
3043 | def last_db_change(self): | |
3044 | return self.updated_on |
|
3044 | return self.updated_on | |
3045 |
|
3045 | |||
3046 | @property |
|
3046 | @property | |
3047 | def children(self): |
|
3047 | def children(self): | |
3048 | return RepoGroup.query().filter(RepoGroup.parent_group == self) |
|
3048 | return RepoGroup.query().filter(RepoGroup.parent_group == self) | |
3049 |
|
3049 | |||
3050 | @property |
|
3050 | @property | |
3051 | def name(self): |
|
3051 | def name(self): | |
3052 | return self.group_name.split(RepoGroup.url_sep())[-1] |
|
3052 | return self.group_name.split(RepoGroup.url_sep())[-1] | |
3053 |
|
3053 | |||
3054 | @property |
|
3054 | @property | |
3055 | def full_path(self): |
|
3055 | def full_path(self): | |
3056 | return self.group_name |
|
3056 | return self.group_name | |
3057 |
|
3057 | |||
3058 | @property |
|
3058 | @property | |
3059 | def full_path_splitted(self): |
|
3059 | def full_path_splitted(self): | |
3060 | return self.group_name.split(RepoGroup.url_sep()) |
|
3060 | return self.group_name.split(RepoGroup.url_sep()) | |
3061 |
|
3061 | |||
3062 | @property |
|
3062 | @property | |
3063 | def repositories(self): |
|
3063 | def repositories(self): | |
3064 | return Repository.query()\ |
|
3064 | return Repository.query()\ | |
3065 | .filter(Repository.group == self)\ |
|
3065 | .filter(Repository.group == self)\ | |
3066 | .order_by(Repository.repo_name) |
|
3066 | .order_by(Repository.repo_name) | |
3067 |
|
3067 | |||
3068 | @property |
|
3068 | @property | |
3069 | def repositories_recursive_count(self): |
|
3069 | def repositories_recursive_count(self): | |
3070 | cnt = self.repositories.count() |
|
3070 | cnt = self.repositories.count() | |
3071 |
|
3071 | |||
3072 | def children_count(group): |
|
3072 | def children_count(group): | |
3073 | cnt = 0 |
|
3073 | cnt = 0 | |
3074 | for child in group.children: |
|
3074 | for child in group.children: | |
3075 | cnt += child.repositories.count() |
|
3075 | cnt += child.repositories.count() | |
3076 | cnt += children_count(child) |
|
3076 | cnt += children_count(child) | |
3077 | return cnt |
|
3077 | return cnt | |
3078 |
|
3078 | |||
3079 | return cnt + children_count(self) |
|
3079 | return cnt + children_count(self) | |
3080 |
|
3080 | |||
3081 | def _recursive_objects(self, include_repos=True, include_groups=True): |
|
3081 | def _recursive_objects(self, include_repos=True, include_groups=True): | |
3082 | all_ = [] |
|
3082 | all_ = [] | |
3083 |
|
3083 | |||
3084 | def _get_members(root_gr): |
|
3084 | def _get_members(root_gr): | |
3085 | if include_repos: |
|
3085 | if include_repos: | |
3086 | for r in root_gr.repositories: |
|
3086 | for r in root_gr.repositories: | |
3087 | all_.append(r) |
|
3087 | all_.append(r) | |
3088 | childs = root_gr.children.all() |
|
3088 | childs = root_gr.children.all() | |
3089 | if childs: |
|
3089 | if childs: | |
3090 | for gr in childs: |
|
3090 | for gr in childs: | |
3091 | if include_groups: |
|
3091 | if include_groups: | |
3092 | all_.append(gr) |
|
3092 | all_.append(gr) | |
3093 | _get_members(gr) |
|
3093 | _get_members(gr) | |
3094 |
|
3094 | |||
3095 | root_group = [] |
|
3095 | root_group = [] | |
3096 | if include_groups: |
|
3096 | if include_groups: | |
3097 | root_group = [self] |
|
3097 | root_group = [self] | |
3098 |
|
3098 | |||
3099 | _get_members(self) |
|
3099 | _get_members(self) | |
3100 | return root_group + all_ |
|
3100 | return root_group + all_ | |
3101 |
|
3101 | |||
3102 | def recursive_groups_and_repos(self): |
|
3102 | def recursive_groups_and_repos(self): | |
3103 | """ |
|
3103 | """ | |
3104 | Recursive return all groups, with repositories in those groups |
|
3104 | Recursive return all groups, with repositories in those groups | |
3105 | """ |
|
3105 | """ | |
3106 | return self._recursive_objects() |
|
3106 | return self._recursive_objects() | |
3107 |
|
3107 | |||
3108 | def recursive_groups(self): |
|
3108 | def recursive_groups(self): | |
3109 | """ |
|
3109 | """ | |
3110 | Returns all children groups for this group including children of children |
|
3110 | Returns all children groups for this group including children of children | |
3111 | """ |
|
3111 | """ | |
3112 | return self._recursive_objects(include_repos=False) |
|
3112 | return self._recursive_objects(include_repos=False) | |
3113 |
|
3113 | |||
3114 | def recursive_repos(self): |
|
3114 | def recursive_repos(self): | |
3115 | """ |
|
3115 | """ | |
3116 | Returns all children repositories for this group |
|
3116 | Returns all children repositories for this group | |
3117 | """ |
|
3117 | """ | |
3118 | return self._recursive_objects(include_groups=False) |
|
3118 | return self._recursive_objects(include_groups=False) | |
3119 |
|
3119 | |||
3120 | def get_new_name(self, group_name): |
|
3120 | def get_new_name(self, group_name): | |
3121 | """ |
|
3121 | """ | |
3122 | returns new full group name based on parent and new name |
|
3122 | returns new full group name based on parent and new name | |
3123 |
|
3123 | |||
3124 | :param group_name: |
|
3124 | :param group_name: | |
3125 | """ |
|
3125 | """ | |
3126 | path_prefix = (self.parent_group.full_path_splitted if |
|
3126 | path_prefix = (self.parent_group.full_path_splitted if | |
3127 | self.parent_group else []) |
|
3127 | self.parent_group else []) | |
3128 | return RepoGroup.url_sep().join(path_prefix + [group_name]) |
|
3128 | return RepoGroup.url_sep().join(path_prefix + [group_name]) | |
3129 |
|
3129 | |||
3130 | def update_commit_cache(self, config=None): |
|
3130 | def update_commit_cache(self, config=None): | |
3131 | """ |
|
3131 | """ | |
3132 | Update cache of last commit for newest repository inside this repository group. |
|
3132 | Update cache of last commit for newest repository inside this repository group. | |
3133 | cache_keys should be:: |
|
3133 | cache_keys should be:: | |
3134 |
|
3134 | |||
3135 | source_repo_id |
|
3135 | source_repo_id | |
3136 | short_id |
|
3136 | short_id | |
3137 | raw_id |
|
3137 | raw_id | |
3138 | revision |
|
3138 | revision | |
3139 | parents |
|
3139 | parents | |
3140 | message |
|
3140 | message | |
3141 | date |
|
3141 | date | |
3142 | author |
|
3142 | author | |
3143 |
|
3143 | |||
3144 | """ |
|
3144 | """ | |
3145 | from rhodecode.lib.vcs.utils.helpers import parse_datetime |
|
3145 | from rhodecode.lib.vcs.utils.helpers import parse_datetime | |
3146 | empty_date = datetime.datetime.fromtimestamp(0) |
|
3146 | empty_date = datetime.datetime.fromtimestamp(0) | |
3147 |
|
3147 | |||
3148 | def repo_groups_and_repos(root_gr): |
|
3148 | def repo_groups_and_repos(root_gr): | |
3149 | for _repo in root_gr.repositories: |
|
3149 | for _repo in root_gr.repositories: | |
3150 | yield _repo |
|
3150 | yield _repo | |
3151 | for child_group in root_gr.children.all(): |
|
3151 | for child_group in root_gr.children.all(): | |
3152 | yield child_group |
|
3152 | yield child_group | |
3153 |
|
3153 | |||
3154 | latest_repo_cs_cache = {} |
|
3154 | latest_repo_cs_cache = {} | |
3155 | for obj in repo_groups_and_repos(self): |
|
3155 | for obj in repo_groups_and_repos(self): | |
3156 | repo_cs_cache = obj.changeset_cache |
|
3156 | repo_cs_cache = obj.changeset_cache | |
3157 | date_latest = latest_repo_cs_cache.get('date', empty_date) |
|
3157 | date_latest = latest_repo_cs_cache.get('date', empty_date) | |
3158 | date_current = repo_cs_cache.get('date', empty_date) |
|
3158 | date_current = repo_cs_cache.get('date', empty_date) | |
3159 | current_timestamp = datetime_to_time(parse_datetime(date_latest)) |
|
3159 | current_timestamp = datetime_to_time(parse_datetime(date_latest)) | |
3160 | if current_timestamp < datetime_to_time(parse_datetime(date_current)): |
|
3160 | if current_timestamp < datetime_to_time(parse_datetime(date_current)): | |
3161 | latest_repo_cs_cache = repo_cs_cache |
|
3161 | latest_repo_cs_cache = repo_cs_cache | |
3162 | if hasattr(obj, 'repo_id'): |
|
3162 | if hasattr(obj, 'repo_id'): | |
3163 | latest_repo_cs_cache['source_repo_id'] = obj.repo_id |
|
3163 | latest_repo_cs_cache['source_repo_id'] = obj.repo_id | |
3164 | else: |
|
3164 | else: | |
3165 | latest_repo_cs_cache['source_repo_id'] = repo_cs_cache.get('source_repo_id') |
|
3165 | latest_repo_cs_cache['source_repo_id'] = repo_cs_cache.get('source_repo_id') | |
3166 |
|
3166 | |||
3167 | _date_latest = parse_datetime(latest_repo_cs_cache.get('date') or empty_date) |
|
3167 | _date_latest = parse_datetime(latest_repo_cs_cache.get('date') or empty_date) | |
3168 |
|
3168 | |||
3169 | latest_repo_cs_cache['updated_on'] = time.time() |
|
3169 | latest_repo_cs_cache['updated_on'] = time.time() | |
3170 | self.changeset_cache = latest_repo_cs_cache |
|
3170 | self.changeset_cache = latest_repo_cs_cache | |
3171 | self.updated_on = _date_latest |
|
3171 | self.updated_on = _date_latest | |
3172 | Session().add(self) |
|
3172 | Session().add(self) | |
3173 | Session().commit() |
|
3173 | Session().commit() | |
3174 |
|
3174 | |||
3175 | log.debug('updated repo group `%s` with new commit cache %s, and last update_date: %s', |
|
3175 | log.debug('updated repo group `%s` with new commit cache %s, and last update_date: %s', | |
3176 | self.group_name, latest_repo_cs_cache, _date_latest) |
|
3176 | self.group_name, latest_repo_cs_cache, _date_latest) | |
3177 |
|
3177 | |||
3178 | def permissions(self, with_admins=True, with_owner=True, |
|
3178 | def permissions(self, with_admins=True, with_owner=True, | |
3179 | expand_from_user_groups=False): |
|
3179 | expand_from_user_groups=False): | |
3180 | """ |
|
3180 | """ | |
3181 | Permissions for repository groups |
|
3181 | Permissions for repository groups | |
3182 | """ |
|
3182 | """ | |
3183 | _admin_perm = 'group.admin' |
|
3183 | _admin_perm = 'group.admin' | |
3184 |
|
3184 | |||
3185 | owner_row = [] |
|
3185 | owner_row = [] | |
3186 | if with_owner: |
|
3186 | if with_owner: | |
3187 | usr = AttributeDict(self.user.get_dict()) |
|
3187 | usr = AttributeDict(self.user.get_dict()) | |
3188 | usr.owner_row = True |
|
3188 | usr.owner_row = True | |
3189 | usr.permission = _admin_perm |
|
3189 | usr.permission = _admin_perm | |
3190 | owner_row.append(usr) |
|
3190 | owner_row.append(usr) | |
3191 |
|
3191 | |||
3192 | super_admin_ids = [] |
|
3192 | super_admin_ids = [] | |
3193 | super_admin_rows = [] |
|
3193 | super_admin_rows = [] | |
3194 | if with_admins: |
|
3194 | if with_admins: | |
3195 | for usr in User.get_all_super_admins(): |
|
3195 | for usr in User.get_all_super_admins(): | |
3196 | super_admin_ids.append(usr.user_id) |
|
3196 | super_admin_ids.append(usr.user_id) | |
3197 | # if this admin is also owner, don't double the record |
|
3197 | # if this admin is also owner, don't double the record | |
3198 | if usr.user_id == owner_row[0].user_id: |
|
3198 | if usr.user_id == owner_row[0].user_id: | |
3199 | owner_row[0].admin_row = True |
|
3199 | owner_row[0].admin_row = True | |
3200 | else: |
|
3200 | else: | |
3201 | usr = AttributeDict(usr.get_dict()) |
|
3201 | usr = AttributeDict(usr.get_dict()) | |
3202 | usr.admin_row = True |
|
3202 | usr.admin_row = True | |
3203 | usr.permission = _admin_perm |
|
3203 | usr.permission = _admin_perm | |
3204 | super_admin_rows.append(usr) |
|
3204 | super_admin_rows.append(usr) | |
3205 |
|
3205 | |||
3206 | q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self) |
|
3206 | q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self) | |
3207 | q = q.options(joinedload(UserRepoGroupToPerm.group), |
|
3207 | q = q.options(joinedload(UserRepoGroupToPerm.group), | |
3208 | joinedload(UserRepoGroupToPerm.user), |
|
3208 | joinedload(UserRepoGroupToPerm.user), | |
3209 | joinedload(UserRepoGroupToPerm.permission),) |
|
3209 | joinedload(UserRepoGroupToPerm.permission),) | |
3210 |
|
3210 | |||
3211 | # get owners and admins and permissions. We do a trick of re-writing |
|
3211 | # get owners and admins and permissions. We do a trick of re-writing | |
3212 | # objects from sqlalchemy to named-tuples due to sqlalchemy session |
|
3212 | # objects from sqlalchemy to named-tuples due to sqlalchemy session | |
3213 | # has a global reference and changing one object propagates to all |
|
3213 | # has a global reference and changing one object propagates to all | |
3214 | # others. This means if admin is also an owner admin_row that change |
|
3214 | # others. This means if admin is also an owner admin_row that change | |
3215 | # would propagate to both objects |
|
3215 | # would propagate to both objects | |
3216 | perm_rows = [] |
|
3216 | perm_rows = [] | |
3217 | for _usr in q.all(): |
|
3217 | for _usr in q.all(): | |
3218 | usr = AttributeDict(_usr.user.get_dict()) |
|
3218 | usr = AttributeDict(_usr.user.get_dict()) | |
3219 | # if this user is also owner/admin, mark as duplicate record |
|
3219 | # if this user is also owner/admin, mark as duplicate record | |
3220 | if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids: |
|
3220 | if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids: | |
3221 | usr.duplicate_perm = True |
|
3221 | usr.duplicate_perm = True | |
3222 | usr.permission = _usr.permission.permission_name |
|
3222 | usr.permission = _usr.permission.permission_name | |
3223 | perm_rows.append(usr) |
|
3223 | perm_rows.append(usr) | |
3224 |
|
3224 | |||
3225 | # filter the perm rows by 'default' first and then sort them by |
|
3225 | # filter the perm rows by 'default' first and then sort them by | |
3226 | # admin,write,read,none permissions sorted again alphabetically in |
|
3226 | # admin,write,read,none permissions sorted again alphabetically in | |
3227 | # each group |
|
3227 | # each group | |
3228 | perm_rows = sorted(perm_rows, key=display_user_sort) |
|
3228 | perm_rows = sorted(perm_rows, key=display_user_sort) | |
3229 |
|
3229 | |||
3230 | user_groups_rows = [] |
|
3230 | user_groups_rows = [] | |
3231 | if expand_from_user_groups: |
|
3231 | if expand_from_user_groups: | |
3232 | for ug in self.permission_user_groups(with_members=True): |
|
3232 | for ug in self.permission_user_groups(with_members=True): | |
3233 | for user_data in ug.members: |
|
3233 | for user_data in ug.members: | |
3234 | user_groups_rows.append(user_data) |
|
3234 | user_groups_rows.append(user_data) | |
3235 |
|
3235 | |||
3236 | return super_admin_rows + owner_row + perm_rows + user_groups_rows |
|
3236 | return super_admin_rows + owner_row + perm_rows + user_groups_rows | |
3237 |
|
3237 | |||
3238 | def permission_user_groups(self, with_members=False): |
|
3238 | def permission_user_groups(self, with_members=False): | |
3239 | q = UserGroupRepoGroupToPerm.query()\ |
|
3239 | q = UserGroupRepoGroupToPerm.query()\ | |
3240 | .filter(UserGroupRepoGroupToPerm.group == self) |
|
3240 | .filter(UserGroupRepoGroupToPerm.group == self) | |
3241 | q = q.options(joinedload(UserGroupRepoGroupToPerm.group), |
|
3241 | q = q.options(joinedload(UserGroupRepoGroupToPerm.group), | |
3242 | joinedload(UserGroupRepoGroupToPerm.users_group), |
|
3242 | joinedload(UserGroupRepoGroupToPerm.users_group), | |
3243 | joinedload(UserGroupRepoGroupToPerm.permission),) |
|
3243 | joinedload(UserGroupRepoGroupToPerm.permission),) | |
3244 |
|
3244 | |||
3245 | perm_rows = [] |
|
3245 | perm_rows = [] | |
3246 | for _user_group in q.all(): |
|
3246 | for _user_group in q.all(): | |
3247 | entry = AttributeDict(_user_group.users_group.get_dict()) |
|
3247 | entry = AttributeDict(_user_group.users_group.get_dict()) | |
3248 | entry.permission = _user_group.permission.permission_name |
|
3248 | entry.permission = _user_group.permission.permission_name | |
3249 | if with_members: |
|
3249 | if with_members: | |
3250 | entry.members = [x.user.get_dict() |
|
3250 | entry.members = [x.user.get_dict() | |
3251 | for x in _user_group.users_group.members] |
|
3251 | for x in _user_group.users_group.members] | |
3252 | perm_rows.append(entry) |
|
3252 | perm_rows.append(entry) | |
3253 |
|
3253 | |||
3254 | perm_rows = sorted(perm_rows, key=display_user_group_sort) |
|
3254 | perm_rows = sorted(perm_rows, key=display_user_group_sort) | |
3255 | return perm_rows |
|
3255 | return perm_rows | |
3256 |
|
3256 | |||
3257 | def get_api_data(self): |
|
3257 | def get_api_data(self): | |
3258 | """ |
|
3258 | """ | |
3259 | Common function for generating api data |
|
3259 | Common function for generating api data | |
3260 |
|
3260 | |||
3261 | """ |
|
3261 | """ | |
3262 | group = self |
|
3262 | group = self | |
3263 | data = { |
|
3263 | data = { | |
3264 | 'group_id': group.group_id, |
|
3264 | 'group_id': group.group_id, | |
3265 | 'group_name': group.group_name, |
|
3265 | 'group_name': group.group_name, | |
3266 | 'group_description': group.description_safe, |
|
3266 | 'group_description': group.description_safe, | |
3267 | 'parent_group': group.parent_group.group_name if group.parent_group else None, |
|
3267 | 'parent_group': group.parent_group.group_name if group.parent_group else None, | |
3268 | 'repositories': [x.repo_name for x in group.repositories], |
|
3268 | 'repositories': [x.repo_name for x in group.repositories], | |
3269 | 'owner': group.user.username, |
|
3269 | 'owner': group.user.username, | |
3270 | } |
|
3270 | } | |
3271 | return data |
|
3271 | return data | |
3272 |
|
3272 | |||
3273 | def get_dict(self): |
|
3273 | def get_dict(self): | |
3274 | # Since we transformed `group_name` to a hybrid property, we need to |
|
3274 | # Since we transformed `group_name` to a hybrid property, we need to | |
3275 | # keep compatibility with the code which uses `group_name` field. |
|
3275 | # keep compatibility with the code which uses `group_name` field. | |
3276 | result = super(RepoGroup, self).get_dict() |
|
3276 | result = super(RepoGroup, self).get_dict() | |
3277 | result['group_name'] = result.pop('_group_name', None) |
|
3277 | result['group_name'] = result.pop('_group_name', None) | |
3278 | result.pop('_changeset_cache', '') |
|
3278 | result.pop('_changeset_cache', '') | |
3279 | return result |
|
3279 | return result | |
3280 |
|
3280 | |||
3281 |
|
3281 | |||
3282 | class Permission(Base, BaseModel): |
|
3282 | class Permission(Base, BaseModel): | |
3283 | __tablename__ = 'permissions' |
|
3283 | __tablename__ = 'permissions' | |
3284 | __table_args__ = ( |
|
3284 | __table_args__ = ( | |
3285 | Index('p_perm_name_idx', 'permission_name'), |
|
3285 | Index('p_perm_name_idx', 'permission_name'), | |
3286 | base_table_args, |
|
3286 | base_table_args, | |
3287 | ) |
|
3287 | ) | |
3288 |
|
3288 | |||
3289 | PERMS = [ |
|
3289 | PERMS = [ | |
3290 | ('hg.admin', _('RhodeCode Super Administrator')), |
|
3290 | ('hg.admin', _('RhodeCode Super Administrator')), | |
3291 |
|
3291 | |||
3292 | ('repository.none', _('Repository no access')), |
|
3292 | ('repository.none', _('Repository no access')), | |
3293 | ('repository.read', _('Repository read access')), |
|
3293 | ('repository.read', _('Repository read access')), | |
3294 | ('repository.write', _('Repository write access')), |
|
3294 | ('repository.write', _('Repository write access')), | |
3295 | ('repository.admin', _('Repository admin access')), |
|
3295 | ('repository.admin', _('Repository admin access')), | |
3296 |
|
3296 | |||
3297 | ('group.none', _('Repository group no access')), |
|
3297 | ('group.none', _('Repository group no access')), | |
3298 | ('group.read', _('Repository group read access')), |
|
3298 | ('group.read', _('Repository group read access')), | |
3299 | ('group.write', _('Repository group write access')), |
|
3299 | ('group.write', _('Repository group write access')), | |
3300 | ('group.admin', _('Repository group admin access')), |
|
3300 | ('group.admin', _('Repository group admin access')), | |
3301 |
|
3301 | |||
3302 | ('usergroup.none', _('User group no access')), |
|
3302 | ('usergroup.none', _('User group no access')), | |
3303 | ('usergroup.read', _('User group read access')), |
|
3303 | ('usergroup.read', _('User group read access')), | |
3304 | ('usergroup.write', _('User group write access')), |
|
3304 | ('usergroup.write', _('User group write access')), | |
3305 | ('usergroup.admin', _('User group admin access')), |
|
3305 | ('usergroup.admin', _('User group admin access')), | |
3306 |
|
3306 | |||
3307 | ('branch.none', _('Branch no permissions')), |
|
3307 | ('branch.none', _('Branch no permissions')), | |
3308 | ('branch.merge', _('Branch access by web merge')), |
|
3308 | ('branch.merge', _('Branch access by web merge')), | |
3309 | ('branch.push', _('Branch access by push')), |
|
3309 | ('branch.push', _('Branch access by push')), | |
3310 | ('branch.push_force', _('Branch access by push with force')), |
|
3310 | ('branch.push_force', _('Branch access by push with force')), | |
3311 |
|
3311 | |||
3312 | ('hg.repogroup.create.false', _('Repository Group creation disabled')), |
|
3312 | ('hg.repogroup.create.false', _('Repository Group creation disabled')), | |
3313 | ('hg.repogroup.create.true', _('Repository Group creation enabled')), |
|
3313 | ('hg.repogroup.create.true', _('Repository Group creation enabled')), | |
3314 |
|
3314 | |||
3315 | ('hg.usergroup.create.false', _('User Group creation disabled')), |
|
3315 | ('hg.usergroup.create.false', _('User Group creation disabled')), | |
3316 | ('hg.usergroup.create.true', _('User Group creation enabled')), |
|
3316 | ('hg.usergroup.create.true', _('User Group creation enabled')), | |
3317 |
|
3317 | |||
3318 | ('hg.create.none', _('Repository creation disabled')), |
|
3318 | ('hg.create.none', _('Repository creation disabled')), | |
3319 | ('hg.create.repository', _('Repository creation enabled')), |
|
3319 | ('hg.create.repository', _('Repository creation enabled')), | |
3320 | ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')), |
|
3320 | ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')), | |
3321 | ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')), |
|
3321 | ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')), | |
3322 |
|
3322 | |||
3323 | ('hg.fork.none', _('Repository forking disabled')), |
|
3323 | ('hg.fork.none', _('Repository forking disabled')), | |
3324 | ('hg.fork.repository', _('Repository forking enabled')), |
|
3324 | ('hg.fork.repository', _('Repository forking enabled')), | |
3325 |
|
3325 | |||
3326 | ('hg.register.none', _('Registration disabled')), |
|
3326 | ('hg.register.none', _('Registration disabled')), | |
3327 | ('hg.register.manual_activate', _('User Registration with manual account activation')), |
|
3327 | ('hg.register.manual_activate', _('User Registration with manual account activation')), | |
3328 | ('hg.register.auto_activate', _('User Registration with automatic account activation')), |
|
3328 | ('hg.register.auto_activate', _('User Registration with automatic account activation')), | |
3329 |
|
3329 | |||
3330 | ('hg.password_reset.enabled', _('Password reset enabled')), |
|
3330 | ('hg.password_reset.enabled', _('Password reset enabled')), | |
3331 | ('hg.password_reset.hidden', _('Password reset hidden')), |
|
3331 | ('hg.password_reset.hidden', _('Password reset hidden')), | |
3332 | ('hg.password_reset.disabled', _('Password reset disabled')), |
|
3332 | ('hg.password_reset.disabled', _('Password reset disabled')), | |
3333 |
|
3333 | |||
3334 | ('hg.extern_activate.manual', _('Manual activation of external account')), |
|
3334 | ('hg.extern_activate.manual', _('Manual activation of external account')), | |
3335 | ('hg.extern_activate.auto', _('Automatic activation of external account')), |
|
3335 | ('hg.extern_activate.auto', _('Automatic activation of external account')), | |
3336 |
|
3336 | |||
3337 | ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')), |
|
3337 | ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')), | |
3338 | ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')), |
|
3338 | ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')), | |
3339 | ] |
|
3339 | ] | |
3340 |
|
3340 | |||
3341 | # definition of system default permissions for DEFAULT user, created on |
|
3341 | # definition of system default permissions for DEFAULT user, created on | |
3342 | # system setup |
|
3342 | # system setup | |
3343 | DEFAULT_USER_PERMISSIONS = [ |
|
3343 | DEFAULT_USER_PERMISSIONS = [ | |
3344 | # object perms |
|
3344 | # object perms | |
3345 | 'repository.read', |
|
3345 | 'repository.read', | |
3346 | 'group.read', |
|
3346 | 'group.read', | |
3347 | 'usergroup.read', |
|
3347 | 'usergroup.read', | |
3348 | # branch, for backward compat we need same value as before so forced pushed |
|
3348 | # branch, for backward compat we need same value as before so forced pushed | |
3349 | 'branch.push_force', |
|
3349 | 'branch.push_force', | |
3350 | # global |
|
3350 | # global | |
3351 | 'hg.create.repository', |
|
3351 | 'hg.create.repository', | |
3352 | 'hg.repogroup.create.false', |
|
3352 | 'hg.repogroup.create.false', | |
3353 | 'hg.usergroup.create.false', |
|
3353 | 'hg.usergroup.create.false', | |
3354 | 'hg.create.write_on_repogroup.true', |
|
3354 | 'hg.create.write_on_repogroup.true', | |
3355 | 'hg.fork.repository', |
|
3355 | 'hg.fork.repository', | |
3356 | 'hg.register.manual_activate', |
|
3356 | 'hg.register.manual_activate', | |
3357 | 'hg.password_reset.enabled', |
|
3357 | 'hg.password_reset.enabled', | |
3358 | 'hg.extern_activate.auto', |
|
3358 | 'hg.extern_activate.auto', | |
3359 | 'hg.inherit_default_perms.true', |
|
3359 | 'hg.inherit_default_perms.true', | |
3360 | ] |
|
3360 | ] | |
3361 |
|
3361 | |||
3362 | # defines which permissions are more important higher the more important |
|
3362 | # defines which permissions are more important higher the more important | |
3363 | # Weight defines which permissions are more important. |
|
3363 | # Weight defines which permissions are more important. | |
3364 | # The higher number the more important. |
|
3364 | # The higher number the more important. | |
3365 | PERM_WEIGHTS = { |
|
3365 | PERM_WEIGHTS = { | |
3366 | 'repository.none': 0, |
|
3366 | 'repository.none': 0, | |
3367 | 'repository.read': 1, |
|
3367 | 'repository.read': 1, | |
3368 | 'repository.write': 3, |
|
3368 | 'repository.write': 3, | |
3369 | 'repository.admin': 4, |
|
3369 | 'repository.admin': 4, | |
3370 |
|
3370 | |||
3371 | 'group.none': 0, |
|
3371 | 'group.none': 0, | |
3372 | 'group.read': 1, |
|
3372 | 'group.read': 1, | |
3373 | 'group.write': 3, |
|
3373 | 'group.write': 3, | |
3374 | 'group.admin': 4, |
|
3374 | 'group.admin': 4, | |
3375 |
|
3375 | |||
3376 | 'usergroup.none': 0, |
|
3376 | 'usergroup.none': 0, | |
3377 | 'usergroup.read': 1, |
|
3377 | 'usergroup.read': 1, | |
3378 | 'usergroup.write': 3, |
|
3378 | 'usergroup.write': 3, | |
3379 | 'usergroup.admin': 4, |
|
3379 | 'usergroup.admin': 4, | |
3380 |
|
3380 | |||
3381 | 'branch.none': 0, |
|
3381 | 'branch.none': 0, | |
3382 | 'branch.merge': 1, |
|
3382 | 'branch.merge': 1, | |
3383 | 'branch.push': 3, |
|
3383 | 'branch.push': 3, | |
3384 | 'branch.push_force': 4, |
|
3384 | 'branch.push_force': 4, | |
3385 |
|
3385 | |||
3386 | 'hg.repogroup.create.false': 0, |
|
3386 | 'hg.repogroup.create.false': 0, | |
3387 | 'hg.repogroup.create.true': 1, |
|
3387 | 'hg.repogroup.create.true': 1, | |
3388 |
|
3388 | |||
3389 | 'hg.usergroup.create.false': 0, |
|
3389 | 'hg.usergroup.create.false': 0, | |
3390 | 'hg.usergroup.create.true': 1, |
|
3390 | 'hg.usergroup.create.true': 1, | |
3391 |
|
3391 | |||
3392 | 'hg.fork.none': 0, |
|
3392 | 'hg.fork.none': 0, | |
3393 | 'hg.fork.repository': 1, |
|
3393 | 'hg.fork.repository': 1, | |
3394 | 'hg.create.none': 0, |
|
3394 | 'hg.create.none': 0, | |
3395 | 'hg.create.repository': 1 |
|
3395 | 'hg.create.repository': 1 | |
3396 | } |
|
3396 | } | |
3397 |
|
3397 | |||
3398 | permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3398 | permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3399 | permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None) |
|
3399 | permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None) | |
3400 | permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None) |
|
3400 | permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None) | |
3401 |
|
3401 | |||
3402 | def __repr__(self): |
|
3402 | def __repr__(self): | |
3403 | return "<%s('%s:%s')>" % ( |
|
3403 | return "<%s('%s:%s')>" % ( | |
3404 | self.cls_name, self.permission_id, self.permission_name |
|
3404 | self.cls_name, self.permission_id, self.permission_name | |
3405 | ) |
|
3405 | ) | |
3406 |
|
3406 | |||
3407 | @classmethod |
|
3407 | @classmethod | |
3408 | def get_by_key(cls, key): |
|
3408 | def get_by_key(cls, key): | |
3409 | return cls.query().filter(cls.permission_name == key).scalar() |
|
3409 | return cls.query().filter(cls.permission_name == key).scalar() | |
3410 |
|
3410 | |||
3411 | @classmethod |
|
3411 | @classmethod | |
3412 | def get_default_repo_perms(cls, user_id, repo_id=None): |
|
3412 | def get_default_repo_perms(cls, user_id, repo_id=None): | |
3413 | q = Session().query(UserRepoToPerm, Repository, Permission)\ |
|
3413 | q = Session().query(UserRepoToPerm, Repository, Permission)\ | |
3414 | .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\ |
|
3414 | .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\ | |
3415 | .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\ |
|
3415 | .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\ | |
3416 | .filter(UserRepoToPerm.user_id == user_id) |
|
3416 | .filter(UserRepoToPerm.user_id == user_id) | |
3417 | if repo_id: |
|
3417 | if repo_id: | |
3418 | q = q.filter(UserRepoToPerm.repository_id == repo_id) |
|
3418 | q = q.filter(UserRepoToPerm.repository_id == repo_id) | |
3419 | return q.all() |
|
3419 | return q.all() | |
3420 |
|
3420 | |||
3421 | @classmethod |
|
3421 | @classmethod | |
3422 | def get_default_repo_branch_perms(cls, user_id, repo_id=None): |
|
3422 | def get_default_repo_branch_perms(cls, user_id, repo_id=None): | |
3423 | q = Session().query(UserToRepoBranchPermission, UserRepoToPerm, Permission) \ |
|
3423 | q = Session().query(UserToRepoBranchPermission, UserRepoToPerm, Permission) \ | |
3424 | .join( |
|
3424 | .join( | |
3425 | Permission, |
|
3425 | Permission, | |
3426 | UserToRepoBranchPermission.permission_id == Permission.permission_id) \ |
|
3426 | UserToRepoBranchPermission.permission_id == Permission.permission_id) \ | |
3427 | .join( |
|
3427 | .join( | |
3428 | UserRepoToPerm, |
|
3428 | UserRepoToPerm, | |
3429 | UserToRepoBranchPermission.rule_to_perm_id == UserRepoToPerm.repo_to_perm_id) \ |
|
3429 | UserToRepoBranchPermission.rule_to_perm_id == UserRepoToPerm.repo_to_perm_id) \ | |
3430 | .filter(UserRepoToPerm.user_id == user_id) |
|
3430 | .filter(UserRepoToPerm.user_id == user_id) | |
3431 |
|
3431 | |||
3432 | if repo_id: |
|
3432 | if repo_id: | |
3433 | q = q.filter(UserToRepoBranchPermission.repository_id == repo_id) |
|
3433 | q = q.filter(UserToRepoBranchPermission.repository_id == repo_id) | |
3434 | return q.order_by(UserToRepoBranchPermission.rule_order).all() |
|
3434 | return q.order_by(UserToRepoBranchPermission.rule_order).all() | |
3435 |
|
3435 | |||
3436 | @classmethod |
|
3436 | @classmethod | |
3437 | def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None): |
|
3437 | def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None): | |
3438 | q = Session().query(UserGroupRepoToPerm, Repository, Permission)\ |
|
3438 | q = Session().query(UserGroupRepoToPerm, Repository, Permission)\ | |
3439 | .join( |
|
3439 | .join( | |
3440 | Permission, |
|
3440 | Permission, | |
3441 | UserGroupRepoToPerm.permission_id == Permission.permission_id)\ |
|
3441 | UserGroupRepoToPerm.permission_id == Permission.permission_id)\ | |
3442 | .join( |
|
3442 | .join( | |
3443 | Repository, |
|
3443 | Repository, | |
3444 | UserGroupRepoToPerm.repository_id == Repository.repo_id)\ |
|
3444 | UserGroupRepoToPerm.repository_id == Repository.repo_id)\ | |
3445 | .join( |
|
3445 | .join( | |
3446 | UserGroup, |
|
3446 | UserGroup, | |
3447 | UserGroupRepoToPerm.users_group_id == |
|
3447 | UserGroupRepoToPerm.users_group_id == | |
3448 | UserGroup.users_group_id)\ |
|
3448 | UserGroup.users_group_id)\ | |
3449 | .join( |
|
3449 | .join( | |
3450 | UserGroupMember, |
|
3450 | UserGroupMember, | |
3451 | UserGroupRepoToPerm.users_group_id == |
|
3451 | UserGroupRepoToPerm.users_group_id == | |
3452 | UserGroupMember.users_group_id)\ |
|
3452 | UserGroupMember.users_group_id)\ | |
3453 | .filter( |
|
3453 | .filter( | |
3454 | UserGroupMember.user_id == user_id, |
|
3454 | UserGroupMember.user_id == user_id, | |
3455 | UserGroup.users_group_active == true()) |
|
3455 | UserGroup.users_group_active == true()) | |
3456 | if repo_id: |
|
3456 | if repo_id: | |
3457 | q = q.filter(UserGroupRepoToPerm.repository_id == repo_id) |
|
3457 | q = q.filter(UserGroupRepoToPerm.repository_id == repo_id) | |
3458 | return q.all() |
|
3458 | return q.all() | |
3459 |
|
3459 | |||
3460 | @classmethod |
|
3460 | @classmethod | |
3461 | def get_default_repo_branch_perms_from_user_group(cls, user_id, repo_id=None): |
|
3461 | def get_default_repo_branch_perms_from_user_group(cls, user_id, repo_id=None): | |
3462 | q = Session().query(UserGroupToRepoBranchPermission, UserGroupRepoToPerm, Permission) \ |
|
3462 | q = Session().query(UserGroupToRepoBranchPermission, UserGroupRepoToPerm, Permission) \ | |
3463 | .join( |
|
3463 | .join( | |
3464 | Permission, |
|
3464 | Permission, | |
3465 | UserGroupToRepoBranchPermission.permission_id == Permission.permission_id) \ |
|
3465 | UserGroupToRepoBranchPermission.permission_id == Permission.permission_id) \ | |
3466 | .join( |
|
3466 | .join( | |
3467 | UserGroupRepoToPerm, |
|
3467 | UserGroupRepoToPerm, | |
3468 | UserGroupToRepoBranchPermission.rule_to_perm_id == UserGroupRepoToPerm.users_group_to_perm_id) \ |
|
3468 | UserGroupToRepoBranchPermission.rule_to_perm_id == UserGroupRepoToPerm.users_group_to_perm_id) \ | |
3469 | .join( |
|
3469 | .join( | |
3470 | UserGroup, |
|
3470 | UserGroup, | |
3471 | UserGroupRepoToPerm.users_group_id == UserGroup.users_group_id) \ |
|
3471 | UserGroupRepoToPerm.users_group_id == UserGroup.users_group_id) \ | |
3472 | .join( |
|
3472 | .join( | |
3473 | UserGroupMember, |
|
3473 | UserGroupMember, | |
3474 | UserGroupRepoToPerm.users_group_id == UserGroupMember.users_group_id) \ |
|
3474 | UserGroupRepoToPerm.users_group_id == UserGroupMember.users_group_id) \ | |
3475 | .filter( |
|
3475 | .filter( | |
3476 | UserGroupMember.user_id == user_id, |
|
3476 | UserGroupMember.user_id == user_id, | |
3477 | UserGroup.users_group_active == true()) |
|
3477 | UserGroup.users_group_active == true()) | |
3478 |
|
3478 | |||
3479 | if repo_id: |
|
3479 | if repo_id: | |
3480 | q = q.filter(UserGroupToRepoBranchPermission.repository_id == repo_id) |
|
3480 | q = q.filter(UserGroupToRepoBranchPermission.repository_id == repo_id) | |
3481 | return q.order_by(UserGroupToRepoBranchPermission.rule_order).all() |
|
3481 | return q.order_by(UserGroupToRepoBranchPermission.rule_order).all() | |
3482 |
|
3482 | |||
3483 | @classmethod |
|
3483 | @classmethod | |
3484 | def get_default_group_perms(cls, user_id, repo_group_id=None): |
|
3484 | def get_default_group_perms(cls, user_id, repo_group_id=None): | |
3485 | q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\ |
|
3485 | q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\ | |
3486 | .join( |
|
3486 | .join( | |
3487 | Permission, |
|
3487 | Permission, | |
3488 | UserRepoGroupToPerm.permission_id == Permission.permission_id)\ |
|
3488 | UserRepoGroupToPerm.permission_id == Permission.permission_id)\ | |
3489 | .join( |
|
3489 | .join( | |
3490 | RepoGroup, |
|
3490 | RepoGroup, | |
3491 | UserRepoGroupToPerm.group_id == RepoGroup.group_id)\ |
|
3491 | UserRepoGroupToPerm.group_id == RepoGroup.group_id)\ | |
3492 | .filter(UserRepoGroupToPerm.user_id == user_id) |
|
3492 | .filter(UserRepoGroupToPerm.user_id == user_id) | |
3493 | if repo_group_id: |
|
3493 | if repo_group_id: | |
3494 | q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id) |
|
3494 | q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id) | |
3495 | return q.all() |
|
3495 | return q.all() | |
3496 |
|
3496 | |||
3497 | @classmethod |
|
3497 | @classmethod | |
3498 | def get_default_group_perms_from_user_group( |
|
3498 | def get_default_group_perms_from_user_group( | |
3499 | cls, user_id, repo_group_id=None): |
|
3499 | cls, user_id, repo_group_id=None): | |
3500 | q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\ |
|
3500 | q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\ | |
3501 | .join( |
|
3501 | .join( | |
3502 | Permission, |
|
3502 | Permission, | |
3503 | UserGroupRepoGroupToPerm.permission_id == |
|
3503 | UserGroupRepoGroupToPerm.permission_id == | |
3504 | Permission.permission_id)\ |
|
3504 | Permission.permission_id)\ | |
3505 | .join( |
|
3505 | .join( | |
3506 | RepoGroup, |
|
3506 | RepoGroup, | |
3507 | UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\ |
|
3507 | UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\ | |
3508 | .join( |
|
3508 | .join( | |
3509 | UserGroup, |
|
3509 | UserGroup, | |
3510 | UserGroupRepoGroupToPerm.users_group_id == |
|
3510 | UserGroupRepoGroupToPerm.users_group_id == | |
3511 | UserGroup.users_group_id)\ |
|
3511 | UserGroup.users_group_id)\ | |
3512 | .join( |
|
3512 | .join( | |
3513 | UserGroupMember, |
|
3513 | UserGroupMember, | |
3514 | UserGroupRepoGroupToPerm.users_group_id == |
|
3514 | UserGroupRepoGroupToPerm.users_group_id == | |
3515 | UserGroupMember.users_group_id)\ |
|
3515 | UserGroupMember.users_group_id)\ | |
3516 | .filter( |
|
3516 | .filter( | |
3517 | UserGroupMember.user_id == user_id, |
|
3517 | UserGroupMember.user_id == user_id, | |
3518 | UserGroup.users_group_active == true()) |
|
3518 | UserGroup.users_group_active == true()) | |
3519 | if repo_group_id: |
|
3519 | if repo_group_id: | |
3520 | q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id) |
|
3520 | q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id) | |
3521 | return q.all() |
|
3521 | return q.all() | |
3522 |
|
3522 | |||
3523 | @classmethod |
|
3523 | @classmethod | |
3524 | def get_default_user_group_perms(cls, user_id, user_group_id=None): |
|
3524 | def get_default_user_group_perms(cls, user_id, user_group_id=None): | |
3525 | q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\ |
|
3525 | q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\ | |
3526 | .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\ |
|
3526 | .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\ | |
3527 | .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\ |
|
3527 | .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\ | |
3528 | .filter(UserUserGroupToPerm.user_id == user_id) |
|
3528 | .filter(UserUserGroupToPerm.user_id == user_id) | |
3529 | if user_group_id: |
|
3529 | if user_group_id: | |
3530 | q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id) |
|
3530 | q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id) | |
3531 | return q.all() |
|
3531 | return q.all() | |
3532 |
|
3532 | |||
3533 | @classmethod |
|
3533 | @classmethod | |
3534 | def get_default_user_group_perms_from_user_group( |
|
3534 | def get_default_user_group_perms_from_user_group( | |
3535 | cls, user_id, user_group_id=None): |
|
3535 | cls, user_id, user_group_id=None): | |
3536 | TargetUserGroup = aliased(UserGroup, name='target_user_group') |
|
3536 | TargetUserGroup = aliased(UserGroup, name='target_user_group') | |
3537 | q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\ |
|
3537 | q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\ | |
3538 | .join( |
|
3538 | .join( | |
3539 | Permission, |
|
3539 | Permission, | |
3540 | UserGroupUserGroupToPerm.permission_id == |
|
3540 | UserGroupUserGroupToPerm.permission_id == | |
3541 | Permission.permission_id)\ |
|
3541 | Permission.permission_id)\ | |
3542 | .join( |
|
3542 | .join( | |
3543 | TargetUserGroup, |
|
3543 | TargetUserGroup, | |
3544 | UserGroupUserGroupToPerm.target_user_group_id == |
|
3544 | UserGroupUserGroupToPerm.target_user_group_id == | |
3545 | TargetUserGroup.users_group_id)\ |
|
3545 | TargetUserGroup.users_group_id)\ | |
3546 | .join( |
|
3546 | .join( | |
3547 | UserGroup, |
|
3547 | UserGroup, | |
3548 | UserGroupUserGroupToPerm.user_group_id == |
|
3548 | UserGroupUserGroupToPerm.user_group_id == | |
3549 | UserGroup.users_group_id)\ |
|
3549 | UserGroup.users_group_id)\ | |
3550 | .join( |
|
3550 | .join( | |
3551 | UserGroupMember, |
|
3551 | UserGroupMember, | |
3552 | UserGroupUserGroupToPerm.user_group_id == |
|
3552 | UserGroupUserGroupToPerm.user_group_id == | |
3553 | UserGroupMember.users_group_id)\ |
|
3553 | UserGroupMember.users_group_id)\ | |
3554 | .filter( |
|
3554 | .filter( | |
3555 | UserGroupMember.user_id == user_id, |
|
3555 | UserGroupMember.user_id == user_id, | |
3556 | UserGroup.users_group_active == true()) |
|
3556 | UserGroup.users_group_active == true()) | |
3557 | if user_group_id: |
|
3557 | if user_group_id: | |
3558 | q = q.filter( |
|
3558 | q = q.filter( | |
3559 | UserGroupUserGroupToPerm.user_group_id == user_group_id) |
|
3559 | UserGroupUserGroupToPerm.user_group_id == user_group_id) | |
3560 |
|
3560 | |||
3561 | return q.all() |
|
3561 | return q.all() | |
3562 |
|
3562 | |||
3563 |
|
3563 | |||
3564 | class UserRepoToPerm(Base, BaseModel): |
|
3564 | class UserRepoToPerm(Base, BaseModel): | |
3565 | __tablename__ = 'repo_to_perm' |
|
3565 | __tablename__ = 'repo_to_perm' | |
3566 | __table_args__ = ( |
|
3566 | __table_args__ = ( | |
3567 | UniqueConstraint('user_id', 'repository_id', 'permission_id'), |
|
3567 | UniqueConstraint('user_id', 'repository_id', 'permission_id'), | |
3568 | base_table_args |
|
3568 | base_table_args | |
3569 | ) |
|
3569 | ) | |
3570 |
|
3570 | |||
3571 | repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3571 | repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3572 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) |
|
3572 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
3573 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
3573 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
3574 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) |
|
3574 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) | |
3575 |
|
3575 | |||
3576 | user = relationship('User', back_populates="repo_to_perm") |
|
3576 | user = relationship('User', back_populates="repo_to_perm") | |
3577 | repository = relationship('Repository', back_populates="repo_to_perm") |
|
3577 | repository = relationship('Repository', back_populates="repo_to_perm") | |
3578 | permission = relationship('Permission') |
|
3578 | permission = relationship('Permission') | |
3579 |
|
3579 | |||
3580 | branch_perm_entry = relationship('UserToRepoBranchPermission', cascade="all, delete-orphan", lazy='joined', back_populates='user_repo_to_perm') |
|
3580 | branch_perm_entry = relationship('UserToRepoBranchPermission', cascade="all, delete-orphan", lazy='joined', back_populates='user_repo_to_perm') | |
3581 |
|
3581 | |||
3582 | @classmethod |
|
3582 | @classmethod | |
3583 | def create(cls, user, repository, permission): |
|
3583 | def create(cls, user, repository, permission): | |
3584 | n = cls() |
|
3584 | n = cls() | |
3585 | n.user = user |
|
3585 | n.user = user | |
3586 | n.repository = repository |
|
3586 | n.repository = repository | |
3587 | n.permission = permission |
|
3587 | n.permission = permission | |
3588 | Session().add(n) |
|
3588 | Session().add(n) | |
3589 | return n |
|
3589 | return n | |
3590 |
|
3590 | |||
3591 | def __repr__(self): |
|
3591 | def __repr__(self): | |
3592 | return f'<{self.user} => {self.repository} >' |
|
3592 | return f'<{self.user} => {self.repository} >' | |
3593 |
|
3593 | |||
3594 |
|
3594 | |||
3595 | class UserUserGroupToPerm(Base, BaseModel): |
|
3595 | class UserUserGroupToPerm(Base, BaseModel): | |
3596 | __tablename__ = 'user_user_group_to_perm' |
|
3596 | __tablename__ = 'user_user_group_to_perm' | |
3597 | __table_args__ = ( |
|
3597 | __table_args__ = ( | |
3598 | UniqueConstraint('user_id', 'user_group_id', 'permission_id'), |
|
3598 | UniqueConstraint('user_id', 'user_group_id', 'permission_id'), | |
3599 | base_table_args |
|
3599 | base_table_args | |
3600 | ) |
|
3600 | ) | |
3601 |
|
3601 | |||
3602 | user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3602 | user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3603 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) |
|
3603 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
3604 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
3604 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
3605 | user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) |
|
3605 | user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
3606 |
|
3606 | |||
3607 | user = relationship('User', back_populates='user_group_to_perm') |
|
3607 | user = relationship('User', back_populates='user_group_to_perm') | |
3608 | user_group = relationship('UserGroup', back_populates='user_user_group_to_perm') |
|
3608 | user_group = relationship('UserGroup', back_populates='user_user_group_to_perm') | |
3609 | permission = relationship('Permission') |
|
3609 | permission = relationship('Permission') | |
3610 |
|
3610 | |||
3611 | @classmethod |
|
3611 | @classmethod | |
3612 | def create(cls, user, user_group, permission): |
|
3612 | def create(cls, user, user_group, permission): | |
3613 | n = cls() |
|
3613 | n = cls() | |
3614 | n.user = user |
|
3614 | n.user = user | |
3615 | n.user_group = user_group |
|
3615 | n.user_group = user_group | |
3616 | n.permission = permission |
|
3616 | n.permission = permission | |
3617 | Session().add(n) |
|
3617 | Session().add(n) | |
3618 | return n |
|
3618 | return n | |
3619 |
|
3619 | |||
3620 | def __repr__(self): |
|
3620 | def __repr__(self): | |
3621 | return f'<{self.user} => {self.user_group} >' |
|
3621 | return f'<{self.user} => {self.user_group} >' | |
3622 |
|
3622 | |||
3623 |
|
3623 | |||
3624 | class UserToPerm(Base, BaseModel): |
|
3624 | class UserToPerm(Base, BaseModel): | |
3625 | __tablename__ = 'user_to_perm' |
|
3625 | __tablename__ = 'user_to_perm' | |
3626 | __table_args__ = ( |
|
3626 | __table_args__ = ( | |
3627 | UniqueConstraint('user_id', 'permission_id'), |
|
3627 | UniqueConstraint('user_id', 'permission_id'), | |
3628 | base_table_args |
|
3628 | base_table_args | |
3629 | ) |
|
3629 | ) | |
3630 |
|
3630 | |||
3631 | user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3631 | user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3632 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) |
|
3632 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
3633 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
3633 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
3634 |
|
3634 | |||
3635 | user = relationship('User', back_populates='user_perms') |
|
3635 | user = relationship('User', back_populates='user_perms') | |
3636 | permission = relationship('Permission', lazy='joined') |
|
3636 | permission = relationship('Permission', lazy='joined') | |
3637 |
|
3637 | |||
3638 | def __repr__(self): |
|
3638 | def __repr__(self): | |
3639 | return f'<{self.user} => {self.permission} >' |
|
3639 | return f'<{self.user} => {self.permission} >' | |
3640 |
|
3640 | |||
3641 |
|
3641 | |||
3642 | class UserGroupRepoToPerm(Base, BaseModel): |
|
3642 | class UserGroupRepoToPerm(Base, BaseModel): | |
3643 | __tablename__ = 'users_group_repo_to_perm' |
|
3643 | __tablename__ = 'users_group_repo_to_perm' | |
3644 | __table_args__ = ( |
|
3644 | __table_args__ = ( | |
3645 | UniqueConstraint('repository_id', 'users_group_id', 'permission_id'), |
|
3645 | UniqueConstraint('repository_id', 'users_group_id', 'permission_id'), | |
3646 | base_table_args |
|
3646 | base_table_args | |
3647 | ) |
|
3647 | ) | |
3648 |
|
3648 | |||
3649 | users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3649 | users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3650 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) |
|
3650 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
3651 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
3651 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
3652 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) |
|
3652 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) | |
3653 |
|
3653 | |||
3654 | users_group = relationship('UserGroup', back_populates='users_group_repo_to_perm') |
|
3654 | users_group = relationship('UserGroup', back_populates='users_group_repo_to_perm') | |
3655 | permission = relationship('Permission') |
|
3655 | permission = relationship('Permission') | |
3656 | repository = relationship('Repository', back_populates='users_group_to_perm') |
|
3656 | repository = relationship('Repository', back_populates='users_group_to_perm') | |
3657 | user_group_branch_perms = relationship('UserGroupToRepoBranchPermission', cascade='all', back_populates='user_group_repo_to_perm') |
|
3657 | user_group_branch_perms = relationship('UserGroupToRepoBranchPermission', cascade='all', back_populates='user_group_repo_to_perm') | |
3658 |
|
3658 | |||
3659 | @classmethod |
|
3659 | @classmethod | |
3660 | def create(cls, users_group, repository, permission): |
|
3660 | def create(cls, users_group, repository, permission): | |
3661 | n = cls() |
|
3661 | n = cls() | |
3662 | n.users_group = users_group |
|
3662 | n.users_group = users_group | |
3663 | n.repository = repository |
|
3663 | n.repository = repository | |
3664 | n.permission = permission |
|
3664 | n.permission = permission | |
3665 | Session().add(n) |
|
3665 | Session().add(n) | |
3666 | return n |
|
3666 | return n | |
3667 |
|
3667 | |||
3668 | def __repr__(self): |
|
3668 | def __repr__(self): | |
3669 | return f'<UserGroupRepoToPerm:{self.users_group} => {self.repository} >' |
|
3669 | return f'<UserGroupRepoToPerm:{self.users_group} => {self.repository} >' | |
3670 |
|
3670 | |||
3671 |
|
3671 | |||
3672 | class UserGroupUserGroupToPerm(Base, BaseModel): |
|
3672 | class UserGroupUserGroupToPerm(Base, BaseModel): | |
3673 | __tablename__ = 'user_group_user_group_to_perm' |
|
3673 | __tablename__ = 'user_group_user_group_to_perm' | |
3674 | __table_args__ = ( |
|
3674 | __table_args__ = ( | |
3675 | UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'), |
|
3675 | UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'), | |
3676 | CheckConstraint('target_user_group_id != user_group_id'), |
|
3676 | CheckConstraint('target_user_group_id != user_group_id'), | |
3677 | base_table_args |
|
3677 | base_table_args | |
3678 | ) |
|
3678 | ) | |
3679 |
|
3679 | |||
3680 | user_group_user_group_to_perm_id = Column("user_group_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3680 | user_group_user_group_to_perm_id = Column("user_group_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3681 | target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) |
|
3681 | target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
3682 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
3682 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
3683 | user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) |
|
3683 | user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
3684 |
|
3684 | |||
3685 | target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id', back_populates='user_group_user_group_to_perm') |
|
3685 | target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id', back_populates='user_group_user_group_to_perm') | |
3686 | user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id') |
|
3686 | user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id') | |
3687 | permission = relationship('Permission') |
|
3687 | permission = relationship('Permission') | |
3688 |
|
3688 | |||
3689 | @classmethod |
|
3689 | @classmethod | |
3690 | def create(cls, target_user_group, user_group, permission): |
|
3690 | def create(cls, target_user_group, user_group, permission): | |
3691 | n = cls() |
|
3691 | n = cls() | |
3692 | n.target_user_group = target_user_group |
|
3692 | n.target_user_group = target_user_group | |
3693 | n.user_group = user_group |
|
3693 | n.user_group = user_group | |
3694 | n.permission = permission |
|
3694 | n.permission = permission | |
3695 | Session().add(n) |
|
3695 | Session().add(n) | |
3696 | return n |
|
3696 | return n | |
3697 |
|
3697 | |||
3698 | def __repr__(self): |
|
3698 | def __repr__(self): | |
3699 | return f'<UserGroupUserGroup:{self.target_user_group} => {self.user_group} >' |
|
3699 | return f'<UserGroupUserGroup:{self.target_user_group} => {self.user_group} >' | |
3700 |
|
3700 | |||
3701 |
|
3701 | |||
3702 | class UserGroupToPerm(Base, BaseModel): |
|
3702 | class UserGroupToPerm(Base, BaseModel): | |
3703 | __tablename__ = 'users_group_to_perm' |
|
3703 | __tablename__ = 'users_group_to_perm' | |
3704 | __table_args__ = ( |
|
3704 | __table_args__ = ( | |
3705 | UniqueConstraint('users_group_id', 'permission_id',), |
|
3705 | UniqueConstraint('users_group_id', 'permission_id',), | |
3706 | base_table_args |
|
3706 | base_table_args | |
3707 | ) |
|
3707 | ) | |
3708 |
|
3708 | |||
3709 | users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3709 | users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3710 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) |
|
3710 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
3711 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
3711 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
3712 |
|
3712 | |||
3713 | users_group = relationship('UserGroup', back_populates='users_group_to_perm') |
|
3713 | users_group = relationship('UserGroup', back_populates='users_group_to_perm') | |
3714 | permission = relationship('Permission') |
|
3714 | permission = relationship('Permission') | |
3715 |
|
3715 | |||
3716 |
|
3716 | |||
3717 | class UserRepoGroupToPerm(Base, BaseModel): |
|
3717 | class UserRepoGroupToPerm(Base, BaseModel): | |
3718 | __tablename__ = 'user_repo_group_to_perm' |
|
3718 | __tablename__ = 'user_repo_group_to_perm' | |
3719 | __table_args__ = ( |
|
3719 | __table_args__ = ( | |
3720 | UniqueConstraint('user_id', 'group_id', 'permission_id'), |
|
3720 | UniqueConstraint('user_id', 'group_id', 'permission_id'), | |
3721 | base_table_args |
|
3721 | base_table_args | |
3722 | ) |
|
3722 | ) | |
3723 |
|
3723 | |||
3724 | group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3724 | group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3725 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) |
|
3725 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
3726 | group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None) |
|
3726 | group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None) | |
3727 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
3727 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
3728 |
|
3728 | |||
3729 | user = relationship('User', back_populates='repo_group_to_perm') |
|
3729 | user = relationship('User', back_populates='repo_group_to_perm') | |
3730 | group = relationship('RepoGroup', back_populates='repo_group_to_perm') |
|
3730 | group = relationship('RepoGroup', back_populates='repo_group_to_perm') | |
3731 | permission = relationship('Permission') |
|
3731 | permission = relationship('Permission') | |
3732 |
|
3732 | |||
3733 | @classmethod |
|
3733 | @classmethod | |
3734 | def create(cls, user, repository_group, permission): |
|
3734 | def create(cls, user, repository_group, permission): | |
3735 | n = cls() |
|
3735 | n = cls() | |
3736 | n.user = user |
|
3736 | n.user = user | |
3737 | n.group = repository_group |
|
3737 | n.group = repository_group | |
3738 | n.permission = permission |
|
3738 | n.permission = permission | |
3739 | Session().add(n) |
|
3739 | Session().add(n) | |
3740 | return n |
|
3740 | return n | |
3741 |
|
3741 | |||
3742 |
|
3742 | |||
3743 | class UserGroupRepoGroupToPerm(Base, BaseModel): |
|
3743 | class UserGroupRepoGroupToPerm(Base, BaseModel): | |
3744 | __tablename__ = 'users_group_repo_group_to_perm' |
|
3744 | __tablename__ = 'users_group_repo_group_to_perm' | |
3745 | __table_args__ = ( |
|
3745 | __table_args__ = ( | |
3746 | UniqueConstraint('users_group_id', 'group_id'), |
|
3746 | UniqueConstraint('users_group_id', 'group_id'), | |
3747 | base_table_args |
|
3747 | base_table_args | |
3748 | ) |
|
3748 | ) | |
3749 |
|
3749 | |||
3750 | users_group_repo_group_to_perm_id = Column("users_group_repo_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3750 | users_group_repo_group_to_perm_id = Column("users_group_repo_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3751 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) |
|
3751 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
3752 | group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None) |
|
3752 | group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None) | |
3753 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
3753 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
3754 |
|
3754 | |||
3755 | users_group = relationship('UserGroup', back_populates='users_group_repo_group_to_perm') |
|
3755 | users_group = relationship('UserGroup', back_populates='users_group_repo_group_to_perm') | |
3756 | permission = relationship('Permission') |
|
3756 | permission = relationship('Permission') | |
3757 | group = relationship('RepoGroup', back_populates='users_group_to_perm') |
|
3757 | group = relationship('RepoGroup', back_populates='users_group_to_perm') | |
3758 |
|
3758 | |||
3759 | @classmethod |
|
3759 | @classmethod | |
3760 | def create(cls, user_group, repository_group, permission): |
|
3760 | def create(cls, user_group, repository_group, permission): | |
3761 | n = cls() |
|
3761 | n = cls() | |
3762 | n.users_group = user_group |
|
3762 | n.users_group = user_group | |
3763 | n.group = repository_group |
|
3763 | n.group = repository_group | |
3764 | n.permission = permission |
|
3764 | n.permission = permission | |
3765 | Session().add(n) |
|
3765 | Session().add(n) | |
3766 | return n |
|
3766 | return n | |
3767 |
|
3767 | |||
3768 | def __repr__(self): |
|
3768 | def __repr__(self): | |
3769 | return '<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group) |
|
3769 | return '<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group) | |
3770 |
|
3770 | |||
3771 |
|
3771 | |||
3772 | class Statistics(Base, BaseModel): |
|
3772 | class Statistics(Base, BaseModel): | |
3773 | __tablename__ = 'statistics' |
|
3773 | __tablename__ = 'statistics' | |
3774 | __table_args__ = ( |
|
3774 | __table_args__ = ( | |
3775 | base_table_args |
|
3775 | base_table_args | |
3776 | ) |
|
3776 | ) | |
3777 |
|
3777 | |||
3778 | stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3778 | stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3779 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None) |
|
3779 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None) | |
3780 | stat_on_revision = Column("stat_on_revision", Integer(), nullable=False) |
|
3780 | stat_on_revision = Column("stat_on_revision", Integer(), nullable=False) | |
3781 | commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False) #JSON data |
|
3781 | commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False) #JSON data | |
3782 | commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False) #JSON data |
|
3782 | commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False) #JSON data | |
3783 | languages = Column("languages", LargeBinary(1000000), nullable=False) #JSON data |
|
3783 | languages = Column("languages", LargeBinary(1000000), nullable=False) #JSON data | |
3784 |
|
3784 | |||
3785 | repository = relationship('Repository', single_parent=True, viewonly=True) |
|
3785 | repository = relationship('Repository', single_parent=True, viewonly=True) | |
3786 |
|
3786 | |||
3787 |
|
3787 | |||
3788 | class UserFollowing(Base, BaseModel): |
|
3788 | class UserFollowing(Base, BaseModel): | |
3789 | __tablename__ = 'user_followings' |
|
3789 | __tablename__ = 'user_followings' | |
3790 | __table_args__ = ( |
|
3790 | __table_args__ = ( | |
3791 | UniqueConstraint('user_id', 'follows_repository_id'), |
|
3791 | UniqueConstraint('user_id', 'follows_repository_id'), | |
3792 | UniqueConstraint('user_id', 'follows_user_id'), |
|
3792 | UniqueConstraint('user_id', 'follows_user_id'), | |
3793 | base_table_args |
|
3793 | base_table_args | |
3794 | ) |
|
3794 | ) | |
3795 |
|
3795 | |||
3796 | user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3796 | user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3797 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) |
|
3797 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
3798 | follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None) |
|
3798 | follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None) | |
3799 | follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) |
|
3799 | follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) | |
3800 | follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now) |
|
3800 | follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now) | |
3801 |
|
3801 | |||
3802 | user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id', back_populates='followings') |
|
3802 | user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id', back_populates='followings') | |
3803 |
|
3803 | |||
3804 | follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id') |
|
3804 | follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id') | |
3805 | follows_repository = relationship('Repository', order_by='Repository.repo_name', back_populates='followers') |
|
3805 | follows_repository = relationship('Repository', order_by='Repository.repo_name', back_populates='followers') | |
3806 |
|
3806 | |||
3807 | @classmethod |
|
3807 | @classmethod | |
3808 | def get_repo_followers(cls, repo_id): |
|
3808 | def get_repo_followers(cls, repo_id): | |
3809 | return cls.query().filter(cls.follows_repo_id == repo_id) |
|
3809 | return cls.query().filter(cls.follows_repo_id == repo_id) | |
3810 |
|
3810 | |||
3811 |
|
3811 | |||
3812 | class CacheKey(Base, BaseModel): |
|
3812 | class CacheKey(Base, BaseModel): | |
3813 | __tablename__ = 'cache_invalidation' |
|
3813 | __tablename__ = 'cache_invalidation' | |
3814 | __table_args__ = ( |
|
3814 | __table_args__ = ( | |
3815 | UniqueConstraint('cache_key'), |
|
3815 | UniqueConstraint('cache_key'), | |
3816 | Index('key_idx', 'cache_key'), |
|
3816 | Index('key_idx', 'cache_key'), | |
3817 | Index('cache_args_idx', 'cache_args'), |
|
3817 | Index('cache_args_idx', 'cache_args'), | |
3818 | base_table_args, |
|
3818 | base_table_args, | |
3819 | ) |
|
3819 | ) | |
3820 |
|
3820 | |||
3821 | CACHE_TYPE_FEED = 'FEED' |
|
3821 | CACHE_TYPE_FEED = 'FEED' | |
3822 |
|
3822 | |||
3823 | # namespaces used to register process/thread aware caches |
|
3823 | # namespaces used to register process/thread aware caches | |
3824 | REPO_INVALIDATION_NAMESPACE = 'repo_cache.v1:{repo_id}' |
|
3824 | REPO_INVALIDATION_NAMESPACE = 'repo_cache.v1:{repo_id}' | |
3825 |
|
3825 | |||
3826 | cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
3826 | cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
3827 | cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None) |
|
3827 | cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None) | |
3828 | cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None) |
|
3828 | cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None) | |
3829 | cache_state_uid = Column("cache_state_uid", String(255), nullable=True, unique=None, default=None) |
|
3829 | cache_state_uid = Column("cache_state_uid", String(255), nullable=True, unique=None, default=None) | |
3830 | cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False) |
|
3830 | cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False) | |
3831 |
|
3831 | |||
3832 | def __init__(self, cache_key, cache_args='', cache_state_uid=None, cache_active=False): |
|
3832 | def __init__(self, cache_key, cache_args='', cache_state_uid=None, cache_active=False): | |
3833 | self.cache_key = cache_key |
|
3833 | self.cache_key = cache_key | |
3834 | self.cache_args = cache_args |
|
3834 | self.cache_args = cache_args | |
3835 | self.cache_active = cache_active |
|
3835 | self.cache_active = cache_active | |
3836 | # first key should be same for all entries, since all workers should share it |
|
3836 | # first key should be same for all entries, since all workers should share it | |
3837 | self.cache_state_uid = cache_state_uid or self.generate_new_state_uid() |
|
3837 | self.cache_state_uid = cache_state_uid or self.generate_new_state_uid() | |
3838 |
|
3838 | |||
3839 | def __repr__(self): |
|
3839 | def __repr__(self): | |
3840 | return "<%s('%s:%s[%s]')>" % ( |
|
3840 | return "<%s('%s:%s[%s]')>" % ( | |
3841 | self.cls_name, |
|
3841 | self.cls_name, | |
3842 | self.cache_id, self.cache_key, self.cache_active) |
|
3842 | self.cache_id, self.cache_key, self.cache_active) | |
3843 |
|
3843 | |||
3844 | def _cache_key_partition(self): |
|
3844 | def _cache_key_partition(self): | |
3845 | prefix, repo_name, suffix = self.cache_key.partition(self.cache_args) |
|
3845 | prefix, repo_name, suffix = self.cache_key.partition(self.cache_args) | |
3846 | return prefix, repo_name, suffix |
|
3846 | return prefix, repo_name, suffix | |
3847 |
|
3847 | |||
3848 | def get_prefix(self): |
|
3848 | def get_prefix(self): | |
3849 | """ |
|
3849 | """ | |
3850 | Try to extract prefix from existing cache key. The key could consist |
|
3850 | Try to extract prefix from existing cache key. The key could consist | |
3851 | of prefix, repo_name, suffix |
|
3851 | of prefix, repo_name, suffix | |
3852 | """ |
|
3852 | """ | |
3853 | # this returns prefix, repo_name, suffix |
|
3853 | # this returns prefix, repo_name, suffix | |
3854 | return self._cache_key_partition()[0] |
|
3854 | return self._cache_key_partition()[0] | |
3855 |
|
3855 | |||
3856 | def get_suffix(self): |
|
3856 | def get_suffix(self): | |
3857 | """ |
|
3857 | """ | |
3858 | get suffix that might have been used in _get_cache_key to |
|
3858 | get suffix that might have been used in _get_cache_key to | |
3859 | generate self.cache_key. Only used for informational purposes |
|
3859 | generate self.cache_key. Only used for informational purposes | |
3860 | in repo_edit.mako. |
|
3860 | in repo_edit.mako. | |
3861 | """ |
|
3861 | """ | |
3862 | # prefix, repo_name, suffix |
|
3862 | # prefix, repo_name, suffix | |
3863 | return self._cache_key_partition()[2] |
|
3863 | return self._cache_key_partition()[2] | |
3864 |
|
3864 | |||
3865 | @classmethod |
|
3865 | @classmethod | |
3866 | def generate_new_state_uid(cls, based_on=None): |
|
3866 | def generate_new_state_uid(cls, based_on=None): | |
3867 | if based_on: |
|
3867 | if based_on: | |
3868 | return str(uuid.uuid5(uuid.NAMESPACE_URL, safe_str(based_on))) |
|
3868 | return str(uuid.uuid5(uuid.NAMESPACE_URL, safe_str(based_on))) | |
3869 | else: |
|
3869 | else: | |
3870 | return str(uuid.uuid4()) |
|
3870 | return str(uuid.uuid4()) | |
3871 |
|
3871 | |||
3872 | @classmethod |
|
3872 | @classmethod | |
3873 | def delete_all_cache(cls): |
|
3873 | def delete_all_cache(cls): | |
3874 | """ |
|
3874 | """ | |
3875 | Delete all cache keys from database. |
|
3875 | Delete all cache keys from database. | |
3876 | Should only be run when all instances are down and all entries |
|
3876 | Should only be run when all instances are down and all entries | |
3877 | thus stale. |
|
3877 | thus stale. | |
3878 | """ |
|
3878 | """ | |
3879 | cls.query().delete() |
|
3879 | cls.query().delete() | |
3880 | Session().commit() |
|
3880 | Session().commit() | |
3881 |
|
3881 | |||
3882 | @classmethod |
|
3882 | @classmethod | |
3883 | def set_invalidate(cls, cache_uid, delete=False): |
|
3883 | def set_invalidate(cls, cache_uid, delete=False): | |
3884 | """ |
|
3884 | """ | |
3885 | Mark all caches of a repo as invalid in the database. |
|
3885 | Mark all caches of a repo as invalid in the database. | |
3886 | """ |
|
3886 | """ | |
3887 | try: |
|
3887 | try: | |
3888 | qry = Session().query(cls).filter(cls.cache_key == cache_uid) |
|
3888 | qry = Session().query(cls).filter(cls.cache_key == cache_uid) | |
3889 | if delete: |
|
3889 | if delete: | |
3890 | qry.delete() |
|
3890 | qry.delete() | |
3891 | log.debug('cache objects deleted for cache args %s', |
|
3891 | log.debug('cache objects deleted for cache args %s', | |
3892 | safe_str(cache_uid)) |
|
3892 | safe_str(cache_uid)) | |
3893 | else: |
|
3893 | else: | |
3894 | new_uid = cls.generate_new_state_uid() |
|
3894 | new_uid = cls.generate_new_state_uid() | |
3895 | qry.update({"cache_state_uid": new_uid, |
|
3895 | qry.update({"cache_state_uid": new_uid, | |
3896 | "cache_args": f"repo_state:{time.time()}"}) |
|
3896 | "cache_args": f"repo_state:{time.time()}"}) | |
3897 | log.debug('cache object %s set new UID %s', |
|
3897 | log.debug('cache object %s set new UID %s', | |
3898 | safe_str(cache_uid), new_uid) |
|
3898 | safe_str(cache_uid), new_uid) | |
3899 |
|
3899 | |||
3900 | Session().commit() |
|
3900 | Session().commit() | |
3901 | except Exception: |
|
3901 | except Exception: | |
3902 | log.exception( |
|
3902 | log.exception( | |
3903 | 'Cache key invalidation failed for cache args %s', |
|
3903 | 'Cache key invalidation failed for cache args %s', | |
3904 | safe_str(cache_uid)) |
|
3904 | safe_str(cache_uid)) | |
3905 | Session().rollback() |
|
3905 | Session().rollback() | |
3906 |
|
3906 | |||
3907 | @classmethod |
|
3907 | @classmethod | |
3908 | def get_active_cache(cls, cache_key): |
|
3908 | def get_active_cache(cls, cache_key): | |
3909 | inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar() |
|
3909 | inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar() | |
3910 | if inv_obj: |
|
3910 | if inv_obj: | |
3911 | return inv_obj |
|
3911 | return inv_obj | |
3912 | return None |
|
3912 | return None | |
3913 |
|
3913 | |||
3914 | @classmethod |
|
3914 | @classmethod | |
3915 | def get_namespace_map(cls, namespace): |
|
3915 | def get_namespace_map(cls, namespace): | |
3916 | return { |
|
3916 | return { | |
3917 | x.cache_key: x |
|
3917 | x.cache_key: x | |
3918 | for x in cls.query().filter(cls.cache_args == namespace)} |
|
3918 | for x in cls.query().filter(cls.cache_args == namespace)} | |
3919 |
|
3919 | |||
3920 |
|
3920 | |||
3921 | class ChangesetComment(Base, BaseModel): |
|
3921 | class ChangesetComment(Base, BaseModel): | |
3922 | __tablename__ = 'changeset_comments' |
|
3922 | __tablename__ = 'changeset_comments' | |
3923 | __table_args__ = ( |
|
3923 | __table_args__ = ( | |
3924 | Index('cc_revision_idx', 'revision'), |
|
3924 | Index('cc_revision_idx', 'revision'), | |
3925 | base_table_args, |
|
3925 | base_table_args, | |
3926 | ) |
|
3926 | ) | |
3927 |
|
3927 | |||
3928 | COMMENT_OUTDATED = 'comment_outdated' |
|
3928 | COMMENT_OUTDATED = 'comment_outdated' | |
3929 | COMMENT_TYPE_NOTE = 'note' |
|
3929 | COMMENT_TYPE_NOTE = 'note' | |
3930 | COMMENT_TYPE_TODO = 'todo' |
|
3930 | COMMENT_TYPE_TODO = 'todo' | |
3931 | COMMENT_TYPES = [COMMENT_TYPE_NOTE, COMMENT_TYPE_TODO] |
|
3931 | COMMENT_TYPES = [COMMENT_TYPE_NOTE, COMMENT_TYPE_TODO] | |
3932 |
|
3932 | |||
3933 | OP_IMMUTABLE = 'immutable' |
|
3933 | OP_IMMUTABLE = 'immutable' | |
3934 | OP_CHANGEABLE = 'changeable' |
|
3934 | OP_CHANGEABLE = 'changeable' | |
3935 |
|
3935 | |||
3936 | comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True) |
|
3936 | comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True) | |
3937 | repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False) |
|
3937 | repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False) | |
3938 | revision = Column('revision', String(40), nullable=True) |
|
3938 | revision = Column('revision', String(40), nullable=True) | |
3939 | pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True) |
|
3939 | pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True) | |
3940 | pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True) |
|
3940 | pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True) | |
3941 | line_no = Column('line_no', Unicode(10), nullable=True) |
|
3941 | line_no = Column('line_no', Unicode(10), nullable=True) | |
3942 | hl_lines = Column('hl_lines', Unicode(512), nullable=True) |
|
3942 | hl_lines = Column('hl_lines', Unicode(512), nullable=True) | |
3943 | f_path = Column('f_path', Unicode(1000), nullable=True) |
|
3943 | f_path = Column('f_path', Unicode(1000), nullable=True) | |
3944 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False) |
|
3944 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False) | |
3945 | text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False) |
|
3945 | text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False) | |
3946 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
3946 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
3947 | modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
3947 | modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
3948 | renderer = Column('renderer', Unicode(64), nullable=True) |
|
3948 | renderer = Column('renderer', Unicode(64), nullable=True) | |
3949 | display_state = Column('display_state', Unicode(128), nullable=True) |
|
3949 | display_state = Column('display_state', Unicode(128), nullable=True) | |
3950 | immutable_state = Column('immutable_state', Unicode(128), nullable=True, default=OP_CHANGEABLE) |
|
3950 | immutable_state = Column('immutable_state', Unicode(128), nullable=True, default=OP_CHANGEABLE) | |
3951 | draft = Column('draft', Boolean(), nullable=True, default=False) |
|
3951 | draft = Column('draft', Boolean(), nullable=True, default=False) | |
3952 |
|
3952 | |||
3953 | comment_type = Column('comment_type', Unicode(128), nullable=True, default=COMMENT_TYPE_NOTE) |
|
3953 | comment_type = Column('comment_type', Unicode(128), nullable=True, default=COMMENT_TYPE_NOTE) | |
3954 | resolved_comment_id = Column('resolved_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=True) |
|
3954 | resolved_comment_id = Column('resolved_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=True) | |
3955 |
|
3955 | |||
3956 | resolved_comment = relationship('ChangesetComment', remote_side=comment_id, back_populates='resolved_by') |
|
3956 | resolved_comment = relationship('ChangesetComment', remote_side=comment_id, back_populates='resolved_by') | |
3957 | resolved_by = relationship('ChangesetComment', back_populates='resolved_comment') |
|
3957 | resolved_by = relationship('ChangesetComment', back_populates='resolved_comment') | |
3958 |
|
3958 | |||
3959 | author = relationship('User', lazy='select', back_populates='user_comments') |
|
3959 | author = relationship('User', lazy='select', back_populates='user_comments') | |
3960 | repo = relationship('Repository', back_populates='comments') |
|
3960 | repo = relationship('Repository', back_populates='comments') | |
3961 | status_change = relationship('ChangesetStatus', cascade="all, delete-orphan", lazy='select', back_populates='comment') |
|
3961 | status_change = relationship('ChangesetStatus', cascade="all, delete-orphan", lazy='select', back_populates='comment') | |
3962 | pull_request = relationship('PullRequest', lazy='select', back_populates='comments') |
|
3962 | pull_request = relationship('PullRequest', lazy='select', back_populates='comments') | |
3963 | pull_request_version = relationship('PullRequestVersion', lazy='select') |
|
3963 | pull_request_version = relationship('PullRequestVersion', lazy='select') | |
3964 | history = relationship('ChangesetCommentHistory', cascade='all, delete-orphan', lazy='select', order_by='ChangesetCommentHistory.version', back_populates="comment") |
|
3964 | history = relationship('ChangesetCommentHistory', cascade='all, delete-orphan', lazy='select', order_by='ChangesetCommentHistory.version', back_populates="comment") | |
3965 |
|
3965 | |||
3966 | @classmethod |
|
3966 | @classmethod | |
3967 | def get_users(cls, revision=None, pull_request_id=None): |
|
3967 | def get_users(cls, revision=None, pull_request_id=None): | |
3968 | """ |
|
3968 | """ | |
3969 | Returns user associated with this ChangesetComment. ie those |
|
3969 | Returns user associated with this ChangesetComment. ie those | |
3970 | who actually commented |
|
3970 | who actually commented | |
3971 |
|
3971 | |||
3972 | :param cls: |
|
3972 | :param cls: | |
3973 | :param revision: |
|
3973 | :param revision: | |
3974 | """ |
|
3974 | """ | |
3975 | q = Session().query(User).join(ChangesetComment.author) |
|
3975 | q = Session().query(User).join(ChangesetComment.author) | |
3976 | if revision: |
|
3976 | if revision: | |
3977 | q = q.filter(cls.revision == revision) |
|
3977 | q = q.filter(cls.revision == revision) | |
3978 | elif pull_request_id: |
|
3978 | elif pull_request_id: | |
3979 | q = q.filter(cls.pull_request_id == pull_request_id) |
|
3979 | q = q.filter(cls.pull_request_id == pull_request_id) | |
3980 | return q.all() |
|
3980 | return q.all() | |
3981 |
|
3981 | |||
3982 | @classmethod |
|
3982 | @classmethod | |
3983 | def get_index_from_version(cls, pr_version, versions=None, num_versions=None) -> int: |
|
3983 | def get_index_from_version(cls, pr_version, versions=None, num_versions=None) -> int: | |
3984 | if pr_version is None: |
|
3984 | if pr_version is None: | |
3985 | return 0 |
|
3985 | return 0 | |
3986 |
|
3986 | |||
3987 | if versions is not None: |
|
3987 | if versions is not None: | |
3988 | num_versions = [x.pull_request_version_id for x in versions] |
|
3988 | num_versions = [x.pull_request_version_id for x in versions] | |
3989 |
|
3989 | |||
3990 | num_versions = num_versions or [] |
|
3990 | num_versions = num_versions or [] | |
3991 | try: |
|
3991 | try: | |
3992 | return num_versions.index(pr_version) + 1 |
|
3992 | return num_versions.index(pr_version) + 1 | |
3993 | except (IndexError, ValueError): |
|
3993 | except (IndexError, ValueError): | |
3994 | return 0 |
|
3994 | return 0 | |
3995 |
|
3995 | |||
3996 | @property |
|
3996 | @property | |
3997 | def outdated(self): |
|
3997 | def outdated(self): | |
3998 | return self.display_state == self.COMMENT_OUTDATED |
|
3998 | return self.display_state == self.COMMENT_OUTDATED | |
3999 |
|
3999 | |||
4000 | @property |
|
4000 | @property | |
4001 | def outdated_js(self): |
|
4001 | def outdated_js(self): | |
4002 | return str_json(self.display_state == self.COMMENT_OUTDATED) |
|
4002 | return str_json(self.display_state == self.COMMENT_OUTDATED) | |
4003 |
|
4003 | |||
4004 | @property |
|
4004 | @property | |
4005 | def immutable(self): |
|
4005 | def immutable(self): | |
4006 | return self.immutable_state == self.OP_IMMUTABLE |
|
4006 | return self.immutable_state == self.OP_IMMUTABLE | |
4007 |
|
4007 | |||
4008 | def outdated_at_version(self, version: int) -> bool: |
|
4008 | def outdated_at_version(self, version: int) -> bool: | |
4009 | """ |
|
4009 | """ | |
4010 | Checks if comment is outdated for given pull request version |
|
4010 | Checks if comment is outdated for given pull request version | |
4011 | """ |
|
4011 | """ | |
4012 |
|
4012 | |||
4013 | def version_check(): |
|
4013 | def version_check(): | |
4014 | return self.pull_request_version_id and self.pull_request_version_id != version |
|
4014 | return self.pull_request_version_id and self.pull_request_version_id != version | |
4015 |
|
4015 | |||
4016 | if self.is_inline: |
|
4016 | if self.is_inline: | |
4017 | return self.outdated and version_check() |
|
4017 | return self.outdated and version_check() | |
4018 | else: |
|
4018 | else: | |
4019 | # general comments don't have .outdated set, also latest don't have a version |
|
4019 | # general comments don't have .outdated set, also latest don't have a version | |
4020 | return version_check() |
|
4020 | return version_check() | |
4021 |
|
4021 | |||
4022 | def outdated_at_version_js(self, version): |
|
4022 | def outdated_at_version_js(self, version): | |
4023 | """ |
|
4023 | """ | |
4024 | Checks if comment is outdated for given pull request version |
|
4024 | Checks if comment is outdated for given pull request version | |
4025 | """ |
|
4025 | """ | |
4026 | return str_json(self.outdated_at_version(version)) |
|
4026 | return str_json(self.outdated_at_version(version)) | |
4027 |
|
4027 | |||
4028 | def older_than_version(self, version: int) -> bool: |
|
4028 | def older_than_version(self, version: int) -> bool: | |
4029 | """ |
|
4029 | """ | |
4030 | Checks if comment is made from a previous version than given. |
|
4030 | Checks if comment is made from a previous version than given. | |
4031 | Assumes self.pull_request_version.pull_request_version_id is an integer if not None. |
|
4031 | Assumes self.pull_request_version.pull_request_version_id is an integer if not None. | |
4032 | """ |
|
4032 | """ | |
4033 |
|
4033 | |||
4034 | # If version is None, return False as the current version cannot be less than None |
|
4034 | # If version is None, return False as the current version cannot be less than None | |
4035 | if version is None: |
|
4035 | if version is None: | |
4036 | return False |
|
4036 | return False | |
4037 |
|
4037 | |||
4038 | # Ensure that the version is an integer to prevent TypeError on comparison |
|
4038 | # Ensure that the version is an integer to prevent TypeError on comparison | |
4039 | if not isinstance(version, int): |
|
4039 | if not isinstance(version, int): | |
4040 | raise ValueError("The provided version must be an integer.") |
|
4040 | raise ValueError("The provided version must be an integer.") | |
4041 |
|
4041 | |||
4042 | # Initialize current version to 0 or pull_request_version_id if it's available |
|
4042 | # Initialize current version to 0 or pull_request_version_id if it's available | |
4043 | cur_ver = 0 |
|
4043 | cur_ver = 0 | |
4044 | if self.pull_request_version and self.pull_request_version.pull_request_version_id is not None: |
|
4044 | if self.pull_request_version and self.pull_request_version.pull_request_version_id is not None: | |
4045 | cur_ver = self.pull_request_version.pull_request_version_id |
|
4045 | cur_ver = self.pull_request_version.pull_request_version_id | |
4046 |
|
4046 | |||
4047 | # Return True if the current version is less than the given version |
|
4047 | # Return True if the current version is less than the given version | |
4048 | return cur_ver < version |
|
4048 | return cur_ver < version | |
4049 |
|
4049 | |||
4050 | def older_than_version_js(self, version): |
|
4050 | def older_than_version_js(self, version): | |
4051 | """ |
|
4051 | """ | |
4052 | Checks if comment is made from previous version than given |
|
4052 | Checks if comment is made from previous version than given | |
4053 | """ |
|
4053 | """ | |
4054 | return str_json(self.older_than_version(version)) |
|
4054 | return str_json(self.older_than_version(version)) | |
4055 |
|
4055 | |||
4056 | @property |
|
4056 | @property | |
4057 | def commit_id(self): |
|
4057 | def commit_id(self): | |
4058 | """New style naming to stop using .revision""" |
|
4058 | """New style naming to stop using .revision""" | |
4059 | return self.revision |
|
4059 | return self.revision | |
4060 |
|
4060 | |||
4061 | @property |
|
4061 | @property | |
4062 | def resolved(self): |
|
4062 | def resolved(self): | |
4063 | return self.resolved_by[0] if self.resolved_by else None |
|
4063 | return self.resolved_by[0] if self.resolved_by else None | |
4064 |
|
4064 | |||
4065 | @property |
|
4065 | @property | |
4066 | def is_todo(self): |
|
4066 | def is_todo(self): | |
4067 | return self.comment_type == self.COMMENT_TYPE_TODO |
|
4067 | return self.comment_type == self.COMMENT_TYPE_TODO | |
4068 |
|
4068 | |||
4069 | @property |
|
4069 | @property | |
4070 | def is_inline(self): |
|
4070 | def is_inline(self): | |
4071 | if self.line_no and self.f_path: |
|
4071 | if self.line_no and self.f_path: | |
4072 | return True |
|
4072 | return True | |
4073 | return False |
|
4073 | return False | |
4074 |
|
4074 | |||
4075 | @property |
|
4075 | @property | |
4076 | def last_version(self): |
|
4076 | def last_version(self): | |
4077 | version = 0 |
|
4077 | version = 0 | |
4078 | if self.history: |
|
4078 | if self.history: | |
4079 | version = self.history[-1].version |
|
4079 | version = self.history[-1].version | |
4080 | return version |
|
4080 | return version | |
4081 |
|
4081 | |||
4082 | def get_index_version(self, versions): |
|
4082 | def get_index_version(self, versions): | |
4083 | return self.get_index_from_version( |
|
4083 | return self.get_index_from_version( | |
4084 | self.pull_request_version_id, versions) |
|
4084 | self.pull_request_version_id, versions) | |
4085 |
|
4085 | |||
4086 | @property |
|
4086 | @property | |
4087 | def review_status(self): |
|
4087 | def review_status(self): | |
4088 | if self.status_change: |
|
4088 | if self.status_change: | |
4089 | return self.status_change[0].status |
|
4089 | return self.status_change[0].status | |
4090 |
|
4090 | |||
4091 | @property |
|
4091 | @property | |
4092 | def review_status_lbl(self): |
|
4092 | def review_status_lbl(self): | |
4093 | if self.status_change: |
|
4093 | if self.status_change: | |
4094 | return self.status_change[0].status_lbl |
|
4094 | return self.status_change[0].status_lbl | |
4095 |
|
4095 | |||
4096 | def __repr__(self): |
|
4096 | def __repr__(self): | |
4097 | if self.comment_id: |
|
4097 | if self.comment_id: | |
4098 | return f'<DB:Comment #{self.comment_id}>' |
|
4098 | return f'<DB:Comment #{self.comment_id}>' | |
4099 | else: |
|
4099 | else: | |
4100 | return f'<DB:Comment at {id(self)!r}>' |
|
4100 | return f'<DB:Comment at {id(self)!r}>' | |
4101 |
|
4101 | |||
4102 | def get_api_data(self): |
|
4102 | def get_api_data(self): | |
4103 | comment = self |
|
4103 | comment = self | |
4104 |
|
4104 | |||
4105 | data = { |
|
4105 | data = { | |
4106 | 'comment_id': comment.comment_id, |
|
4106 | 'comment_id': comment.comment_id, | |
4107 | 'comment_type': comment.comment_type, |
|
4107 | 'comment_type': comment.comment_type, | |
4108 | 'comment_text': comment.text, |
|
4108 | 'comment_text': comment.text, | |
4109 | 'comment_status': comment.status_change, |
|
4109 | 'comment_status': comment.status_change, | |
4110 | 'comment_f_path': comment.f_path, |
|
4110 | 'comment_f_path': comment.f_path, | |
4111 | 'comment_lineno': comment.line_no, |
|
4111 | 'comment_lineno': comment.line_no, | |
4112 | 'comment_author': comment.author, |
|
4112 | 'comment_author': comment.author, | |
4113 | 'comment_created_on': comment.created_on, |
|
4113 | 'comment_created_on': comment.created_on, | |
4114 | 'comment_resolved_by': self.resolved, |
|
4114 | 'comment_resolved_by': self.resolved, | |
4115 | 'comment_commit_id': comment.revision, |
|
4115 | 'comment_commit_id': comment.revision, | |
4116 | 'comment_pull_request_id': comment.pull_request_id, |
|
4116 | 'comment_pull_request_id': comment.pull_request_id, | |
4117 | 'comment_last_version': self.last_version |
|
4117 | 'comment_last_version': self.last_version | |
4118 | } |
|
4118 | } | |
4119 | return data |
|
4119 | return data | |
4120 |
|
4120 | |||
4121 | def __json__(self): |
|
4121 | def __json__(self): | |
4122 | data = dict() |
|
4122 | data = dict() | |
4123 | data.update(self.get_api_data()) |
|
4123 | data.update(self.get_api_data()) | |
4124 | return data |
|
4124 | return data | |
4125 |
|
4125 | |||
4126 |
|
4126 | |||
4127 | class ChangesetCommentHistory(Base, BaseModel): |
|
4127 | class ChangesetCommentHistory(Base, BaseModel): | |
4128 | __tablename__ = 'changeset_comments_history' |
|
4128 | __tablename__ = 'changeset_comments_history' | |
4129 | __table_args__ = ( |
|
4129 | __table_args__ = ( | |
4130 | Index('cch_comment_id_idx', 'comment_id'), |
|
4130 | Index('cch_comment_id_idx', 'comment_id'), | |
4131 | base_table_args, |
|
4131 | base_table_args, | |
4132 | ) |
|
4132 | ) | |
4133 |
|
4133 | |||
4134 | comment_history_id = Column('comment_history_id', Integer(), nullable=False, primary_key=True) |
|
4134 | comment_history_id = Column('comment_history_id', Integer(), nullable=False, primary_key=True) | |
4135 | comment_id = Column('comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=False) |
|
4135 | comment_id = Column('comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=False) | |
4136 | version = Column("version", Integer(), nullable=False, default=0) |
|
4136 | version = Column("version", Integer(), nullable=False, default=0) | |
4137 | created_by_user_id = Column('created_by_user_id', Integer(), ForeignKey('users.user_id'), nullable=False) |
|
4137 | created_by_user_id = Column('created_by_user_id', Integer(), ForeignKey('users.user_id'), nullable=False) | |
4138 | text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False) |
|
4138 | text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False) | |
4139 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
4139 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
4140 | deleted = Column('deleted', Boolean(), default=False) |
|
4140 | deleted = Column('deleted', Boolean(), default=False) | |
4141 |
|
4141 | |||
4142 | author = relationship('User', lazy='joined') |
|
4142 | author = relationship('User', lazy='joined') | |
4143 | comment = relationship('ChangesetComment', cascade="all, delete", back_populates="history") |
|
4143 | comment = relationship('ChangesetComment', cascade="all, delete", back_populates="history") | |
4144 |
|
4144 | |||
4145 | @classmethod |
|
4145 | @classmethod | |
4146 | def get_version(cls, comment_id): |
|
4146 | def get_version(cls, comment_id): | |
4147 | q = Session().query(ChangesetCommentHistory).filter( |
|
4147 | q = Session().query(ChangesetCommentHistory).filter( | |
4148 | ChangesetCommentHistory.comment_id == comment_id).order_by(ChangesetCommentHistory.version.desc()) |
|
4148 | ChangesetCommentHistory.comment_id == comment_id).order_by(ChangesetCommentHistory.version.desc()) | |
4149 | if q.count() == 0: |
|
4149 | if q.count() == 0: | |
4150 | return 1 |
|
4150 | return 1 | |
4151 | elif q.count() >= q[0].version: |
|
4151 | elif q.count() >= q[0].version: | |
4152 | return q.count() + 1 |
|
4152 | return q.count() + 1 | |
4153 | else: |
|
4153 | else: | |
4154 | return q[0].version + 1 |
|
4154 | return q[0].version + 1 | |
4155 |
|
4155 | |||
4156 |
|
4156 | |||
4157 | class ChangesetStatus(Base, BaseModel): |
|
4157 | class ChangesetStatus(Base, BaseModel): | |
4158 | __tablename__ = 'changeset_statuses' |
|
4158 | __tablename__ = 'changeset_statuses' | |
4159 | __table_args__ = ( |
|
4159 | __table_args__ = ( | |
4160 | Index('cs_revision_idx', 'revision'), |
|
4160 | Index('cs_revision_idx', 'revision'), | |
4161 | Index('cs_version_idx', 'version'), |
|
4161 | Index('cs_version_idx', 'version'), | |
4162 | UniqueConstraint('repo_id', 'revision', 'version'), |
|
4162 | UniqueConstraint('repo_id', 'revision', 'version'), | |
4163 | base_table_args |
|
4163 | base_table_args | |
4164 | ) |
|
4164 | ) | |
4165 |
|
4165 | |||
4166 | STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed' |
|
4166 | STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed' | |
4167 | STATUS_APPROVED = 'approved' |
|
4167 | STATUS_APPROVED = 'approved' | |
4168 | STATUS_REJECTED = 'rejected' |
|
4168 | STATUS_REJECTED = 'rejected' | |
4169 | STATUS_UNDER_REVIEW = 'under_review' |
|
4169 | STATUS_UNDER_REVIEW = 'under_review' | |
4170 |
|
4170 | |||
4171 | STATUSES = [ |
|
4171 | STATUSES = [ | |
4172 | (STATUS_NOT_REVIEWED, _("Not Reviewed")), # (no icon) and default |
|
4172 | (STATUS_NOT_REVIEWED, _("Not Reviewed")), # (no icon) and default | |
4173 | (STATUS_APPROVED, _("Approved")), |
|
4173 | (STATUS_APPROVED, _("Approved")), | |
4174 | (STATUS_REJECTED, _("Rejected")), |
|
4174 | (STATUS_REJECTED, _("Rejected")), | |
4175 | (STATUS_UNDER_REVIEW, _("Under Review")), |
|
4175 | (STATUS_UNDER_REVIEW, _("Under Review")), | |
4176 | ] |
|
4176 | ] | |
4177 |
|
4177 | |||
4178 | changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True) |
|
4178 | changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True) | |
4179 | repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False) |
|
4179 | repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False) | |
4180 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None) |
|
4180 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None) | |
4181 | revision = Column('revision', String(40), nullable=False) |
|
4181 | revision = Column('revision', String(40), nullable=False) | |
4182 | status = Column('status', String(128), nullable=False, default=DEFAULT) |
|
4182 | status = Column('status', String(128), nullable=False, default=DEFAULT) | |
4183 | changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id')) |
|
4183 | changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id')) | |
4184 | modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now) |
|
4184 | modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now) | |
4185 | version = Column('version', Integer(), nullable=False, default=0) |
|
4185 | version = Column('version', Integer(), nullable=False, default=0) | |
4186 | pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True) |
|
4186 | pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True) | |
4187 |
|
4187 | |||
4188 | author = relationship('User', lazy='select') |
|
4188 | author = relationship('User', lazy='select') | |
4189 | repo = relationship('Repository', lazy='select') |
|
4189 | repo = relationship('Repository', lazy='select') | |
4190 | comment = relationship('ChangesetComment', lazy='select', back_populates='status_change') |
|
4190 | comment = relationship('ChangesetComment', lazy='select', back_populates='status_change') | |
4191 | pull_request = relationship('PullRequest', lazy='select', back_populates='statuses') |
|
4191 | pull_request = relationship('PullRequest', lazy='select', back_populates='statuses') | |
4192 |
|
4192 | |||
4193 | def __repr__(self): |
|
4193 | def __repr__(self): | |
4194 | return f"<{self.cls_name}('{self.status}[v{self.version}]:{self.author}')>" |
|
4194 | return f"<{self.cls_name}('{self.status}[v{self.version}]:{self.author}')>" | |
4195 |
|
4195 | |||
4196 | @classmethod |
|
4196 | @classmethod | |
4197 | def get_status_lbl(cls, value): |
|
4197 | def get_status_lbl(cls, value): | |
4198 | return dict(cls.STATUSES).get(value) |
|
4198 | return dict(cls.STATUSES).get(value) | |
4199 |
|
4199 | |||
4200 | @property |
|
4200 | @property | |
4201 | def status_lbl(self): |
|
4201 | def status_lbl(self): | |
4202 | return ChangesetStatus.get_status_lbl(self.status) |
|
4202 | return ChangesetStatus.get_status_lbl(self.status) | |
4203 |
|
4203 | |||
4204 | def get_api_data(self): |
|
4204 | def get_api_data(self): | |
4205 | status = self |
|
4205 | status = self | |
4206 | data = { |
|
4206 | data = { | |
4207 | 'status_id': status.changeset_status_id, |
|
4207 | 'status_id': status.changeset_status_id, | |
4208 | 'status': status.status, |
|
4208 | 'status': status.status, | |
4209 | } |
|
4209 | } | |
4210 | return data |
|
4210 | return data | |
4211 |
|
4211 | |||
4212 | def __json__(self): |
|
4212 | def __json__(self): | |
4213 | data = dict() |
|
4213 | data = dict() | |
4214 | data.update(self.get_api_data()) |
|
4214 | data.update(self.get_api_data()) | |
4215 | return data |
|
4215 | return data | |
4216 |
|
4216 | |||
4217 |
|
4217 | |||
4218 | class _SetState(object): |
|
4218 | class _SetState(object): | |
4219 | """ |
|
4219 | """ | |
4220 | Context processor allowing changing state for sensitive operation such as |
|
4220 | Context processor allowing changing state for sensitive operation such as | |
4221 | pull request update or merge |
|
4221 | pull request update or merge | |
4222 | """ |
|
4222 | """ | |
4223 |
|
4223 | |||
4224 | def __init__(self, pull_request, pr_state, back_state=None): |
|
4224 | def __init__(self, pull_request, pr_state, back_state=None): | |
4225 | self._pr = pull_request |
|
4225 | self._pr = pull_request | |
4226 | self._org_state = back_state or pull_request.pull_request_state |
|
4226 | self._org_state = back_state or pull_request.pull_request_state | |
4227 | self._pr_state = pr_state |
|
4227 | self._pr_state = pr_state | |
4228 | self._current_state = None |
|
4228 | self._current_state = None | |
4229 |
|
4229 | |||
4230 | def __enter__(self): |
|
4230 | def __enter__(self): | |
4231 | log.debug('StateLock: entering set state context of pr %s, setting state to: `%s`', |
|
4231 | log.debug('StateLock: entering set state context of pr %s, setting state to: `%s`', | |
4232 | self._pr, self._pr_state) |
|
4232 | self._pr, self._pr_state) | |
4233 | self.set_pr_state(self._pr_state) |
|
4233 | self.set_pr_state(self._pr_state) | |
4234 | return self |
|
4234 | return self | |
4235 |
|
4235 | |||
4236 | def __exit__(self, exc_type, exc_val, exc_tb): |
|
4236 | def __exit__(self, exc_type, exc_val, exc_tb): | |
4237 | if exc_val is not None or exc_type is not None: |
|
4237 | if exc_val is not None or exc_type is not None: | |
4238 | log.error(traceback.format_tb(exc_tb)) |
|
4238 | log.error(traceback.format_tb(exc_tb)) | |
4239 | return None |
|
4239 | return None | |
4240 |
|
4240 | |||
4241 | self.set_pr_state(self._org_state) |
|
4241 | self.set_pr_state(self._org_state) | |
4242 | log.debug('StateLock: exiting set state context of pr %s, setting state to: `%s`', |
|
4242 | log.debug('StateLock: exiting set state context of pr %s, setting state to: `%s`', | |
4243 | self._pr, self._org_state) |
|
4243 | self._pr, self._org_state) | |
4244 |
|
4244 | |||
4245 | @property |
|
4245 | @property | |
4246 | def state(self): |
|
4246 | def state(self): | |
4247 | return self._current_state |
|
4247 | return self._current_state | |
4248 |
|
4248 | |||
4249 | def set_pr_state(self, pr_state): |
|
4249 | def set_pr_state(self, pr_state): | |
4250 | try: |
|
4250 | try: | |
4251 | self._pr.pull_request_state = pr_state |
|
4251 | self._pr.pull_request_state = pr_state | |
4252 | Session().add(self._pr) |
|
4252 | Session().add(self._pr) | |
4253 | Session().commit() |
|
4253 | Session().commit() | |
4254 | self._current_state = pr_state |
|
4254 | self._current_state = pr_state | |
4255 | except Exception: |
|
4255 | except Exception: | |
4256 | log.exception('Failed to set PullRequest %s state to %s', self._pr, pr_state) |
|
4256 | log.exception('Failed to set PullRequest %s state to %s', self._pr, pr_state) | |
4257 | raise |
|
4257 | raise | |
4258 |
|
4258 | |||
4259 |
|
4259 | |||
4260 | class _PullRequestBase(BaseModel): |
|
4260 | class _PullRequestBase(BaseModel): | |
4261 | """ |
|
4261 | """ | |
4262 | Common attributes of pull request and version entries. |
|
4262 | Common attributes of pull request and version entries. | |
4263 | """ |
|
4263 | """ | |
4264 |
|
4264 | |||
4265 | # .status values |
|
4265 | # .status values | |
4266 | STATUS_NEW = 'new' |
|
4266 | STATUS_NEW = 'new' | |
4267 | STATUS_OPEN = 'open' |
|
4267 | STATUS_OPEN = 'open' | |
4268 | STATUS_CLOSED = 'closed' |
|
4268 | STATUS_CLOSED = 'closed' | |
4269 |
|
4269 | |||
4270 | # available states |
|
4270 | # available states | |
4271 | STATE_CREATING = 'creating' |
|
4271 | STATE_CREATING = 'creating' | |
4272 | STATE_UPDATING = 'updating' |
|
4272 | STATE_UPDATING = 'updating' | |
4273 | STATE_MERGING = 'merging' |
|
4273 | STATE_MERGING = 'merging' | |
4274 | STATE_CREATED = 'created' |
|
4274 | STATE_CREATED = 'created' | |
4275 |
|
4275 | |||
4276 | title = Column('title', Unicode(255), nullable=True) |
|
4276 | title = Column('title', Unicode(255), nullable=True) | |
4277 | description = Column( |
|
4277 | description = Column( | |
4278 | 'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), |
|
4278 | 'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), | |
4279 | nullable=True) |
|
4279 | nullable=True) | |
4280 | description_renderer = Column('description_renderer', Unicode(64), nullable=True) |
|
4280 | description_renderer = Column('description_renderer', Unicode(64), nullable=True) | |
4281 |
|
4281 | |||
4282 | # new/open/closed status of pull request (not approve/reject/etc) |
|
4282 | # new/open/closed status of pull request (not approve/reject/etc) | |
4283 | status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW) |
|
4283 | status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW) | |
4284 | created_on = Column( |
|
4284 | created_on = Column( | |
4285 | 'created_on', DateTime(timezone=False), nullable=False, |
|
4285 | 'created_on', DateTime(timezone=False), nullable=False, | |
4286 | default=datetime.datetime.now) |
|
4286 | default=datetime.datetime.now) | |
4287 | updated_on = Column( |
|
4287 | updated_on = Column( | |
4288 | 'updated_on', DateTime(timezone=False), nullable=False, |
|
4288 | 'updated_on', DateTime(timezone=False), nullable=False, | |
4289 | default=datetime.datetime.now) |
|
4289 | default=datetime.datetime.now) | |
4290 |
|
4290 | |||
4291 | pull_request_state = Column("pull_request_state", String(255), nullable=True) |
|
4291 | pull_request_state = Column("pull_request_state", String(255), nullable=True) | |
4292 |
|
4292 | |||
4293 | @declared_attr |
|
4293 | @declared_attr | |
4294 | def user_id(cls): |
|
4294 | def user_id(cls): | |
4295 | return Column( |
|
4295 | return Column( | |
4296 | "user_id", Integer(), ForeignKey('users.user_id'), nullable=False, |
|
4296 | "user_id", Integer(), ForeignKey('users.user_id'), nullable=False, | |
4297 | unique=None) |
|
4297 | unique=None) | |
4298 |
|
4298 | |||
4299 | # 500 revisions max |
|
4299 | # 500 revisions max | |
4300 | _revisions = Column( |
|
4300 | _revisions = Column( | |
4301 | 'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql')) |
|
4301 | 'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql')) | |
4302 |
|
4302 | |||
4303 | common_ancestor_id = Column('common_ancestor_id', Unicode(255), nullable=True) |
|
4303 | common_ancestor_id = Column('common_ancestor_id', Unicode(255), nullable=True) | |
4304 |
|
4304 | |||
4305 | @declared_attr |
|
4305 | @declared_attr | |
4306 | def source_repo_id(cls): |
|
4306 | def source_repo_id(cls): | |
4307 | # TODO: dan: rename column to source_repo_id |
|
4307 | # TODO: dan: rename column to source_repo_id | |
4308 | return Column( |
|
4308 | return Column( | |
4309 | 'org_repo_id', Integer(), ForeignKey('repositories.repo_id'), |
|
4309 | 'org_repo_id', Integer(), ForeignKey('repositories.repo_id'), | |
4310 | nullable=False) |
|
4310 | nullable=False) | |
4311 |
|
4311 | |||
4312 | @declared_attr |
|
4312 | @declared_attr | |
4313 | def pr_source(cls): |
|
4313 | def pr_source(cls): | |
4314 | return relationship( |
|
4314 | return relationship( | |
4315 | 'Repository', |
|
4315 | 'Repository', | |
4316 | primaryjoin=f'{cls.__name__}.source_repo_id==Repository.repo_id', |
|
4316 | primaryjoin=f'{cls.__name__}.source_repo_id==Repository.repo_id', | |
4317 | overlaps="pull_requests_source" |
|
4317 | overlaps="pull_requests_source" | |
4318 | ) |
|
4318 | ) | |
4319 |
|
4319 | |||
4320 | _source_ref = Column('org_ref', Unicode(255), nullable=False) |
|
4320 | _source_ref = Column('org_ref', Unicode(255), nullable=False) | |
4321 |
|
4321 | |||
4322 | @hybrid_property |
|
4322 | @hybrid_property | |
4323 | def source_ref(self): |
|
4323 | def source_ref(self): | |
4324 | return self._source_ref |
|
4324 | return self._source_ref | |
4325 |
|
4325 | |||
4326 | @source_ref.setter |
|
4326 | @source_ref.setter | |
4327 | def source_ref(self, val): |
|
4327 | def source_ref(self, val): | |
4328 | parts = (val or '').split(':') |
|
4328 | parts = (val or '').split(':') | |
4329 | if len(parts) != 3: |
|
4329 | if len(parts) != 3: | |
4330 | raise ValueError( |
|
4330 | raise ValueError( | |
4331 | 'Invalid reference format given: {}, expected X:Y:Z'.format(val)) |
|
4331 | 'Invalid reference format given: {}, expected X:Y:Z'.format(val)) | |
4332 | self._source_ref = safe_str(val) |
|
4332 | self._source_ref = safe_str(val) | |
4333 |
|
4333 | |||
4334 | _target_ref = Column('other_ref', Unicode(255), nullable=False) |
|
4334 | _target_ref = Column('other_ref', Unicode(255), nullable=False) | |
4335 |
|
4335 | |||
4336 | @hybrid_property |
|
4336 | @hybrid_property | |
4337 | def target_ref(self): |
|
4337 | def target_ref(self): | |
4338 | return self._target_ref |
|
4338 | return self._target_ref | |
4339 |
|
4339 | |||
4340 | @target_ref.setter |
|
4340 | @target_ref.setter | |
4341 | def target_ref(self, val): |
|
4341 | def target_ref(self, val): | |
4342 | parts = (val or '').split(':') |
|
4342 | parts = (val or '').split(':') | |
4343 | if len(parts) != 3: |
|
4343 | if len(parts) != 3: | |
4344 | raise ValueError( |
|
4344 | raise ValueError( | |
4345 | 'Invalid reference format given: {}, expected X:Y:Z'.format(val)) |
|
4345 | 'Invalid reference format given: {}, expected X:Y:Z'.format(val)) | |
4346 | self._target_ref = safe_str(val) |
|
4346 | self._target_ref = safe_str(val) | |
4347 |
|
4347 | |||
4348 | @declared_attr |
|
4348 | @declared_attr | |
4349 | def target_repo_id(cls): |
|
4349 | def target_repo_id(cls): | |
4350 | # TODO: dan: rename column to target_repo_id |
|
4350 | # TODO: dan: rename column to target_repo_id | |
4351 | return Column( |
|
4351 | return Column( | |
4352 | 'other_repo_id', Integer(), ForeignKey('repositories.repo_id'), |
|
4352 | 'other_repo_id', Integer(), ForeignKey('repositories.repo_id'), | |
4353 | nullable=False) |
|
4353 | nullable=False) | |
4354 |
|
4354 | |||
4355 | @declared_attr |
|
4355 | @declared_attr | |
4356 | def pr_target(cls): |
|
4356 | def pr_target(cls): | |
4357 | return relationship( |
|
4357 | return relationship( | |
4358 | 'Repository', |
|
4358 | 'Repository', | |
4359 | primaryjoin=f'{cls.__name__}.target_repo_id==Repository.repo_id', |
|
4359 | primaryjoin=f'{cls.__name__}.target_repo_id==Repository.repo_id', | |
4360 | overlaps="pull_requests_target" |
|
4360 | overlaps="pull_requests_target" | |
4361 | ) |
|
4361 | ) | |
4362 |
|
4362 | |||
4363 | _shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True) |
|
4363 | _shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True) | |
4364 |
|
4364 | |||
4365 | # TODO: dan: rename column to last_merge_source_rev |
|
4365 | # TODO: dan: rename column to last_merge_source_rev | |
4366 | _last_merge_source_rev = Column( |
|
4366 | _last_merge_source_rev = Column( | |
4367 | 'last_merge_org_rev', String(40), nullable=True) |
|
4367 | 'last_merge_org_rev', String(40), nullable=True) | |
4368 | # TODO: dan: rename column to last_merge_target_rev |
|
4368 | # TODO: dan: rename column to last_merge_target_rev | |
4369 | _last_merge_target_rev = Column( |
|
4369 | _last_merge_target_rev = Column( | |
4370 | 'last_merge_other_rev', String(40), nullable=True) |
|
4370 | 'last_merge_other_rev', String(40), nullable=True) | |
4371 | _last_merge_status = Column('merge_status', Integer(), nullable=True) |
|
4371 | _last_merge_status = Column('merge_status', Integer(), nullable=True) | |
4372 | last_merge_metadata = Column( |
|
4372 | last_merge_metadata = Column( | |
4373 | 'last_merge_metadata', MutationObj.as_mutable( |
|
4373 | 'last_merge_metadata', MutationObj.as_mutable( | |
4374 | JsonType(dialect_map=dict(mysql=UnicodeText(16384))))) |
|
4374 | JsonType(dialect_map=dict(mysql=UnicodeText(16384))))) | |
4375 |
|
4375 | |||
4376 | merge_rev = Column('merge_rev', String(40), nullable=True) |
|
4376 | merge_rev = Column('merge_rev', String(40), nullable=True) | |
4377 |
|
4377 | |||
4378 | reviewer_data = Column( |
|
4378 | reviewer_data = Column( | |
4379 | 'reviewer_data_json', MutationObj.as_mutable( |
|
4379 | 'reviewer_data_json', MutationObj.as_mutable( | |
4380 | JsonType(dialect_map=dict(mysql=UnicodeText(16384))))) |
|
4380 | JsonType(dialect_map=dict(mysql=UnicodeText(16384))))) | |
4381 |
|
4381 | |||
4382 | @property |
|
4382 | @property | |
4383 | def reviewer_data_json(self): |
|
4383 | def reviewer_data_json(self): | |
4384 | return str_json(self.reviewer_data) |
|
4384 | return str_json(self.reviewer_data) | |
4385 |
|
4385 | |||
4386 | @property |
|
4386 | @property | |
4387 | def last_merge_metadata_parsed(self): |
|
4387 | def last_merge_metadata_parsed(self): | |
4388 | metadata = {} |
|
4388 | metadata = {} | |
4389 | if not self.last_merge_metadata: |
|
4389 | if not self.last_merge_metadata: | |
4390 | return metadata |
|
4390 | return metadata | |
4391 |
|
4391 | |||
4392 | if hasattr(self.last_merge_metadata, 'de_coerce'): |
|
4392 | if hasattr(self.last_merge_metadata, 'de_coerce'): | |
4393 | for k, v in self.last_merge_metadata.de_coerce().items(): |
|
4393 | for k, v in self.last_merge_metadata.de_coerce().items(): | |
4394 | if k in ['target_ref', 'source_ref']: |
|
4394 | if k in ['target_ref', 'source_ref']: | |
4395 | metadata[k] = Reference(v['type'], v['name'], v['commit_id']) |
|
4395 | metadata[k] = Reference(v['type'], v['name'], v['commit_id']) | |
4396 | else: |
|
4396 | else: | |
4397 | if hasattr(v, 'de_coerce'): |
|
4397 | if hasattr(v, 'de_coerce'): | |
4398 | metadata[k] = v.de_coerce() |
|
4398 | metadata[k] = v.de_coerce() | |
4399 | else: |
|
4399 | else: | |
4400 | metadata[k] = v |
|
4400 | metadata[k] = v | |
4401 | return metadata |
|
4401 | return metadata | |
4402 |
|
4402 | |||
4403 | @property |
|
4403 | @property | |
4404 | def work_in_progress(self): |
|
4404 | def work_in_progress(self): | |
4405 | """checks if pull request is work in progress by checking the title""" |
|
4405 | """checks if pull request is work in progress by checking the title""" | |
4406 | title = self.title.upper() |
|
4406 | title = self.title.upper() | |
4407 | if re.match(r'^(\[WIP\]\s*|WIP:\s*|WIP\s+)', title): |
|
4407 | if re.match(r'^(\[WIP\]\s*|WIP:\s*|WIP\s+)', title): | |
4408 | return True |
|
4408 | return True | |
4409 | return False |
|
4409 | return False | |
4410 |
|
4410 | |||
4411 | @property |
|
4411 | @property | |
4412 | def title_safe(self): |
|
4412 | def title_safe(self): | |
4413 | return self.title\ |
|
4413 | return self.title\ | |
4414 | .replace('{', '{{')\ |
|
4414 | .replace('{', '{{')\ | |
4415 | .replace('}', '}}') |
|
4415 | .replace('}', '}}') | |
4416 |
|
4416 | |||
4417 | @hybrid_property |
|
4417 | @hybrid_property | |
4418 | def description_safe(self): |
|
4418 | def description_safe(self): | |
4419 | return description_escaper(self.description) |
|
4419 | return description_escaper(self.description) | |
4420 |
|
4420 | |||
4421 | @hybrid_property |
|
4421 | @hybrid_property | |
4422 | def revisions(self): |
|
4422 | def revisions(self): | |
4423 | return self._revisions.split(':') if self._revisions else [] |
|
4423 | return self._revisions.split(':') if self._revisions else [] | |
4424 |
|
4424 | |||
4425 | @revisions.setter |
|
4425 | @revisions.setter | |
4426 | def revisions(self, val): |
|
4426 | def revisions(self, val): | |
4427 | self._revisions = ':'.join(val) |
|
4427 | self._revisions = ':'.join(val) | |
4428 |
|
4428 | |||
4429 | @hybrid_property |
|
4429 | @hybrid_property | |
4430 | def last_merge_status(self): |
|
4430 | def last_merge_status(self): | |
4431 | return safe_int(self._last_merge_status) |
|
4431 | return safe_int(self._last_merge_status) | |
4432 |
|
4432 | |||
4433 | @last_merge_status.setter |
|
4433 | @last_merge_status.setter | |
4434 | def last_merge_status(self, val): |
|
4434 | def last_merge_status(self, val): | |
4435 | self._last_merge_status = val |
|
4435 | self._last_merge_status = val | |
4436 |
|
4436 | |||
4437 | @declared_attr |
|
4437 | @declared_attr | |
4438 | def author(cls): |
|
4438 | def author(cls): | |
4439 | return relationship( |
|
4439 | return relationship( | |
4440 | 'User', lazy='joined', |
|
4440 | 'User', lazy='joined', | |
4441 | #TODO, problem that is somehow :? |
|
4441 | #TODO, problem that is somehow :? | |
4442 | #back_populates='user_pull_requests' |
|
4442 | #back_populates='user_pull_requests' | |
4443 | ) |
|
4443 | ) | |
4444 |
|
4444 | |||
4445 | @declared_attr |
|
4445 | @declared_attr | |
4446 | def source_repo(cls): |
|
4446 | def source_repo(cls): | |
4447 | return relationship( |
|
4447 | return relationship( | |
4448 | 'Repository', |
|
4448 | 'Repository', | |
4449 | primaryjoin=f'{cls.__name__}.source_repo_id==Repository.repo_id', |
|
4449 | primaryjoin=f'{cls.__name__}.source_repo_id==Repository.repo_id', | |
4450 | overlaps="pr_source" |
|
4450 | overlaps="pr_source" | |
4451 | ) |
|
4451 | ) | |
4452 |
|
4452 | |||
4453 | @property |
|
4453 | @property | |
4454 | def source_ref_parts(self): |
|
4454 | def source_ref_parts(self): | |
4455 | return self.unicode_to_reference(self.source_ref) |
|
4455 | return self.unicode_to_reference(self.source_ref) | |
4456 |
|
4456 | |||
4457 | @declared_attr |
|
4457 | @declared_attr | |
4458 | def target_repo(cls): |
|
4458 | def target_repo(cls): | |
4459 | return relationship( |
|
4459 | return relationship( | |
4460 | 'Repository', |
|
4460 | 'Repository', | |
4461 | primaryjoin=f'{cls.__name__}.target_repo_id==Repository.repo_id', |
|
4461 | primaryjoin=f'{cls.__name__}.target_repo_id==Repository.repo_id', | |
4462 | overlaps="pr_target" |
|
4462 | overlaps="pr_target" | |
4463 | ) |
|
4463 | ) | |
4464 |
|
4464 | |||
4465 | @property |
|
4465 | @property | |
4466 | def target_ref_parts(self): |
|
4466 | def target_ref_parts(self): | |
4467 | return self.unicode_to_reference(self.target_ref) |
|
4467 | return self.unicode_to_reference(self.target_ref) | |
4468 |
|
4468 | |||
4469 | @property |
|
4469 | @property | |
4470 | def shadow_merge_ref(self): |
|
4470 | def shadow_merge_ref(self): | |
4471 | return self.unicode_to_reference(self._shadow_merge_ref) |
|
4471 | return self.unicode_to_reference(self._shadow_merge_ref) | |
4472 |
|
4472 | |||
4473 | @shadow_merge_ref.setter |
|
4473 | @shadow_merge_ref.setter | |
4474 | def shadow_merge_ref(self, ref): |
|
4474 | def shadow_merge_ref(self, ref): | |
4475 | self._shadow_merge_ref = self.reference_to_unicode(ref) |
|
4475 | self._shadow_merge_ref = self.reference_to_unicode(ref) | |
4476 |
|
4476 | |||
4477 | @staticmethod |
|
4477 | @staticmethod | |
4478 | def unicode_to_reference(raw): |
|
4478 | def unicode_to_reference(raw): | |
4479 | return unicode_to_reference(raw) |
|
4479 | return unicode_to_reference(raw) | |
4480 |
|
4480 | |||
4481 | @staticmethod |
|
4481 | @staticmethod | |
4482 | def reference_to_unicode(ref): |
|
4482 | def reference_to_unicode(ref): | |
4483 | return reference_to_unicode(ref) |
|
4483 | return reference_to_unicode(ref) | |
4484 |
|
4484 | |||
4485 | def get_api_data(self, with_merge_state=True): |
|
4485 | def get_api_data(self, with_merge_state=True): | |
4486 | from rhodecode.model.pull_request import PullRequestModel |
|
4486 | from rhodecode.model.pull_request import PullRequestModel | |
4487 |
|
4487 | |||
4488 | pull_request = self |
|
4488 | pull_request = self | |
4489 | if with_merge_state: |
|
4489 | if with_merge_state: | |
4490 | merge_response, merge_status, msg = \ |
|
4490 | merge_response, merge_status, msg = \ | |
4491 | PullRequestModel().merge_status(pull_request) |
|
4491 | PullRequestModel().merge_status(pull_request) | |
4492 | merge_state = { |
|
4492 | merge_state = { | |
4493 | 'status': merge_status, |
|
4493 | 'status': merge_status, | |
4494 | 'message': safe_str(msg), |
|
4494 | 'message': safe_str(msg), | |
4495 | } |
|
4495 | } | |
4496 | else: |
|
4496 | else: | |
4497 | merge_state = {'status': 'not_available', |
|
4497 | merge_state = {'status': 'not_available', | |
4498 | 'message': 'not_available'} |
|
4498 | 'message': 'not_available'} | |
4499 |
|
4499 | |||
4500 | merge_data = { |
|
4500 | merge_data = { | |
4501 | 'clone_url': PullRequestModel().get_shadow_clone_url(pull_request), |
|
4501 | 'clone_url': PullRequestModel().get_shadow_clone_url(pull_request), | |
4502 | 'reference': ( |
|
4502 | 'reference': ( | |
4503 | pull_request.shadow_merge_ref.asdict() |
|
4503 | pull_request.shadow_merge_ref.asdict() | |
4504 | if pull_request.shadow_merge_ref else None), |
|
4504 | if pull_request.shadow_merge_ref else None), | |
4505 | } |
|
4505 | } | |
4506 |
|
4506 | |||
4507 | data = { |
|
4507 | data = { | |
4508 | 'pull_request_id': pull_request.pull_request_id, |
|
4508 | 'pull_request_id': pull_request.pull_request_id, | |
4509 | 'url': PullRequestModel().get_url(pull_request), |
|
4509 | 'url': PullRequestModel().get_url(pull_request), | |
4510 | 'title': pull_request.title, |
|
4510 | 'title': pull_request.title, | |
4511 | 'description': pull_request.description, |
|
4511 | 'description': pull_request.description, | |
4512 | 'status': pull_request.status, |
|
4512 | 'status': pull_request.status, | |
4513 | 'state': pull_request.pull_request_state, |
|
4513 | 'state': pull_request.pull_request_state, | |
4514 | 'created_on': pull_request.created_on, |
|
4514 | 'created_on': pull_request.created_on, | |
4515 | 'updated_on': pull_request.updated_on, |
|
4515 | 'updated_on': pull_request.updated_on, | |
4516 | 'commit_ids': pull_request.revisions, |
|
4516 | 'commit_ids': pull_request.revisions, | |
4517 | 'review_status': pull_request.calculated_review_status(), |
|
4517 | 'review_status': pull_request.calculated_review_status(), | |
4518 | 'mergeable': merge_state, |
|
4518 | 'mergeable': merge_state, | |
4519 | 'source': { |
|
4519 | 'source': { | |
4520 | 'clone_url': pull_request.source_repo.clone_url(), |
|
4520 | 'clone_url': pull_request.source_repo.clone_url(), | |
4521 | 'repository': pull_request.source_repo.repo_name, |
|
4521 | 'repository': pull_request.source_repo.repo_name, | |
4522 | 'reference': { |
|
4522 | 'reference': { | |
4523 | 'name': pull_request.source_ref_parts.name, |
|
4523 | 'name': pull_request.source_ref_parts.name, | |
4524 | 'type': pull_request.source_ref_parts.type, |
|
4524 | 'type': pull_request.source_ref_parts.type, | |
4525 | 'commit_id': pull_request.source_ref_parts.commit_id, |
|
4525 | 'commit_id': pull_request.source_ref_parts.commit_id, | |
4526 | }, |
|
4526 | }, | |
4527 | }, |
|
4527 | }, | |
4528 | 'target': { |
|
4528 | 'target': { | |
4529 | 'clone_url': pull_request.target_repo.clone_url(), |
|
4529 | 'clone_url': pull_request.target_repo.clone_url(), | |
4530 | 'repository': pull_request.target_repo.repo_name, |
|
4530 | 'repository': pull_request.target_repo.repo_name, | |
4531 | 'reference': { |
|
4531 | 'reference': { | |
4532 | 'name': pull_request.target_ref_parts.name, |
|
4532 | 'name': pull_request.target_ref_parts.name, | |
4533 | 'type': pull_request.target_ref_parts.type, |
|
4533 | 'type': pull_request.target_ref_parts.type, | |
4534 | 'commit_id': pull_request.target_ref_parts.commit_id, |
|
4534 | 'commit_id': pull_request.target_ref_parts.commit_id, | |
4535 | }, |
|
4535 | }, | |
4536 | }, |
|
4536 | }, | |
4537 | 'merge': merge_data, |
|
4537 | 'merge': merge_data, | |
4538 | 'author': pull_request.author.get_api_data(include_secrets=False, |
|
4538 | 'author': pull_request.author.get_api_data(include_secrets=False, | |
4539 | details='basic'), |
|
4539 | details='basic'), | |
4540 | 'reviewers': [ |
|
4540 | 'reviewers': [ | |
4541 | { |
|
4541 | { | |
4542 | 'user': reviewer.get_api_data(include_secrets=False, |
|
4542 | 'user': reviewer.get_api_data(include_secrets=False, | |
4543 | details='basic'), |
|
4543 | details='basic'), | |
4544 | 'reasons': reasons, |
|
4544 | 'reasons': reasons, | |
4545 | 'review_status': st[0][1].status if st else 'not_reviewed', |
|
4545 | 'review_status': st[0][1].status if st else 'not_reviewed', | |
4546 | } |
|
4546 | } | |
4547 | for obj, reviewer, reasons, mandatory, st in |
|
4547 | for obj, reviewer, reasons, mandatory, st in | |
4548 | pull_request.reviewers_statuses() |
|
4548 | pull_request.reviewers_statuses() | |
4549 | ] |
|
4549 | ] | |
4550 | } |
|
4550 | } | |
4551 |
|
4551 | |||
4552 | return data |
|
4552 | return data | |
4553 |
|
4553 | |||
4554 | def set_state(self, pull_request_state, final_state=None): |
|
4554 | def set_state(self, pull_request_state, final_state=None): | |
4555 | """ |
|
4555 | """ | |
4556 | # goes from initial state to updating to initial state. |
|
4556 | # goes from initial state to updating to initial state. | |
4557 | # initial state can be changed by specifying back_state= |
|
4557 | # initial state can be changed by specifying back_state= | |
4558 | with pull_request_obj.set_state(PullRequest.STATE_UPDATING): |
|
4558 | with pull_request_obj.set_state(PullRequest.STATE_UPDATING): | |
4559 | pull_request.merge() |
|
4559 | pull_request.merge() | |
4560 |
|
4560 | |||
4561 | :param pull_request_state: |
|
4561 | :param pull_request_state: | |
4562 | :param final_state: |
|
4562 | :param final_state: | |
4563 |
|
4563 | |||
4564 | """ |
|
4564 | """ | |
4565 |
|
4565 | |||
4566 | return _SetState(self, pull_request_state, back_state=final_state) |
|
4566 | return _SetState(self, pull_request_state, back_state=final_state) | |
4567 |
|
4567 | |||
4568 |
|
4568 | |||
4569 | class PullRequest(Base, _PullRequestBase): |
|
4569 | class PullRequest(Base, _PullRequestBase): | |
4570 | __tablename__ = 'pull_requests' |
|
4570 | __tablename__ = 'pull_requests' | |
4571 | __table_args__ = ( |
|
4571 | __table_args__ = ( | |
4572 | base_table_args, |
|
4572 | base_table_args, | |
4573 | ) |
|
4573 | ) | |
4574 | LATEST_VER = 'latest' |
|
4574 | LATEST_VER = 'latest' | |
4575 |
|
4575 | |||
4576 | pull_request_id = Column( |
|
4576 | pull_request_id = Column( | |
4577 | 'pull_request_id', Integer(), nullable=False, primary_key=True) |
|
4577 | 'pull_request_id', Integer(), nullable=False, primary_key=True) | |
4578 |
|
4578 | |||
4579 | def __repr__(self): |
|
4579 | def __repr__(self): | |
4580 | if self.pull_request_id: |
|
4580 | if self.pull_request_id: | |
4581 | return f'<DB:PullRequest #{self.pull_request_id}>' |
|
4581 | return f'<DB:PullRequest #{self.pull_request_id}>' | |
4582 | else: |
|
4582 | else: | |
4583 | return f'<DB:PullRequest at {id(self)!r}>' |
|
4583 | return f'<DB:PullRequest at {id(self)!r}>' | |
4584 |
|
4584 | |||
4585 | def __str__(self): |
|
4585 | def __str__(self): | |
4586 | if self.pull_request_id: |
|
4586 | if self.pull_request_id: | |
4587 | return f'#{self.pull_request_id}' |
|
4587 | return f'#{self.pull_request_id}' | |
4588 | else: |
|
4588 | else: | |
4589 | return f'#{id(self)!r}' |
|
4589 | return f'#{id(self)!r}' | |
4590 |
|
4590 | |||
4591 | reviewers = relationship('PullRequestReviewers', cascade="all, delete-orphan", back_populates='pull_request') |
|
4591 | reviewers = relationship('PullRequestReviewers', cascade="all, delete-orphan", back_populates='pull_request') | |
4592 | statuses = relationship('ChangesetStatus', cascade="all, delete-orphan", back_populates='pull_request') |
|
4592 | statuses = relationship('ChangesetStatus', cascade="all, delete-orphan", back_populates='pull_request') | |
4593 | comments = relationship('ChangesetComment', cascade="all, delete-orphan", back_populates='pull_request') |
|
4593 | comments = relationship('ChangesetComment', cascade="all, delete-orphan", back_populates='pull_request') | |
4594 | versions = relationship('PullRequestVersion', cascade="all, delete-orphan", lazy='dynamic', back_populates='pull_request') |
|
4594 | versions = relationship('PullRequestVersion', cascade="all, delete-orphan", lazy='dynamic', back_populates='pull_request') | |
4595 |
|
4595 | |||
4596 | @classmethod |
|
4596 | @classmethod | |
4597 | def get_pr_display_object(cls, pull_request_obj, org_pull_request_obj, |
|
4597 | def get_pr_display_object(cls, pull_request_obj, org_pull_request_obj, | |
4598 | internal_methods=None): |
|
4598 | internal_methods=None): | |
4599 |
|
4599 | |||
4600 | class PullRequestDisplay(object): |
|
4600 | class PullRequestDisplay(object): | |
4601 | """ |
|
4601 | """ | |
4602 | Special object wrapper for showing PullRequest data via Versions |
|
4602 | Special object wrapper for showing PullRequest data via Versions | |
4603 | It mimics PR object as close as possible. This is read only object |
|
4603 | It mimics PR object as close as possible. This is read only object | |
4604 | just for display |
|
4604 | just for display | |
4605 | """ |
|
4605 | """ | |
4606 |
|
4606 | |||
4607 | def __init__(self, attrs, internal=None): |
|
4607 | def __init__(self, attrs, internal=None): | |
4608 | self.attrs = attrs |
|
4608 | self.attrs = attrs | |
4609 | # internal have priority over the given ones via attrs |
|
4609 | # internal have priority over the given ones via attrs | |
4610 | self.internal = internal or ['versions'] |
|
4610 | self.internal = internal or ['versions'] | |
4611 |
|
4611 | |||
4612 | def __getattr__(self, item): |
|
4612 | def __getattr__(self, item): | |
4613 | if item in self.internal: |
|
4613 | if item in self.internal: | |
4614 | return getattr(self, item) |
|
4614 | return getattr(self, item) | |
4615 | try: |
|
4615 | try: | |
4616 | return self.attrs[item] |
|
4616 | return self.attrs[item] | |
4617 | except KeyError: |
|
4617 | except KeyError: | |
4618 | raise AttributeError( |
|
4618 | raise AttributeError( | |
4619 | '%s object has no attribute %s' % (self, item)) |
|
4619 | '%s object has no attribute %s' % (self, item)) | |
4620 |
|
4620 | |||
4621 | def __repr__(self): |
|
4621 | def __repr__(self): | |
4622 | pr_id = self.attrs.get('pull_request_id') |
|
4622 | pr_id = self.attrs.get('pull_request_id') | |
4623 | return f'<DB:PullRequestDisplay #{pr_id}>' |
|
4623 | return f'<DB:PullRequestDisplay #{pr_id}>' | |
4624 |
|
4624 | |||
4625 | def versions(self): |
|
4625 | def versions(self): | |
4626 | return pull_request_obj.versions.order_by( |
|
4626 | return pull_request_obj.versions.order_by( | |
4627 | PullRequestVersion.pull_request_version_id).all() |
|
4627 | PullRequestVersion.pull_request_version_id).all() | |
4628 |
|
4628 | |||
4629 | def is_closed(self): |
|
4629 | def is_closed(self): | |
4630 | return pull_request_obj.is_closed() |
|
4630 | return pull_request_obj.is_closed() | |
4631 |
|
4631 | |||
4632 | def is_state_changing(self): |
|
4632 | def is_state_changing(self): | |
4633 | return pull_request_obj.is_state_changing() |
|
4633 | return pull_request_obj.is_state_changing() | |
4634 |
|
4634 | |||
4635 | @property |
|
4635 | @property | |
4636 | def pull_request_version_id(self): |
|
4636 | def pull_request_version_id(self): | |
4637 | return getattr(pull_request_obj, 'pull_request_version_id', None) |
|
4637 | return getattr(pull_request_obj, 'pull_request_version_id', None) | |
4638 |
|
4638 | |||
4639 | @property |
|
4639 | @property | |
4640 | def pull_request_last_version(self): |
|
4640 | def pull_request_last_version(self): | |
4641 | return pull_request_obj.pull_request_last_version |
|
4641 | return pull_request_obj.pull_request_last_version | |
4642 |
|
4642 | |||
4643 | attrs = StrictAttributeDict(pull_request_obj.get_api_data(with_merge_state=False)) |
|
4643 | attrs = StrictAttributeDict(pull_request_obj.get_api_data(with_merge_state=False)) | |
4644 |
|
4644 | |||
4645 | attrs.author = StrictAttributeDict( |
|
4645 | attrs.author = StrictAttributeDict( | |
4646 | pull_request_obj.author.get_api_data()) |
|
4646 | pull_request_obj.author.get_api_data()) | |
4647 | if pull_request_obj.target_repo: |
|
4647 | if pull_request_obj.target_repo: | |
4648 | attrs.target_repo = StrictAttributeDict( |
|
4648 | attrs.target_repo = StrictAttributeDict( | |
4649 | pull_request_obj.target_repo.get_api_data()) |
|
4649 | pull_request_obj.target_repo.get_api_data()) | |
4650 | attrs.target_repo.clone_url = pull_request_obj.target_repo.clone_url |
|
4650 | attrs.target_repo.clone_url = pull_request_obj.target_repo.clone_url | |
4651 |
|
4651 | |||
4652 | if pull_request_obj.source_repo: |
|
4652 | if pull_request_obj.source_repo: | |
4653 | attrs.source_repo = StrictAttributeDict( |
|
4653 | attrs.source_repo = StrictAttributeDict( | |
4654 | pull_request_obj.source_repo.get_api_data()) |
|
4654 | pull_request_obj.source_repo.get_api_data()) | |
4655 | attrs.source_repo.clone_url = pull_request_obj.source_repo.clone_url |
|
4655 | attrs.source_repo.clone_url = pull_request_obj.source_repo.clone_url | |
4656 |
|
4656 | |||
4657 | attrs.source_ref_parts = pull_request_obj.source_ref_parts |
|
4657 | attrs.source_ref_parts = pull_request_obj.source_ref_parts | |
4658 | attrs.target_ref_parts = pull_request_obj.target_ref_parts |
|
4658 | attrs.target_ref_parts = pull_request_obj.target_ref_parts | |
4659 | attrs.revisions = pull_request_obj.revisions |
|
4659 | attrs.revisions = pull_request_obj.revisions | |
4660 | attrs.common_ancestor_id = pull_request_obj.common_ancestor_id |
|
4660 | attrs.common_ancestor_id = pull_request_obj.common_ancestor_id | |
4661 | attrs.shadow_merge_ref = org_pull_request_obj.shadow_merge_ref |
|
4661 | attrs.shadow_merge_ref = org_pull_request_obj.shadow_merge_ref | |
4662 | attrs.reviewer_data = org_pull_request_obj.reviewer_data |
|
4662 | attrs.reviewer_data = org_pull_request_obj.reviewer_data | |
4663 | attrs.reviewer_data_json = org_pull_request_obj.reviewer_data_json |
|
4663 | attrs.reviewer_data_json = org_pull_request_obj.reviewer_data_json | |
4664 |
|
4664 | |||
4665 | return PullRequestDisplay(attrs, internal=internal_methods) |
|
4665 | return PullRequestDisplay(attrs, internal=internal_methods) | |
4666 |
|
4666 | |||
4667 | def is_closed(self): |
|
4667 | def is_closed(self): | |
4668 | return self.status == self.STATUS_CLOSED |
|
4668 | return self.status == self.STATUS_CLOSED | |
4669 |
|
4669 | |||
4670 | def is_state_changing(self): |
|
4670 | def is_state_changing(self): | |
4671 | return self.pull_request_state != PullRequest.STATE_CREATED |
|
4671 | return self.pull_request_state != PullRequest.STATE_CREATED | |
4672 |
|
4672 | |||
4673 | def __json__(self): |
|
4673 | def __json__(self): | |
4674 | return { |
|
4674 | return { | |
4675 | 'revisions': self.revisions, |
|
4675 | 'revisions': self.revisions, | |
4676 | 'versions': self.versions_count |
|
4676 | 'versions': self.versions_count | |
4677 | } |
|
4677 | } | |
4678 |
|
4678 | |||
4679 | def calculated_review_status(self): |
|
4679 | def calculated_review_status(self): | |
4680 | from rhodecode.model.changeset_status import ChangesetStatusModel |
|
4680 | from rhodecode.model.changeset_status import ChangesetStatusModel | |
4681 | return ChangesetStatusModel().calculated_review_status(self) |
|
4681 | return ChangesetStatusModel().calculated_review_status(self) | |
4682 |
|
4682 | |||
4683 | def reviewers_statuses(self, user=None): |
|
4683 | def reviewers_statuses(self, user=None): | |
4684 | from rhodecode.model.changeset_status import ChangesetStatusModel |
|
4684 | from rhodecode.model.changeset_status import ChangesetStatusModel | |
4685 | return ChangesetStatusModel().reviewers_statuses(self, user=user) |
|
4685 | return ChangesetStatusModel().reviewers_statuses(self, user=user) | |
4686 |
|
4686 | |||
4687 | def get_pull_request_reviewers(self, role=None): |
|
4687 | def get_pull_request_reviewers(self, role=None): | |
4688 | qry = PullRequestReviewers.query()\ |
|
4688 | qry = PullRequestReviewers.query()\ | |
4689 | .filter(PullRequestReviewers.pull_request_id == self.pull_request_id) |
|
4689 | .filter(PullRequestReviewers.pull_request_id == self.pull_request_id) | |
4690 | if role: |
|
4690 | if role: | |
4691 | qry = qry.filter(PullRequestReviewers.role == role) |
|
4691 | qry = qry.filter(PullRequestReviewers.role == role) | |
4692 |
|
4692 | |||
4693 | return qry.all() |
|
4693 | return qry.all() | |
4694 |
|
4694 | |||
4695 | @property |
|
4695 | @property | |
4696 | def reviewers_count(self): |
|
4696 | def reviewers_count(self): | |
4697 | qry = PullRequestReviewers.query()\ |
|
4697 | qry = PullRequestReviewers.query()\ | |
4698 | .filter(PullRequestReviewers.pull_request_id == self.pull_request_id)\ |
|
4698 | .filter(PullRequestReviewers.pull_request_id == self.pull_request_id)\ | |
4699 | .filter(PullRequestReviewers.role == PullRequestReviewers.ROLE_REVIEWER) |
|
4699 | .filter(PullRequestReviewers.role == PullRequestReviewers.ROLE_REVIEWER) | |
4700 | return qry.count() |
|
4700 | return qry.count() | |
4701 |
|
4701 | |||
4702 | @property |
|
4702 | @property | |
4703 | def observers_count(self): |
|
4703 | def observers_count(self): | |
4704 | qry = PullRequestReviewers.query()\ |
|
4704 | qry = PullRequestReviewers.query()\ | |
4705 | .filter(PullRequestReviewers.pull_request_id == self.pull_request_id)\ |
|
4705 | .filter(PullRequestReviewers.pull_request_id == self.pull_request_id)\ | |
4706 | .filter(PullRequestReviewers.role == PullRequestReviewers.ROLE_OBSERVER) |
|
4706 | .filter(PullRequestReviewers.role == PullRequestReviewers.ROLE_OBSERVER) | |
4707 | return qry.count() |
|
4707 | return qry.count() | |
4708 |
|
4708 | |||
4709 | def observers(self): |
|
4709 | def observers(self): | |
4710 | qry = PullRequestReviewers.query()\ |
|
4710 | qry = PullRequestReviewers.query()\ | |
4711 | .filter(PullRequestReviewers.pull_request_id == self.pull_request_id)\ |
|
4711 | .filter(PullRequestReviewers.pull_request_id == self.pull_request_id)\ | |
4712 | .filter(PullRequestReviewers.role == PullRequestReviewers.ROLE_OBSERVER)\ |
|
4712 | .filter(PullRequestReviewers.role == PullRequestReviewers.ROLE_OBSERVER)\ | |
4713 | .all() |
|
4713 | .all() | |
4714 |
|
4714 | |||
4715 | for entry in qry: |
|
4715 | for entry in qry: | |
4716 | yield entry, entry.user |
|
4716 | yield entry, entry.user | |
4717 |
|
4717 | |||
4718 | @property |
|
4718 | @property | |
4719 | def workspace_id(self): |
|
4719 | def workspace_id(self): | |
4720 | from rhodecode.model.pull_request import PullRequestModel |
|
4720 | from rhodecode.model.pull_request import PullRequestModel | |
4721 | return PullRequestModel()._workspace_id(self) |
|
4721 | return PullRequestModel()._workspace_id(self) | |
4722 |
|
4722 | |||
4723 | def get_shadow_repo(self): |
|
4723 | def get_shadow_repo(self): | |
4724 | workspace_id = self.workspace_id |
|
4724 | workspace_id = self.workspace_id | |
4725 | shadow_repository_path = self.target_repo.get_shadow_repository_path(workspace_id) |
|
4725 | shadow_repository_path = self.target_repo.get_shadow_repository_path(workspace_id) | |
4726 | if os.path.isdir(shadow_repository_path): |
|
4726 | if os.path.isdir(shadow_repository_path): | |
4727 | vcs_obj = self.target_repo.scm_instance() |
|
4727 | vcs_obj = self.target_repo.scm_instance() | |
4728 | return vcs_obj.get_shadow_instance(shadow_repository_path) |
|
4728 | return vcs_obj.get_shadow_instance(shadow_repository_path) | |
4729 |
|
4729 | |||
4730 | @property |
|
4730 | @property | |
4731 | def versions_count(self): |
|
4731 | def versions_count(self): | |
4732 | """ |
|
4732 | """ | |
4733 | return number of versions this PR have, e.g a PR that once been |
|
4733 | return number of versions this PR have, e.g a PR that once been | |
4734 | updated will have 2 versions |
|
4734 | updated will have 2 versions | |
4735 | """ |
|
4735 | """ | |
4736 | return self.versions.count() + 1 |
|
4736 | return self.versions.count() + 1 | |
4737 |
|
4737 | |||
4738 | @property |
|
4738 | @property | |
4739 | def pull_request_last_version(self): |
|
4739 | def pull_request_last_version(self): | |
4740 | return self.versions_count |
|
4740 | return self.versions_count | |
4741 |
|
4741 | |||
4742 |
|
4742 | |||
4743 | class PullRequestVersion(Base, _PullRequestBase): |
|
4743 | class PullRequestVersion(Base, _PullRequestBase): | |
4744 | __tablename__ = 'pull_request_versions' |
|
4744 | __tablename__ = 'pull_request_versions' | |
4745 | __table_args__ = ( |
|
4745 | __table_args__ = ( | |
4746 | base_table_args, |
|
4746 | base_table_args, | |
4747 | ) |
|
4747 | ) | |
4748 |
|
4748 | |||
4749 | pull_request_version_id = Column('pull_request_version_id', Integer(), nullable=False, primary_key=True) |
|
4749 | pull_request_version_id = Column('pull_request_version_id', Integer(), nullable=False, primary_key=True) | |
4750 | pull_request_id = Column('pull_request_id', Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=False) |
|
4750 | pull_request_id = Column('pull_request_id', Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=False) | |
4751 | pull_request = relationship('PullRequest', back_populates='versions') |
|
4751 | pull_request = relationship('PullRequest', back_populates='versions') | |
4752 |
|
4752 | |||
4753 | def __repr__(self): |
|
4753 | def __repr__(self): | |
4754 | if self.pull_request_version_id: |
|
4754 | if self.pull_request_version_id: | |
4755 | return f'<DB:PullRequestVersion #{self.pull_request_version_id}>' |
|
4755 | return f'<DB:PullRequestVersion #{self.pull_request_version_id}>' | |
4756 | else: |
|
4756 | else: | |
4757 | return f'<DB:PullRequestVersion at {id(self)!r}>' |
|
4757 | return f'<DB:PullRequestVersion at {id(self)!r}>' | |
4758 |
|
4758 | |||
4759 | @property |
|
4759 | @property | |
4760 | def reviewers(self): |
|
4760 | def reviewers(self): | |
4761 | return self.pull_request.reviewers |
|
4761 | return self.pull_request.reviewers | |
4762 |
|
4762 | |||
4763 | @property |
|
4763 | @property | |
4764 | def versions(self): |
|
4764 | def versions(self): | |
4765 | return self.pull_request.versions |
|
4765 | return self.pull_request.versions | |
4766 |
|
4766 | |||
4767 | def is_closed(self): |
|
4767 | def is_closed(self): | |
4768 | # calculate from original |
|
4768 | # calculate from original | |
4769 | return self.pull_request.status == self.STATUS_CLOSED |
|
4769 | return self.pull_request.status == self.STATUS_CLOSED | |
4770 |
|
4770 | |||
4771 | def is_state_changing(self): |
|
4771 | def is_state_changing(self): | |
4772 | return self.pull_request.pull_request_state != PullRequest.STATE_CREATED |
|
4772 | return self.pull_request.pull_request_state != PullRequest.STATE_CREATED | |
4773 |
|
4773 | |||
4774 | def calculated_review_status(self): |
|
4774 | def calculated_review_status(self): | |
4775 | return self.pull_request.calculated_review_status() |
|
4775 | return self.pull_request.calculated_review_status() | |
4776 |
|
4776 | |||
4777 | def reviewers_statuses(self): |
|
4777 | def reviewers_statuses(self): | |
4778 | return self.pull_request.reviewers_statuses() |
|
4778 | return self.pull_request.reviewers_statuses() | |
4779 |
|
4779 | |||
4780 | def observers(self): |
|
4780 | def observers(self): | |
4781 | return self.pull_request.observers() |
|
4781 | return self.pull_request.observers() | |
4782 |
|
4782 | |||
4783 |
|
4783 | |||
4784 | class PullRequestReviewers(Base, BaseModel): |
|
4784 | class PullRequestReviewers(Base, BaseModel): | |
4785 | __tablename__ = 'pull_request_reviewers' |
|
4785 | __tablename__ = 'pull_request_reviewers' | |
4786 | __table_args__ = ( |
|
4786 | __table_args__ = ( | |
4787 | base_table_args, |
|
4787 | base_table_args, | |
4788 | ) |
|
4788 | ) | |
4789 | ROLE_REVIEWER = 'reviewer' |
|
4789 | ROLE_REVIEWER = 'reviewer' | |
4790 | ROLE_OBSERVER = 'observer' |
|
4790 | ROLE_OBSERVER = 'observer' | |
4791 | ROLES = [ROLE_REVIEWER, ROLE_OBSERVER] |
|
4791 | ROLES = [ROLE_REVIEWER, ROLE_OBSERVER] | |
4792 |
|
4792 | |||
4793 | @hybrid_property |
|
4793 | @hybrid_property | |
4794 | def reasons(self): |
|
4794 | def reasons(self): | |
4795 | if not self._reasons: |
|
4795 | if not self._reasons: | |
4796 | return [] |
|
4796 | return [] | |
4797 | return self._reasons |
|
4797 | return self._reasons | |
4798 |
|
4798 | |||
4799 | @reasons.setter |
|
4799 | @reasons.setter | |
4800 | def reasons(self, val): |
|
4800 | def reasons(self, val): | |
4801 | val = val or [] |
|
4801 | val = val or [] | |
4802 | if any(not isinstance(x, str) for x in val): |
|
4802 | if any(not isinstance(x, str) for x in val): | |
4803 | raise Exception('invalid reasons type, must be list of strings') |
|
4803 | raise Exception('invalid reasons type, must be list of strings') | |
4804 | self._reasons = val |
|
4804 | self._reasons = val | |
4805 |
|
4805 | |||
4806 | pull_requests_reviewers_id = Column( |
|
4806 | pull_requests_reviewers_id = Column( | |
4807 | 'pull_requests_reviewers_id', Integer(), nullable=False, |
|
4807 | 'pull_requests_reviewers_id', Integer(), nullable=False, | |
4808 | primary_key=True) |
|
4808 | primary_key=True) | |
4809 | pull_request_id = Column( |
|
4809 | pull_request_id = Column( | |
4810 | "pull_request_id", Integer(), |
|
4810 | "pull_request_id", Integer(), | |
4811 | ForeignKey('pull_requests.pull_request_id'), nullable=False) |
|
4811 | ForeignKey('pull_requests.pull_request_id'), nullable=False) | |
4812 | user_id = Column( |
|
4812 | user_id = Column( | |
4813 | "user_id", Integer(), ForeignKey('users.user_id'), nullable=True) |
|
4813 | "user_id", Integer(), ForeignKey('users.user_id'), nullable=True) | |
4814 | _reasons = Column( |
|
4814 | _reasons = Column( | |
4815 | 'reason', MutationList.as_mutable( |
|
4815 | 'reason', MutationList.as_mutable( | |
4816 | JsonType('list', dialect_map=dict(mysql=UnicodeText(16384))))) |
|
4816 | JsonType('list', dialect_map=dict(mysql=UnicodeText(16384))))) | |
4817 |
|
4817 | |||
4818 | mandatory = Column("mandatory", Boolean(), nullable=False, default=False) |
|
4818 | mandatory = Column("mandatory", Boolean(), nullable=False, default=False) | |
4819 | role = Column('role', Unicode(255), nullable=True, default=ROLE_REVIEWER) |
|
4819 | role = Column('role', Unicode(255), nullable=True, default=ROLE_REVIEWER) | |
4820 |
|
4820 | |||
4821 | user = relationship('User') |
|
4821 | user = relationship('User') | |
4822 | pull_request = relationship('PullRequest', back_populates='reviewers') |
|
4822 | pull_request = relationship('PullRequest', back_populates='reviewers') | |
4823 |
|
4823 | |||
4824 | rule_data = Column( |
|
4824 | rule_data = Column( | |
4825 | 'rule_data_json', |
|
4825 | 'rule_data_json', | |
4826 | JsonType(dialect_map=dict(mysql=UnicodeText(16384)))) |
|
4826 | JsonType(dialect_map=dict(mysql=UnicodeText(16384)))) | |
4827 |
|
4827 | |||
4828 | def rule_user_group_data(self): |
|
4828 | def rule_user_group_data(self): | |
4829 | """ |
|
4829 | """ | |
4830 | Returns the voting user group rule data for this reviewer |
|
4830 | Returns the voting user group rule data for this reviewer | |
4831 | """ |
|
4831 | """ | |
4832 |
|
4832 | |||
4833 | if self.rule_data and 'vote_rule' in self.rule_data: |
|
4833 | if self.rule_data and 'vote_rule' in self.rule_data: | |
4834 | user_group_data = {} |
|
4834 | user_group_data = {} | |
4835 | if 'rule_user_group_entry_id' in self.rule_data: |
|
4835 | if 'rule_user_group_entry_id' in self.rule_data: | |
4836 | # means a group with voting rules ! |
|
4836 | # means a group with voting rules ! | |
4837 | user_group_data['id'] = self.rule_data['rule_user_group_entry_id'] |
|
4837 | user_group_data['id'] = self.rule_data['rule_user_group_entry_id'] | |
4838 | user_group_data['name'] = self.rule_data['rule_name'] |
|
4838 | user_group_data['name'] = self.rule_data['rule_name'] | |
4839 | user_group_data['vote_rule'] = self.rule_data['vote_rule'] |
|
4839 | user_group_data['vote_rule'] = self.rule_data['vote_rule'] | |
4840 |
|
4840 | |||
4841 | return user_group_data |
|
4841 | return user_group_data | |
4842 |
|
4842 | |||
4843 | @classmethod |
|
4843 | @classmethod | |
4844 | def get_pull_request_reviewers(cls, pull_request_id, role=None): |
|
4844 | def get_pull_request_reviewers(cls, pull_request_id, role=None): | |
4845 | qry = PullRequestReviewers.query()\ |
|
4845 | qry = PullRequestReviewers.query()\ | |
4846 | .filter(PullRequestReviewers.pull_request_id == pull_request_id) |
|
4846 | .filter(PullRequestReviewers.pull_request_id == pull_request_id) | |
4847 | if role: |
|
4847 | if role: | |
4848 | qry = qry.filter(PullRequestReviewers.role == role) |
|
4848 | qry = qry.filter(PullRequestReviewers.role == role) | |
4849 |
|
4849 | |||
4850 | return qry.all() |
|
4850 | return qry.all() | |
4851 |
|
4851 | |||
4852 | def __repr__(self): |
|
4852 | def __repr__(self): | |
4853 | return f"<{self.cls_name}('id:{self.pull_requests_reviewers_id}')>" |
|
4853 | return f"<{self.cls_name}('id:{self.pull_requests_reviewers_id}')>" | |
4854 |
|
4854 | |||
4855 |
|
4855 | |||
4856 | class Notification(Base, BaseModel): |
|
4856 | class Notification(Base, BaseModel): | |
4857 | __tablename__ = 'notifications' |
|
4857 | __tablename__ = 'notifications' | |
4858 | __table_args__ = ( |
|
4858 | __table_args__ = ( | |
4859 | Index('notification_type_idx', 'type'), |
|
4859 | Index('notification_type_idx', 'type'), | |
4860 | base_table_args, |
|
4860 | base_table_args, | |
4861 | ) |
|
4861 | ) | |
4862 |
|
4862 | |||
4863 | TYPE_CHANGESET_COMMENT = 'cs_comment' |
|
4863 | TYPE_CHANGESET_COMMENT = 'cs_comment' | |
4864 | TYPE_MESSAGE = 'message' |
|
4864 | TYPE_MESSAGE = 'message' | |
4865 | TYPE_MENTION = 'mention' |
|
4865 | TYPE_MENTION = 'mention' | |
4866 | TYPE_REGISTRATION = 'registration' |
|
4866 | TYPE_REGISTRATION = 'registration' | |
4867 | TYPE_PULL_REQUEST = 'pull_request' |
|
4867 | TYPE_PULL_REQUEST = 'pull_request' | |
4868 | TYPE_PULL_REQUEST_COMMENT = 'pull_request_comment' |
|
4868 | TYPE_PULL_REQUEST_COMMENT = 'pull_request_comment' | |
4869 | TYPE_PULL_REQUEST_UPDATE = 'pull_request_update' |
|
4869 | TYPE_PULL_REQUEST_UPDATE = 'pull_request_update' | |
4870 |
|
4870 | |||
4871 | notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True) |
|
4871 | notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True) | |
4872 | subject = Column('subject', Unicode(512), nullable=True) |
|
4872 | subject = Column('subject', Unicode(512), nullable=True) | |
4873 | body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True) |
|
4873 | body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True) | |
4874 | created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True) |
|
4874 | created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True) | |
4875 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
4875 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
4876 | type_ = Column('type', Unicode(255)) |
|
4876 | type_ = Column('type', Unicode(255)) | |
4877 |
|
4877 | |||
4878 | created_by_user = relationship('User', back_populates='user_created_notifications') |
|
4878 | created_by_user = relationship('User', back_populates='user_created_notifications') | |
4879 | notifications_to_users = relationship('UserNotification', lazy='joined', cascade="all, delete-orphan", back_populates='notification') |
|
4879 | notifications_to_users = relationship('UserNotification', lazy='joined', cascade="all, delete-orphan", back_populates='notification') | |
4880 |
|
4880 | |||
4881 | @property |
|
4881 | @property | |
4882 | def recipients(self): |
|
4882 | def recipients(self): | |
4883 | return [x.user for x in UserNotification.query()\ |
|
4883 | return [x.user for x in UserNotification.query()\ | |
4884 | .filter(UserNotification.notification == self)\ |
|
4884 | .filter(UserNotification.notification == self)\ | |
4885 | .order_by(UserNotification.user_id.asc()).all()] |
|
4885 | .order_by(UserNotification.user_id.asc()).all()] | |
4886 |
|
4886 | |||
4887 | @classmethod |
|
4887 | @classmethod | |
4888 | def create(cls, created_by, subject, body, recipients, type_=None): |
|
4888 | def create(cls, created_by, subject, body, recipients, type_=None): | |
4889 | if type_ is None: |
|
4889 | if type_ is None: | |
4890 | type_ = Notification.TYPE_MESSAGE |
|
4890 | type_ = Notification.TYPE_MESSAGE | |
4891 |
|
4891 | |||
4892 | notification = cls() |
|
4892 | notification = cls() | |
4893 | notification.created_by_user = created_by |
|
4893 | notification.created_by_user = created_by | |
4894 | notification.subject = subject |
|
4894 | notification.subject = subject | |
4895 | notification.body = body |
|
4895 | notification.body = body | |
4896 | notification.type_ = type_ |
|
4896 | notification.type_ = type_ | |
4897 | notification.created_on = datetime.datetime.now() |
|
4897 | notification.created_on = datetime.datetime.now() | |
4898 |
|
4898 | |||
4899 | # For each recipient link the created notification to his account |
|
4899 | # For each recipient link the created notification to his account | |
4900 | for u in recipients: |
|
4900 | for u in recipients: | |
4901 | assoc = UserNotification() |
|
4901 | assoc = UserNotification() | |
4902 | assoc.user_id = u.user_id |
|
4902 | assoc.user_id = u.user_id | |
4903 | assoc.notification = notification |
|
4903 | assoc.notification = notification | |
4904 |
|
4904 | |||
4905 | # if created_by is inside recipients mark his notification |
|
4905 | # if created_by is inside recipients mark his notification | |
4906 | # as read |
|
4906 | # as read | |
4907 | if u.user_id == created_by.user_id: |
|
4907 | if u.user_id == created_by.user_id: | |
4908 | assoc.read = True |
|
4908 | assoc.read = True | |
4909 | Session().add(assoc) |
|
4909 | Session().add(assoc) | |
4910 |
|
4910 | |||
4911 | Session().add(notification) |
|
4911 | Session().add(notification) | |
4912 |
|
4912 | |||
4913 | return notification |
|
4913 | return notification | |
4914 |
|
4914 | |||
4915 |
|
4915 | |||
4916 | class UserNotification(Base, BaseModel): |
|
4916 | class UserNotification(Base, BaseModel): | |
4917 | __tablename__ = 'user_to_notification' |
|
4917 | __tablename__ = 'user_to_notification' | |
4918 | __table_args__ = ( |
|
4918 | __table_args__ = ( | |
4919 | UniqueConstraint('user_id', 'notification_id'), |
|
4919 | UniqueConstraint('user_id', 'notification_id'), | |
4920 | base_table_args |
|
4920 | base_table_args | |
4921 | ) |
|
4921 | ) | |
4922 |
|
4922 | |||
4923 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True) |
|
4923 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True) | |
4924 | notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True) |
|
4924 | notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True) | |
4925 | read = Column('read', Boolean, default=False) |
|
4925 | read = Column('read', Boolean, default=False) | |
4926 | sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None) |
|
4926 | sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None) | |
4927 |
|
4927 | |||
4928 | user = relationship('User', lazy="joined", back_populates='notifications') |
|
4928 | user = relationship('User', lazy="joined", back_populates='notifications') | |
4929 | notification = relationship('Notification', lazy="joined", order_by=lambda: Notification.created_on.desc(), back_populates='notifications_to_users') |
|
4929 | notification = relationship('Notification', lazy="joined", order_by=lambda: Notification.created_on.desc(), back_populates='notifications_to_users') | |
4930 |
|
4930 | |||
4931 | def mark_as_read(self): |
|
4931 | def mark_as_read(self): | |
4932 | self.read = True |
|
4932 | self.read = True | |
4933 | Session().add(self) |
|
4933 | Session().add(self) | |
4934 |
|
4934 | |||
4935 |
|
4935 | |||
4936 | class UserNotice(Base, BaseModel): |
|
4936 | class UserNotice(Base, BaseModel): | |
4937 | __tablename__ = 'user_notices' |
|
4937 | __tablename__ = 'user_notices' | |
4938 | __table_args__ = ( |
|
4938 | __table_args__ = ( | |
4939 | base_table_args |
|
4939 | base_table_args | |
4940 | ) |
|
4940 | ) | |
4941 |
|
4941 | |||
4942 | NOTIFICATION_TYPE_MESSAGE = 'message' |
|
4942 | NOTIFICATION_TYPE_MESSAGE = 'message' | |
4943 | NOTIFICATION_TYPE_NOTICE = 'notice' |
|
4943 | NOTIFICATION_TYPE_NOTICE = 'notice' | |
4944 |
|
4944 | |||
4945 | NOTIFICATION_LEVEL_INFO = 'info' |
|
4945 | NOTIFICATION_LEVEL_INFO = 'info' | |
4946 | NOTIFICATION_LEVEL_WARNING = 'warning' |
|
4946 | NOTIFICATION_LEVEL_WARNING = 'warning' | |
4947 | NOTIFICATION_LEVEL_ERROR = 'error' |
|
4947 | NOTIFICATION_LEVEL_ERROR = 'error' | |
4948 |
|
4948 | |||
4949 | user_notice_id = Column('gist_id', Integer(), primary_key=True) |
|
4949 | user_notice_id = Column('gist_id', Integer(), primary_key=True) | |
4950 |
|
4950 | |||
4951 | notice_subject = Column('notice_subject', Unicode(512), nullable=True) |
|
4951 | notice_subject = Column('notice_subject', Unicode(512), nullable=True) | |
4952 | notice_body = Column('notice_body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True) |
|
4952 | notice_body = Column('notice_body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True) | |
4953 |
|
4953 | |||
4954 | notice_read = Column('notice_read', Boolean, default=False) |
|
4954 | notice_read = Column('notice_read', Boolean, default=False) | |
4955 |
|
4955 | |||
4956 | notification_level = Column('notification_level', String(1024), default=NOTIFICATION_LEVEL_INFO) |
|
4956 | notification_level = Column('notification_level', String(1024), default=NOTIFICATION_LEVEL_INFO) | |
4957 | notification_type = Column('notification_type', String(1024), default=NOTIFICATION_TYPE_NOTICE) |
|
4957 | notification_type = Column('notification_type', String(1024), default=NOTIFICATION_TYPE_NOTICE) | |
4958 |
|
4958 | |||
4959 | notice_created_by = Column('notice_created_by', Integer(), ForeignKey('users.user_id'), nullable=True) |
|
4959 | notice_created_by = Column('notice_created_by', Integer(), ForeignKey('users.user_id'), nullable=True) | |
4960 | notice_created_on = Column('notice_created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
4960 | notice_created_on = Column('notice_created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
4961 |
|
4961 | |||
4962 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id')) |
|
4962 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id')) | |
4963 | user = relationship('User', lazy="joined", primaryjoin='User.user_id==UserNotice.user_id') |
|
4963 | user = relationship('User', lazy="joined", primaryjoin='User.user_id==UserNotice.user_id') | |
4964 |
|
4964 | |||
4965 | @classmethod |
|
4965 | @classmethod | |
4966 | def create_for_user(cls, user, subject, body, notice_level=NOTIFICATION_LEVEL_INFO, allow_duplicate=False): |
|
4966 | def create_for_user(cls, user, subject, body, notice_level=NOTIFICATION_LEVEL_INFO, allow_duplicate=False): | |
4967 |
|
4967 | |||
4968 | if notice_level not in [cls.NOTIFICATION_LEVEL_ERROR, |
|
4968 | if notice_level not in [cls.NOTIFICATION_LEVEL_ERROR, | |
4969 | cls.NOTIFICATION_LEVEL_WARNING, |
|
4969 | cls.NOTIFICATION_LEVEL_WARNING, | |
4970 | cls.NOTIFICATION_LEVEL_INFO]: |
|
4970 | cls.NOTIFICATION_LEVEL_INFO]: | |
4971 | return |
|
4971 | return | |
4972 |
|
4972 | |||
4973 | from rhodecode.model.user import UserModel |
|
4973 | from rhodecode.model.user import UserModel | |
4974 | user = UserModel().get_user(user) |
|
4974 | user = UserModel().get_user(user) | |
4975 |
|
4975 | |||
4976 | new_notice = UserNotice() |
|
4976 | new_notice = UserNotice() | |
4977 | if not allow_duplicate: |
|
4977 | if not allow_duplicate: | |
4978 | existing_msg = UserNotice().query() \ |
|
4978 | existing_msg = UserNotice().query() \ | |
4979 | .filter(UserNotice.user == user) \ |
|
4979 | .filter(UserNotice.user == user) \ | |
4980 | .filter(UserNotice.notice_body == body) \ |
|
4980 | .filter(UserNotice.notice_body == body) \ | |
4981 | .filter(UserNotice.notice_read == false()) \ |
|
4981 | .filter(UserNotice.notice_read == false()) \ | |
4982 | .scalar() |
|
4982 | .scalar() | |
4983 | if existing_msg: |
|
4983 | if existing_msg: | |
4984 | log.warning('Ignoring duplicate notice for user %s', user) |
|
4984 | log.warning('Ignoring duplicate notice for user %s', user) | |
4985 | return |
|
4985 | return | |
4986 |
|
4986 | |||
4987 | new_notice.user = user |
|
4987 | new_notice.user = user | |
4988 | new_notice.notice_subject = subject |
|
4988 | new_notice.notice_subject = subject | |
4989 | new_notice.notice_body = body |
|
4989 | new_notice.notice_body = body | |
4990 | new_notice.notification_level = notice_level |
|
4990 | new_notice.notification_level = notice_level | |
4991 | Session().add(new_notice) |
|
4991 | Session().add(new_notice) | |
4992 | Session().commit() |
|
4992 | Session().commit() | |
4993 |
|
4993 | |||
4994 |
|
4994 | |||
4995 | class Gist(Base, BaseModel): |
|
4995 | class Gist(Base, BaseModel): | |
4996 | __tablename__ = 'gists' |
|
4996 | __tablename__ = 'gists' | |
4997 | __table_args__ = ( |
|
4997 | __table_args__ = ( | |
4998 | Index('g_gist_access_id_idx', 'gist_access_id'), |
|
4998 | Index('g_gist_access_id_idx', 'gist_access_id'), | |
4999 | Index('g_created_on_idx', 'created_on'), |
|
4999 | Index('g_created_on_idx', 'created_on'), | |
5000 | base_table_args |
|
5000 | base_table_args | |
5001 | ) |
|
5001 | ) | |
5002 |
|
5002 | |||
5003 | GIST_PUBLIC = 'public' |
|
5003 | GIST_PUBLIC = 'public' | |
5004 | GIST_PRIVATE = 'private' |
|
5004 | GIST_PRIVATE = 'private' | |
5005 | DEFAULT_FILENAME = 'gistfile1.txt' |
|
5005 | DEFAULT_FILENAME = 'gistfile1.txt' | |
5006 |
|
5006 | |||
5007 | ACL_LEVEL_PUBLIC = 'acl_public' |
|
5007 | ACL_LEVEL_PUBLIC = 'acl_public' | |
5008 | ACL_LEVEL_PRIVATE = 'acl_private' |
|
5008 | ACL_LEVEL_PRIVATE = 'acl_private' | |
5009 |
|
5009 | |||
5010 | gist_id = Column('gist_id', Integer(), primary_key=True) |
|
5010 | gist_id = Column('gist_id', Integer(), primary_key=True) | |
5011 | gist_access_id = Column('gist_access_id', Unicode(250)) |
|
5011 | gist_access_id = Column('gist_access_id', Unicode(250)) | |
5012 | gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql')) |
|
5012 | gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql')) | |
5013 | gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True) |
|
5013 | gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True) | |
5014 | gist_expires = Column('gist_expires', Float(53), nullable=False) |
|
5014 | gist_expires = Column('gist_expires', Float(53), nullable=False) | |
5015 | gist_type = Column('gist_type', Unicode(128), nullable=False) |
|
5015 | gist_type = Column('gist_type', Unicode(128), nullable=False) | |
5016 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
5016 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
5017 | modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
5017 | modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
5018 | acl_level = Column('acl_level', Unicode(128), nullable=True) |
|
5018 | acl_level = Column('acl_level', Unicode(128), nullable=True) | |
5019 |
|
5019 | |||
5020 | owner = relationship('User', back_populates='user_gists') |
|
5020 | owner = relationship('User', back_populates='user_gists') | |
5021 |
|
5021 | |||
5022 | def __repr__(self): |
|
5022 | def __repr__(self): | |
5023 | return f'<Gist:[{self.gist_type}]{self.gist_access_id}>' |
|
5023 | return f'<Gist:[{self.gist_type}]{self.gist_access_id}>' | |
5024 |
|
5024 | |||
5025 | @hybrid_property |
|
5025 | @hybrid_property | |
5026 | def description_safe(self): |
|
5026 | def description_safe(self): | |
5027 | return description_escaper(self.gist_description) |
|
5027 | return description_escaper(self.gist_description) | |
5028 |
|
5028 | |||
5029 | @classmethod |
|
5029 | @classmethod | |
5030 | def get_or_404(cls, id_): |
|
5030 | def get_or_404(cls, id_): | |
5031 | from pyramid.httpexceptions import HTTPNotFound |
|
5031 | from pyramid.httpexceptions import HTTPNotFound | |
5032 |
|
5032 | |||
5033 | res = cls.query().filter(cls.gist_access_id == id_).scalar() |
|
5033 | res = cls.query().filter(cls.gist_access_id == id_).scalar() | |
5034 | if not res: |
|
5034 | if not res: | |
5035 | log.debug('WARN: No DB entry with id %s', id_) |
|
5035 | log.debug('WARN: No DB entry with id %s', id_) | |
5036 | raise HTTPNotFound() |
|
5036 | raise HTTPNotFound() | |
5037 | return res |
|
5037 | return res | |
5038 |
|
5038 | |||
5039 | @classmethod |
|
5039 | @classmethod | |
5040 | def get_by_access_id(cls, gist_access_id): |
|
5040 | def get_by_access_id(cls, gist_access_id): | |
5041 | return cls.query().filter(cls.gist_access_id == gist_access_id).scalar() |
|
5041 | return cls.query().filter(cls.gist_access_id == gist_access_id).scalar() | |
5042 |
|
5042 | |||
5043 | def gist_url(self): |
|
5043 | def gist_url(self): | |
5044 | from rhodecode.model.gist import GistModel |
|
5044 | from rhodecode.model.gist import GistModel | |
5045 | return GistModel().get_url(self) |
|
5045 | return GistModel().get_url(self) | |
5046 |
|
5046 | |||
5047 | @classmethod |
|
5047 | @classmethod | |
5048 | def base_path(cls): |
|
5048 | def base_path(cls): | |
5049 | """ |
|
5049 | """ | |
5050 | Returns base path when all gists are stored |
|
5050 | Returns base path when all gists are stored | |
5051 |
|
5051 | |||
5052 | :param cls: |
|
5052 | :param cls: | |
5053 | """ |
|
5053 | """ | |
5054 | from rhodecode.model.gist import GIST_STORE_LOC |
|
5054 | from rhodecode.model.gist import GIST_STORE_LOC | |
5055 | from rhodecode.lib.utils import get_rhodecode_repo_store_path |
|
5055 | from rhodecode.lib.utils import get_rhodecode_repo_store_path | |
5056 | repo_store_path = get_rhodecode_repo_store_path() |
|
5056 | repo_store_path = get_rhodecode_repo_store_path() | |
5057 | return os.path.join(repo_store_path, GIST_STORE_LOC) |
|
5057 | return os.path.join(repo_store_path, GIST_STORE_LOC) | |
5058 |
|
5058 | |||
5059 | def get_api_data(self): |
|
5059 | def get_api_data(self): | |
5060 | """ |
|
5060 | """ | |
5061 | Common function for generating gist related data for API |
|
5061 | Common function for generating gist related data for API | |
5062 | """ |
|
5062 | """ | |
5063 | gist = self |
|
5063 | gist = self | |
5064 | data = { |
|
5064 | data = { | |
5065 | 'gist_id': gist.gist_id, |
|
5065 | 'gist_id': gist.gist_id, | |
5066 | 'type': gist.gist_type, |
|
5066 | 'type': gist.gist_type, | |
5067 | 'access_id': gist.gist_access_id, |
|
5067 | 'access_id': gist.gist_access_id, | |
5068 | 'description': gist.gist_description, |
|
5068 | 'description': gist.gist_description, | |
5069 | 'url': gist.gist_url(), |
|
5069 | 'url': gist.gist_url(), | |
5070 | 'expires': gist.gist_expires, |
|
5070 | 'expires': gist.gist_expires, | |
5071 | 'created_on': gist.created_on, |
|
5071 | 'created_on': gist.created_on, | |
5072 | 'modified_at': gist.modified_at, |
|
5072 | 'modified_at': gist.modified_at, | |
5073 | 'content': None, |
|
5073 | 'content': None, | |
5074 | 'acl_level': gist.acl_level, |
|
5074 | 'acl_level': gist.acl_level, | |
5075 | } |
|
5075 | } | |
5076 | return data |
|
5076 | return data | |
5077 |
|
5077 | |||
5078 | def __json__(self): |
|
5078 | def __json__(self): | |
5079 | data = dict() |
|
5079 | data = dict() | |
5080 | data.update(self.get_api_data()) |
|
5080 | data.update(self.get_api_data()) | |
5081 | return data |
|
5081 | return data | |
5082 | # SCM functions |
|
5082 | # SCM functions | |
5083 |
|
5083 | |||
5084 | def scm_instance(self, **kwargs): |
|
5084 | def scm_instance(self, **kwargs): | |
5085 | """ |
|
5085 | """ | |
5086 | Get an instance of VCS Repository |
|
5086 | Get an instance of VCS Repository | |
5087 |
|
5087 | |||
5088 | :param kwargs: |
|
5088 | :param kwargs: | |
5089 | """ |
|
5089 | """ | |
5090 | from rhodecode.model.gist import GistModel |
|
5090 | from rhodecode.model.gist import GistModel | |
5091 | full_repo_path = os.path.join(self.base_path(), self.gist_access_id) |
|
5091 | full_repo_path = os.path.join(self.base_path(), self.gist_access_id) | |
5092 | return get_vcs_instance( |
|
5092 | return get_vcs_instance( | |
5093 | repo_path=safe_str(full_repo_path), create=False, |
|
5093 | repo_path=safe_str(full_repo_path), create=False, | |
5094 | _vcs_alias=GistModel.vcs_backend) |
|
5094 | _vcs_alias=GistModel.vcs_backend) | |
5095 |
|
5095 | |||
5096 |
|
5096 | |||
5097 | class ExternalIdentity(Base, BaseModel): |
|
5097 | class ExternalIdentity(Base, BaseModel): | |
5098 | __tablename__ = 'external_identities' |
|
5098 | __tablename__ = 'external_identities' | |
5099 | __table_args__ = ( |
|
5099 | __table_args__ = ( | |
5100 | Index('local_user_id_idx', 'local_user_id'), |
|
5100 | Index('local_user_id_idx', 'local_user_id'), | |
5101 | Index('external_id_idx', 'external_id'), |
|
5101 | Index('external_id_idx', 'external_id'), | |
5102 | base_table_args |
|
5102 | base_table_args | |
5103 | ) |
|
5103 | ) | |
5104 |
|
5104 | |||
5105 | external_id = Column('external_id', Unicode(255), default='', primary_key=True) |
|
5105 | external_id = Column('external_id', Unicode(255), default='', primary_key=True) | |
5106 | external_username = Column('external_username', Unicode(1024), default='') |
|
5106 | external_username = Column('external_username', Unicode(1024), default='') | |
5107 | local_user_id = Column('local_user_id', Integer(), ForeignKey('users.user_id'), primary_key=True) |
|
5107 | local_user_id = Column('local_user_id', Integer(), ForeignKey('users.user_id'), primary_key=True) | |
5108 | provider_name = Column('provider_name', Unicode(255), default='', primary_key=True) |
|
5108 | provider_name = Column('provider_name', Unicode(255), default='', primary_key=True) | |
5109 | access_token = Column('access_token', String(1024), default='') |
|
5109 | access_token = Column('access_token', String(1024), default='') | |
5110 | alt_token = Column('alt_token', String(1024), default='') |
|
5110 | alt_token = Column('alt_token', String(1024), default='') | |
5111 | token_secret = Column('token_secret', String(1024), default='') |
|
5111 | token_secret = Column('token_secret', String(1024), default='') | |
5112 |
|
5112 | |||
5113 | @classmethod |
|
5113 | @classmethod | |
5114 | def by_external_id_and_provider(cls, external_id, provider_name, local_user_id=None): |
|
5114 | def by_external_id_and_provider(cls, external_id, provider_name, local_user_id=None): | |
5115 | """ |
|
5115 | """ | |
5116 | Returns ExternalIdentity instance based on search params |
|
5116 | Returns ExternalIdentity instance based on search params | |
5117 |
|
5117 | |||
5118 | :param external_id: |
|
5118 | :param external_id: | |
5119 | :param provider_name: |
|
5119 | :param provider_name: | |
5120 | :return: ExternalIdentity |
|
5120 | :return: ExternalIdentity | |
5121 | """ |
|
5121 | """ | |
5122 | query = cls.query() |
|
5122 | query = cls.query() | |
5123 | query = query.filter(cls.external_id == external_id) |
|
5123 | query = query.filter(cls.external_id == external_id) | |
5124 | query = query.filter(cls.provider_name == provider_name) |
|
5124 | query = query.filter(cls.provider_name == provider_name) | |
5125 | if local_user_id: |
|
5125 | if local_user_id: | |
5126 | query = query.filter(cls.local_user_id == local_user_id) |
|
5126 | query = query.filter(cls.local_user_id == local_user_id) | |
5127 | return query.first() |
|
5127 | return query.first() | |
5128 |
|
5128 | |||
5129 | @classmethod |
|
5129 | @classmethod | |
5130 | def user_by_external_id_and_provider(cls, external_id, provider_name): |
|
5130 | def user_by_external_id_and_provider(cls, external_id, provider_name): | |
5131 | """ |
|
5131 | """ | |
5132 | Returns User instance based on search params |
|
5132 | Returns User instance based on search params | |
5133 |
|
5133 | |||
5134 | :param external_id: |
|
5134 | :param external_id: | |
5135 | :param provider_name: |
|
5135 | :param provider_name: | |
5136 | :return: User |
|
5136 | :return: User | |
5137 | """ |
|
5137 | """ | |
5138 | query = User.query() |
|
5138 | query = User.query() | |
5139 | query = query.filter(cls.external_id == external_id) |
|
5139 | query = query.filter(cls.external_id == external_id) | |
5140 | query = query.filter(cls.provider_name == provider_name) |
|
5140 | query = query.filter(cls.provider_name == provider_name) | |
5141 | query = query.filter(User.user_id == cls.local_user_id) |
|
5141 | query = query.filter(User.user_id == cls.local_user_id) | |
5142 | return query.first() |
|
5142 | return query.first() | |
5143 |
|
5143 | |||
5144 | @classmethod |
|
5144 | @classmethod | |
5145 | def by_local_user_id(cls, local_user_id): |
|
5145 | def by_local_user_id(cls, local_user_id): | |
5146 | """ |
|
5146 | """ | |
5147 | Returns all tokens for user |
|
5147 | Returns all tokens for user | |
5148 |
|
5148 | |||
5149 | :param local_user_id: |
|
5149 | :param local_user_id: | |
5150 | :return: ExternalIdentity |
|
5150 | :return: ExternalIdentity | |
5151 | """ |
|
5151 | """ | |
5152 | query = cls.query() |
|
5152 | query = cls.query() | |
5153 | query = query.filter(cls.local_user_id == local_user_id) |
|
5153 | query = query.filter(cls.local_user_id == local_user_id) | |
5154 | return query |
|
5154 | return query | |
5155 |
|
5155 | |||
5156 | @classmethod |
|
5156 | @classmethod | |
5157 | def load_provider_plugin(cls, plugin_id): |
|
5157 | def load_provider_plugin(cls, plugin_id): | |
5158 | from rhodecode.authentication.base import loadplugin |
|
5158 | from rhodecode.authentication.base import loadplugin | |
5159 | _plugin_id = 'egg:rhodecode-enterprise-ee#{}'.format(plugin_id) |
|
5159 | _plugin_id = 'egg:rhodecode-enterprise-ee#{}'.format(plugin_id) | |
5160 | auth_plugin = loadplugin(_plugin_id) |
|
5160 | auth_plugin = loadplugin(_plugin_id) | |
5161 | return auth_plugin |
|
5161 | return auth_plugin | |
5162 |
|
5162 | |||
5163 |
|
5163 | |||
5164 | class Integration(Base, BaseModel): |
|
5164 | class Integration(Base, BaseModel): | |
5165 | __tablename__ = 'integrations' |
|
5165 | __tablename__ = 'integrations' | |
5166 | __table_args__ = ( |
|
5166 | __table_args__ = ( | |
5167 | base_table_args |
|
5167 | base_table_args | |
5168 | ) |
|
5168 | ) | |
5169 |
|
5169 | |||
5170 | integration_id = Column('integration_id', Integer(), primary_key=True) |
|
5170 | integration_id = Column('integration_id', Integer(), primary_key=True) | |
5171 | integration_type = Column('integration_type', String(255)) |
|
5171 | integration_type = Column('integration_type', String(255)) | |
5172 | enabled = Column('enabled', Boolean(), nullable=False) |
|
5172 | enabled = Column('enabled', Boolean(), nullable=False) | |
5173 | name = Column('name', String(255), nullable=False) |
|
5173 | name = Column('name', String(255), nullable=False) | |
5174 | child_repos_only = Column('child_repos_only', Boolean(), nullable=False, default=False) |
|
5174 | child_repos_only = Column('child_repos_only', Boolean(), nullable=False, default=False) | |
5175 |
|
5175 | |||
5176 | settings = Column( |
|
5176 | settings = Column( | |
5177 | 'settings_json', MutationObj.as_mutable( |
|
5177 | 'settings_json', MutationObj.as_mutable( | |
5178 | JsonType(dialect_map=dict(mysql=UnicodeText(16384))))) |
|
5178 | JsonType(dialect_map=dict(mysql=UnicodeText(16384))))) | |
5179 | repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None) |
|
5179 | repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None) | |
5180 | repo = relationship('Repository', lazy='joined', back_populates='integrations') |
|
5180 | repo = relationship('Repository', lazy='joined', back_populates='integrations') | |
5181 |
|
5181 | |||
5182 | repo_group_id = Column('repo_group_id', Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None) |
|
5182 | repo_group_id = Column('repo_group_id', Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None) | |
5183 | repo_group = relationship('RepoGroup', lazy='joined', back_populates='integrations') |
|
5183 | repo_group = relationship('RepoGroup', lazy='joined', back_populates='integrations') | |
5184 |
|
5184 | |||
5185 | @property |
|
5185 | @property | |
5186 | def scope(self): |
|
5186 | def scope(self): | |
5187 | if self.repo: |
|
5187 | if self.repo: | |
5188 | return repr(self.repo) |
|
5188 | return repr(self.repo) | |
5189 | if self.repo_group: |
|
5189 | if self.repo_group: | |
5190 | if self.child_repos_only: |
|
5190 | if self.child_repos_only: | |
5191 | return repr(self.repo_group) + ' (child repos only)' |
|
5191 | return repr(self.repo_group) + ' (child repos only)' | |
5192 | else: |
|
5192 | else: | |
5193 | return repr(self.repo_group) + ' (recursive)' |
|
5193 | return repr(self.repo_group) + ' (recursive)' | |
5194 | if self.child_repos_only: |
|
5194 | if self.child_repos_only: | |
5195 | return 'root_repos' |
|
5195 | return 'root_repos' | |
5196 | return 'global' |
|
5196 | return 'global' | |
5197 |
|
5197 | |||
5198 | def __repr__(self): |
|
5198 | def __repr__(self): | |
5199 | return '<Integration(%r, %r)>' % (self.integration_type, self.scope) |
|
5199 | return '<Integration(%r, %r)>' % (self.integration_type, self.scope) | |
5200 |
|
5200 | |||
5201 |
|
5201 | |||
5202 | class RepoReviewRuleUser(Base, BaseModel): |
|
5202 | class RepoReviewRuleUser(Base, BaseModel): | |
5203 | __tablename__ = 'repo_review_rules_users' |
|
5203 | __tablename__ = 'repo_review_rules_users' | |
5204 | __table_args__ = ( |
|
5204 | __table_args__ = ( | |
5205 | base_table_args |
|
5205 | base_table_args | |
5206 | ) |
|
5206 | ) | |
5207 | ROLE_REVIEWER = 'reviewer' |
|
5207 | ROLE_REVIEWER = 'reviewer' | |
5208 | ROLE_OBSERVER = 'observer' |
|
5208 | ROLE_OBSERVER = 'observer' | |
5209 | ROLES = [ROLE_REVIEWER, ROLE_OBSERVER] |
|
5209 | ROLES = [ROLE_REVIEWER, ROLE_OBSERVER] | |
5210 |
|
5210 | |||
5211 | repo_review_rule_user_id = Column('repo_review_rule_user_id', Integer(), primary_key=True) |
|
5211 | repo_review_rule_user_id = Column('repo_review_rule_user_id', Integer(), primary_key=True) | |
5212 | repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id')) |
|
5212 | repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id')) | |
5213 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False) |
|
5213 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False) | |
5214 | mandatory = Column("mandatory", Boolean(), nullable=False, default=False) |
|
5214 | mandatory = Column("mandatory", Boolean(), nullable=False, default=False) | |
5215 | role = Column('role', Unicode(255), nullable=True, default=ROLE_REVIEWER) |
|
5215 | role = Column('role', Unicode(255), nullable=True, default=ROLE_REVIEWER) | |
5216 | user = relationship('User', back_populates='user_review_rules') |
|
5216 | user = relationship('User', back_populates='user_review_rules') | |
5217 |
|
5217 | |||
5218 | def rule_data(self): |
|
5218 | def rule_data(self): | |
5219 | return { |
|
5219 | return { | |
5220 | 'mandatory': self.mandatory, |
|
5220 | 'mandatory': self.mandatory, | |
5221 | 'role': self.role, |
|
5221 | 'role': self.role, | |
5222 | } |
|
5222 | } | |
5223 |
|
5223 | |||
5224 |
|
5224 | |||
5225 | class RepoReviewRuleUserGroup(Base, BaseModel): |
|
5225 | class RepoReviewRuleUserGroup(Base, BaseModel): | |
5226 | __tablename__ = 'repo_review_rules_users_groups' |
|
5226 | __tablename__ = 'repo_review_rules_users_groups' | |
5227 | __table_args__ = ( |
|
5227 | __table_args__ = ( | |
5228 | base_table_args |
|
5228 | base_table_args | |
5229 | ) |
|
5229 | ) | |
5230 |
|
5230 | |||
5231 | VOTE_RULE_ALL = -1 |
|
5231 | VOTE_RULE_ALL = -1 | |
5232 | ROLE_REVIEWER = 'reviewer' |
|
5232 | ROLE_REVIEWER = 'reviewer' | |
5233 | ROLE_OBSERVER = 'observer' |
|
5233 | ROLE_OBSERVER = 'observer' | |
5234 | ROLES = [ROLE_REVIEWER, ROLE_OBSERVER] |
|
5234 | ROLES = [ROLE_REVIEWER, ROLE_OBSERVER] | |
5235 |
|
5235 | |||
5236 | repo_review_rule_users_group_id = Column('repo_review_rule_users_group_id', Integer(), primary_key=True) |
|
5236 | repo_review_rule_users_group_id = Column('repo_review_rule_users_group_id', Integer(), primary_key=True) | |
5237 | repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id')) |
|
5237 | repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id')) | |
5238 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False) |
|
5238 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False) | |
5239 | mandatory = Column("mandatory", Boolean(), nullable=False, default=False) |
|
5239 | mandatory = Column("mandatory", Boolean(), nullable=False, default=False) | |
5240 | role = Column('role', Unicode(255), nullable=True, default=ROLE_REVIEWER) |
|
5240 | role = Column('role', Unicode(255), nullable=True, default=ROLE_REVIEWER) | |
5241 | vote_rule = Column("vote_rule", Integer(), nullable=True, default=VOTE_RULE_ALL) |
|
5241 | vote_rule = Column("vote_rule", Integer(), nullable=True, default=VOTE_RULE_ALL) | |
5242 | users_group = relationship('UserGroup') |
|
5242 | users_group = relationship('UserGroup') | |
5243 |
|
5243 | |||
5244 | def rule_data(self): |
|
5244 | def rule_data(self): | |
5245 | return { |
|
5245 | return { | |
5246 | 'mandatory': self.mandatory, |
|
5246 | 'mandatory': self.mandatory, | |
5247 | 'role': self.role, |
|
5247 | 'role': self.role, | |
5248 | 'vote_rule': self.vote_rule |
|
5248 | 'vote_rule': self.vote_rule | |
5249 | } |
|
5249 | } | |
5250 |
|
5250 | |||
5251 | @property |
|
5251 | @property | |
5252 | def vote_rule_label(self): |
|
5252 | def vote_rule_label(self): | |
5253 | if not self.vote_rule or self.vote_rule == self.VOTE_RULE_ALL: |
|
5253 | if not self.vote_rule or self.vote_rule == self.VOTE_RULE_ALL: | |
5254 | return 'all must vote' |
|
5254 | return 'all must vote' | |
5255 | else: |
|
5255 | else: | |
5256 | return 'min. vote {}'.format(self.vote_rule) |
|
5256 | return 'min. vote {}'.format(self.vote_rule) | |
5257 |
|
5257 | |||
5258 |
|
5258 | |||
5259 | class RepoReviewRule(Base, BaseModel): |
|
5259 | class RepoReviewRule(Base, BaseModel): | |
5260 | __tablename__ = 'repo_review_rules' |
|
5260 | __tablename__ = 'repo_review_rules' | |
5261 | __table_args__ = ( |
|
5261 | __table_args__ = ( | |
5262 | base_table_args |
|
5262 | base_table_args | |
5263 | ) |
|
5263 | ) | |
5264 |
|
5264 | |||
5265 | repo_review_rule_id = Column( |
|
5265 | repo_review_rule_id = Column( | |
5266 | 'repo_review_rule_id', Integer(), primary_key=True) |
|
5266 | 'repo_review_rule_id', Integer(), primary_key=True) | |
5267 | repo_id = Column( |
|
5267 | repo_id = Column( | |
5268 | "repo_id", Integer(), ForeignKey('repositories.repo_id')) |
|
5268 | "repo_id", Integer(), ForeignKey('repositories.repo_id')) | |
5269 | repo = relationship('Repository', back_populates='review_rules') |
|
5269 | repo = relationship('Repository', back_populates='review_rules') | |
5270 |
|
5270 | |||
5271 | review_rule_name = Column('review_rule_name', String(255)) |
|
5271 | review_rule_name = Column('review_rule_name', String(255)) | |
5272 | _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default='*') # glob |
|
5272 | _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default='*') # glob | |
5273 | _target_branch_pattern = Column("target_branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default='*') # glob |
|
5273 | _target_branch_pattern = Column("target_branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default='*') # glob | |
5274 | _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default='*') # glob |
|
5274 | _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default='*') # glob | |
5275 |
|
5275 | |||
5276 | use_authors_for_review = Column("use_authors_for_review", Boolean(), nullable=False, default=False) |
|
5276 | use_authors_for_review = Column("use_authors_for_review", Boolean(), nullable=False, default=False) | |
5277 |
|
5277 | |||
5278 | # Legacy fields, just for backward compat |
|
5278 | # Legacy fields, just for backward compat | |
5279 | _forbid_author_to_review = Column("forbid_author_to_review", Boolean(), nullable=False, default=False) |
|
5279 | _forbid_author_to_review = Column("forbid_author_to_review", Boolean(), nullable=False, default=False) | |
5280 | _forbid_commit_author_to_review = Column("forbid_commit_author_to_review", Boolean(), nullable=False, default=False) |
|
5280 | _forbid_commit_author_to_review = Column("forbid_commit_author_to_review", Boolean(), nullable=False, default=False) | |
5281 |
|
5281 | |||
5282 | pr_author = Column("pr_author", UnicodeText().with_variant(UnicodeText(255), 'mysql'), nullable=True) |
|
5282 | pr_author = Column("pr_author", UnicodeText().with_variant(UnicodeText(255), 'mysql'), nullable=True) | |
5283 | commit_author = Column("commit_author", UnicodeText().with_variant(UnicodeText(255), 'mysql'), nullable=True) |
|
5283 | commit_author = Column("commit_author", UnicodeText().with_variant(UnicodeText(255), 'mysql'), nullable=True) | |
5284 |
|
5284 | |||
5285 | forbid_adding_reviewers = Column("forbid_adding_reviewers", Boolean(), nullable=False, default=False) |
|
5285 | forbid_adding_reviewers = Column("forbid_adding_reviewers", Boolean(), nullable=False, default=False) | |
5286 |
|
5286 | |||
5287 | rule_users = relationship('RepoReviewRuleUser') |
|
5287 | rule_users = relationship('RepoReviewRuleUser') | |
5288 | rule_user_groups = relationship('RepoReviewRuleUserGroup') |
|
5288 | rule_user_groups = relationship('RepoReviewRuleUserGroup') | |
5289 |
|
5289 | |||
5290 | def _validate_pattern(self, value): |
|
5290 | def _validate_pattern(self, value): | |
5291 | re.compile('^' + glob2re(value) + '$') |
|
5291 | re.compile('^' + glob2re(value) + '$') | |
5292 |
|
5292 | |||
5293 | @hybrid_property |
|
5293 | @hybrid_property | |
5294 | def source_branch_pattern(self): |
|
5294 | def source_branch_pattern(self): | |
5295 | return self._branch_pattern or '*' |
|
5295 | return self._branch_pattern or '*' | |
5296 |
|
5296 | |||
5297 | @source_branch_pattern.setter |
|
5297 | @source_branch_pattern.setter | |
5298 | def source_branch_pattern(self, value): |
|
5298 | def source_branch_pattern(self, value): | |
5299 | self._validate_pattern(value) |
|
5299 | self._validate_pattern(value) | |
5300 | self._branch_pattern = value or '*' |
|
5300 | self._branch_pattern = value or '*' | |
5301 |
|
5301 | |||
5302 | @hybrid_property |
|
5302 | @hybrid_property | |
5303 | def target_branch_pattern(self): |
|
5303 | def target_branch_pattern(self): | |
5304 | return self._target_branch_pattern or '*' |
|
5304 | return self._target_branch_pattern or '*' | |
5305 |
|
5305 | |||
5306 | @target_branch_pattern.setter |
|
5306 | @target_branch_pattern.setter | |
5307 | def target_branch_pattern(self, value): |
|
5307 | def target_branch_pattern(self, value): | |
5308 | self._validate_pattern(value) |
|
5308 | self._validate_pattern(value) | |
5309 | self._target_branch_pattern = value or '*' |
|
5309 | self._target_branch_pattern = value or '*' | |
5310 |
|
5310 | |||
5311 | @hybrid_property |
|
5311 | @hybrid_property | |
5312 | def file_pattern(self): |
|
5312 | def file_pattern(self): | |
5313 | return self._file_pattern or '*' |
|
5313 | return self._file_pattern or '*' | |
5314 |
|
5314 | |||
5315 | @file_pattern.setter |
|
5315 | @file_pattern.setter | |
5316 | def file_pattern(self, value): |
|
5316 | def file_pattern(self, value): | |
5317 | self._validate_pattern(value) |
|
5317 | self._validate_pattern(value) | |
5318 | self._file_pattern = value or '*' |
|
5318 | self._file_pattern = value or '*' | |
5319 |
|
5319 | |||
5320 | @hybrid_property |
|
5320 | @hybrid_property | |
5321 | def forbid_pr_author_to_review(self): |
|
5321 | def forbid_pr_author_to_review(self): | |
5322 | return self.pr_author == 'forbid_pr_author' |
|
5322 | return self.pr_author == 'forbid_pr_author' | |
5323 |
|
5323 | |||
5324 | @hybrid_property |
|
5324 | @hybrid_property | |
5325 | def include_pr_author_to_review(self): |
|
5325 | def include_pr_author_to_review(self): | |
5326 | return self.pr_author == 'include_pr_author' |
|
5326 | return self.pr_author == 'include_pr_author' | |
5327 |
|
5327 | |||
5328 | @hybrid_property |
|
5328 | @hybrid_property | |
5329 | def forbid_commit_author_to_review(self): |
|
5329 | def forbid_commit_author_to_review(self): | |
5330 | return self.commit_author == 'forbid_commit_author' |
|
5330 | return self.commit_author == 'forbid_commit_author' | |
5331 |
|
5331 | |||
5332 | @hybrid_property |
|
5332 | @hybrid_property | |
5333 | def include_commit_author_to_review(self): |
|
5333 | def include_commit_author_to_review(self): | |
5334 | return self.commit_author == 'include_commit_author' |
|
5334 | return self.commit_author == 'include_commit_author' | |
5335 |
|
5335 | |||
5336 | def matches(self, source_branch, target_branch, files_changed): |
|
5336 | def matches(self, source_branch, target_branch, files_changed): | |
5337 | """ |
|
5337 | """ | |
5338 | Check if this review rule matches a branch/files in a pull request |
|
5338 | Check if this review rule matches a branch/files in a pull request | |
5339 |
|
5339 | |||
5340 | :param source_branch: source branch name for the commit |
|
5340 | :param source_branch: source branch name for the commit | |
5341 | :param target_branch: target branch name for the commit |
|
5341 | :param target_branch: target branch name for the commit | |
5342 | :param files_changed: list of file paths changed in the pull request |
|
5342 | :param files_changed: list of file paths changed in the pull request | |
5343 | """ |
|
5343 | """ | |
5344 |
|
5344 | |||
5345 | source_branch = source_branch or '' |
|
5345 | source_branch = source_branch or '' | |
5346 | target_branch = target_branch or '' |
|
5346 | target_branch = target_branch or '' | |
5347 | files_changed = files_changed or [] |
|
5347 | files_changed = files_changed or [] | |
5348 |
|
5348 | |||
5349 | branch_matches = True |
|
5349 | branch_matches = True | |
5350 | if source_branch or target_branch: |
|
5350 | if source_branch or target_branch: | |
5351 | if self.source_branch_pattern == '*': |
|
5351 | if self.source_branch_pattern == '*': | |
5352 | source_branch_match = True |
|
5352 | source_branch_match = True | |
5353 | else: |
|
5353 | else: | |
5354 | if self.source_branch_pattern.startswith('re:'): |
|
5354 | if self.source_branch_pattern.startswith('re:'): | |
5355 | source_pattern = self.source_branch_pattern[3:] |
|
5355 | source_pattern = self.source_branch_pattern[3:] | |
5356 | else: |
|
5356 | else: | |
5357 | source_pattern = '^' + glob2re(self.source_branch_pattern) + '$' |
|
5357 | source_pattern = '^' + glob2re(self.source_branch_pattern) + '$' | |
5358 | source_branch_regex = re.compile(source_pattern) |
|
5358 | source_branch_regex = re.compile(source_pattern) | |
5359 | source_branch_match = bool(source_branch_regex.search(source_branch)) |
|
5359 | source_branch_match = bool(source_branch_regex.search(source_branch)) | |
5360 | if self.target_branch_pattern == '*': |
|
5360 | if self.target_branch_pattern == '*': | |
5361 | target_branch_match = True |
|
5361 | target_branch_match = True | |
5362 | else: |
|
5362 | else: | |
5363 | if self.target_branch_pattern.startswith('re:'): |
|
5363 | if self.target_branch_pattern.startswith('re:'): | |
5364 | target_pattern = self.target_branch_pattern[3:] |
|
5364 | target_pattern = self.target_branch_pattern[3:] | |
5365 | else: |
|
5365 | else: | |
5366 | target_pattern = '^' + glob2re(self.target_branch_pattern) + '$' |
|
5366 | target_pattern = '^' + glob2re(self.target_branch_pattern) + '$' | |
5367 | target_branch_regex = re.compile(target_pattern) |
|
5367 | target_branch_regex = re.compile(target_pattern) | |
5368 | target_branch_match = bool(target_branch_regex.search(target_branch)) |
|
5368 | target_branch_match = bool(target_branch_regex.search(target_branch)) | |
5369 |
|
5369 | |||
5370 | branch_matches = source_branch_match and target_branch_match |
|
5370 | branch_matches = source_branch_match and target_branch_match | |
5371 |
|
5371 | |||
5372 | files_matches = True |
|
5372 | files_matches = True | |
5373 | if self.file_pattern != '*': |
|
5373 | if self.file_pattern != '*': | |
5374 | files_matches = False |
|
5374 | files_matches = False | |
5375 | if self.file_pattern.startswith('re:'): |
|
5375 | if self.file_pattern.startswith('re:'): | |
5376 | file_pattern = self.file_pattern[3:] |
|
5376 | file_pattern = self.file_pattern[3:] | |
5377 | else: |
|
5377 | else: | |
5378 | file_pattern = glob2re(self.file_pattern) |
|
5378 | file_pattern = glob2re(self.file_pattern) | |
5379 | file_regex = re.compile(file_pattern) |
|
5379 | file_regex = re.compile(file_pattern) | |
5380 | for file_data in files_changed: |
|
5380 | for file_data in files_changed: | |
5381 | filename = file_data.get('filename') |
|
5381 | filename = file_data.get('filename') | |
5382 |
|
5382 | |||
5383 | if file_regex.search(filename): |
|
5383 | if file_regex.search(filename): | |
5384 | files_matches = True |
|
5384 | files_matches = True | |
5385 | break |
|
5385 | break | |
5386 |
|
5386 | |||
5387 | return branch_matches and files_matches |
|
5387 | return branch_matches and files_matches | |
5388 |
|
5388 | |||
5389 | @property |
|
5389 | @property | |
5390 | def review_users(self): |
|
5390 | def review_users(self): | |
5391 | """ Returns the users which this rule applies to """ |
|
5391 | """ Returns the users which this rule applies to """ | |
5392 |
|
5392 | |||
5393 | users = collections.OrderedDict() |
|
5393 | users = collections.OrderedDict() | |
5394 |
|
5394 | |||
5395 | for rule_user in self.rule_users: |
|
5395 | for rule_user in self.rule_users: | |
5396 | if rule_user.user.active: |
|
5396 | if rule_user.user.active: | |
5397 | if rule_user.user not in users: |
|
5397 | if rule_user.user not in users: | |
5398 | users[rule_user.user.username] = { |
|
5398 | users[rule_user.user.username] = { | |
5399 | 'user': rule_user.user, |
|
5399 | 'user': rule_user.user, | |
5400 | 'source': 'user', |
|
5400 | 'source': 'user', | |
5401 | 'source_data': {}, |
|
5401 | 'source_data': {}, | |
5402 | 'data': rule_user.rule_data() |
|
5402 | 'data': rule_user.rule_data() | |
5403 | } |
|
5403 | } | |
5404 |
|
5404 | |||
5405 | for rule_user_group in self.rule_user_groups: |
|
5405 | for rule_user_group in self.rule_user_groups: | |
5406 | source_data = { |
|
5406 | source_data = { | |
5407 | 'user_group_id': rule_user_group.users_group.users_group_id, |
|
5407 | 'user_group_id': rule_user_group.users_group.users_group_id, | |
5408 | 'name': rule_user_group.users_group.users_group_name, |
|
5408 | 'name': rule_user_group.users_group.users_group_name, | |
5409 | 'members': len(rule_user_group.users_group.members) |
|
5409 | 'members': len(rule_user_group.users_group.members) | |
5410 | } |
|
5410 | } | |
5411 | for member in rule_user_group.users_group.members: |
|
5411 | for member in rule_user_group.users_group.members: | |
5412 | if member.user.active: |
|
5412 | if member.user.active: | |
5413 | key = member.user.username |
|
5413 | key = member.user.username | |
5414 | if key in users: |
|
5414 | if key in users: | |
5415 | # skip this member as we have him already |
|
5415 | # skip this member as we have him already | |
5416 | # this prevents from override the "first" matched |
|
5416 | # this prevents from override the "first" matched | |
5417 | # users with duplicates in multiple groups |
|
5417 | # users with duplicates in multiple groups | |
5418 | continue |
|
5418 | continue | |
5419 |
|
5419 | |||
5420 | users[key] = { |
|
5420 | users[key] = { | |
5421 | 'user': member.user, |
|
5421 | 'user': member.user, | |
5422 | 'source': 'user_group', |
|
5422 | 'source': 'user_group', | |
5423 | 'source_data': source_data, |
|
5423 | 'source_data': source_data, | |
5424 | 'data': rule_user_group.rule_data() |
|
5424 | 'data': rule_user_group.rule_data() | |
5425 | } |
|
5425 | } | |
5426 |
|
5426 | |||
5427 | return users |
|
5427 | return users | |
5428 |
|
5428 | |||
5429 | def user_group_vote_rule(self, user_id): |
|
5429 | def user_group_vote_rule(self, user_id): | |
5430 |
|
5430 | |||
5431 | rules = [] |
|
5431 | rules = [] | |
5432 | if not self.rule_user_groups: |
|
5432 | if not self.rule_user_groups: | |
5433 | return rules |
|
5433 | return rules | |
5434 |
|
5434 | |||
5435 | for user_group in self.rule_user_groups: |
|
5435 | for user_group in self.rule_user_groups: | |
5436 | user_group_members = [x.user_id for x in user_group.users_group.members] |
|
5436 | user_group_members = [x.user_id for x in user_group.users_group.members] | |
5437 | if user_id in user_group_members: |
|
5437 | if user_id in user_group_members: | |
5438 | rules.append(user_group) |
|
5438 | rules.append(user_group) | |
5439 | return rules |
|
5439 | return rules | |
5440 |
|
5440 | |||
5441 | def __repr__(self): |
|
5441 | def __repr__(self): | |
5442 | return f'<RepoReviewerRule(id={self.repo_review_rule_id}, repo={self.repo!r})>' |
|
5442 | return f'<RepoReviewerRule(id={self.repo_review_rule_id}, repo={self.repo!r})>' | |
5443 |
|
5443 | |||
5444 |
|
5444 | |||
5445 | class ScheduleEntry(Base, BaseModel): |
|
5445 | class ScheduleEntry(Base, BaseModel): | |
5446 | __tablename__ = 'schedule_entries' |
|
5446 | __tablename__ = 'schedule_entries' | |
5447 | __table_args__ = ( |
|
5447 | __table_args__ = ( | |
5448 | UniqueConstraint('schedule_name', name='s_schedule_name_idx'), |
|
5448 | UniqueConstraint('schedule_name', name='s_schedule_name_idx'), | |
5449 | UniqueConstraint('task_uid', name='s_task_uid_idx'), |
|
5449 | UniqueConstraint('task_uid', name='s_task_uid_idx'), | |
5450 | base_table_args, |
|
5450 | base_table_args, | |
5451 | ) |
|
5451 | ) | |
5452 | SCHEDULE_TYPE_INTEGER = "integer" |
|
5452 | SCHEDULE_TYPE_INTEGER = "integer" | |
5453 | SCHEDULE_TYPE_CRONTAB = "crontab" |
|
5453 | SCHEDULE_TYPE_CRONTAB = "crontab" | |
5454 |
|
5454 | |||
5455 | schedule_types = [SCHEDULE_TYPE_CRONTAB, SCHEDULE_TYPE_INTEGER] |
|
5455 | schedule_types = [SCHEDULE_TYPE_CRONTAB, SCHEDULE_TYPE_INTEGER] | |
5456 | schedule_entry_id = Column('schedule_entry_id', Integer(), primary_key=True) |
|
5456 | schedule_entry_id = Column('schedule_entry_id', Integer(), primary_key=True) | |
5457 |
|
5457 | |||
5458 | schedule_name = Column("schedule_name", String(255), nullable=False, unique=None, default=None) |
|
5458 | schedule_name = Column("schedule_name", String(255), nullable=False, unique=None, default=None) | |
5459 | schedule_description = Column("schedule_description", String(10000), nullable=True, unique=None, default=None) |
|
5459 | schedule_description = Column("schedule_description", String(10000), nullable=True, unique=None, default=None) | |
5460 | schedule_enabled = Column("schedule_enabled", Boolean(), nullable=False, unique=None, default=True) |
|
5460 | schedule_enabled = Column("schedule_enabled", Boolean(), nullable=False, unique=None, default=True) | |
5461 |
|
5461 | |||
5462 | _schedule_type = Column("schedule_type", String(255), nullable=False, unique=None, default=None) |
|
5462 | _schedule_type = Column("schedule_type", String(255), nullable=False, unique=None, default=None) | |
5463 | schedule_definition = Column('schedule_definition_json', MutationObj.as_mutable(JsonType(default=lambda: "", dialect_map=dict(mysql=LONGTEXT())))) |
|
5463 | schedule_definition = Column('schedule_definition_json', MutationObj.as_mutable(JsonType(default=lambda: "", dialect_map=dict(mysql=LONGTEXT())))) | |
5464 |
|
5464 | |||
5465 | schedule_last_run = Column('schedule_last_run', DateTime(timezone=False), nullable=True, unique=None, default=None) |
|
5465 | schedule_last_run = Column('schedule_last_run', DateTime(timezone=False), nullable=True, unique=None, default=None) | |
5466 | schedule_total_run_count = Column('schedule_total_run_count', Integer(), nullable=True, unique=None, default=0) |
|
5466 | schedule_total_run_count = Column('schedule_total_run_count', Integer(), nullable=True, unique=None, default=0) | |
5467 |
|
5467 | |||
5468 | # task |
|
5468 | # task | |
5469 | task_uid = Column("task_uid", String(255), nullable=False, unique=None, default=None) |
|
5469 | task_uid = Column("task_uid", String(255), nullable=False, unique=None, default=None) | |
5470 | task_dot_notation = Column("task_dot_notation", String(4096), nullable=False, unique=None, default=None) |
|
5470 | task_dot_notation = Column("task_dot_notation", String(4096), nullable=False, unique=None, default=None) | |
5471 | task_args = Column('task_args_json', MutationObj.as_mutable(JsonType(default=list, dialect_map=dict(mysql=LONGTEXT())))) |
|
5471 | task_args = Column('task_args_json', MutationObj.as_mutable(JsonType(default=list, dialect_map=dict(mysql=LONGTEXT())))) | |
5472 | task_kwargs = Column('task_kwargs_json', MutationObj.as_mutable(JsonType(default=dict, dialect_map=dict(mysql=LONGTEXT())))) |
|
5472 | task_kwargs = Column('task_kwargs_json', MutationObj.as_mutable(JsonType(default=dict, dialect_map=dict(mysql=LONGTEXT())))) | |
5473 |
|
5473 | |||
5474 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
5474 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
5475 | updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=None) |
|
5475 | updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=None) | |
5476 |
|
5476 | |||
5477 | @hybrid_property |
|
5477 | @hybrid_property | |
5478 | def schedule_type(self): |
|
5478 | def schedule_type(self): | |
5479 | return self._schedule_type |
|
5479 | return self._schedule_type | |
5480 |
|
5480 | |||
5481 | @schedule_type.setter |
|
5481 | @schedule_type.setter | |
5482 | def schedule_type(self, val): |
|
5482 | def schedule_type(self, val): | |
5483 | if val not in self.schedule_types: |
|
5483 | if val not in self.schedule_types: | |
5484 | raise ValueError(f'Value must be on of `{val}` and got `{self.schedule_type}`') |
|
5484 | raise ValueError(f'Value must be on of `{val}` and got `{self.schedule_type}`') | |
5485 |
|
5485 | |||
5486 | self._schedule_type = val |
|
5486 | self._schedule_type = val | |
5487 |
|
5487 | |||
5488 | @classmethod |
|
5488 | @classmethod | |
5489 | def get_uid(cls, obj): |
|
5489 | def get_uid(cls, obj): | |
5490 | args = obj.task_args |
|
5490 | args = obj.task_args | |
5491 | kwargs = obj.task_kwargs |
|
5491 | kwargs = obj.task_kwargs | |
5492 |
|
5492 | |||
5493 | if isinstance(args, JsonRaw): |
|
5493 | if isinstance(args, JsonRaw): | |
5494 | try: |
|
5494 | try: | |
5495 | args = json.loads(str(args)) |
|
5495 | args = json.loads(str(args)) | |
5496 | except ValueError: |
|
5496 | except ValueError: | |
5497 | log.exception('json.loads of args failed...') |
|
5497 | log.exception('json.loads of args failed...') | |
5498 | args = tuple() |
|
5498 | args = tuple() | |
5499 |
|
5499 | |||
5500 | if isinstance(kwargs, JsonRaw): |
|
5500 | if isinstance(kwargs, JsonRaw): | |
5501 | try: |
|
5501 | try: | |
5502 | kwargs = json.loads(str(kwargs)) |
|
5502 | kwargs = json.loads(str(kwargs)) | |
5503 | except ValueError: |
|
5503 | except ValueError: | |
5504 | log.exception('json.loads of kwargs failed...') |
|
5504 | log.exception('json.loads of kwargs failed...') | |
5505 | kwargs = dict() |
|
5505 | kwargs = dict() | |
5506 |
|
5506 | |||
5507 | dot_notation = obj.task_dot_notation |
|
5507 | dot_notation = obj.task_dot_notation | |
5508 | val = '.'.join(map(safe_str, [dot_notation, args, sorted(kwargs.items())])) |
|
5508 | val = '.'.join(map(safe_str, [dot_notation, args, sorted(kwargs.items())])) | |
5509 | log.debug('calculating task uid using id:`%s`', val) |
|
5509 | log.debug('calculating task uid using id:`%s`', val) | |
5510 |
|
5510 | |||
5511 | return sha1(safe_bytes(val)) |
|
5511 | return sha1(safe_bytes(val)) | |
5512 |
|
5512 | |||
5513 | @classmethod |
|
5513 | @classmethod | |
5514 | def get_by_schedule_name(cls, schedule_name): |
|
5514 | def get_by_schedule_name(cls, schedule_name): | |
5515 | return cls.query().filter(cls.schedule_name == schedule_name).scalar() |
|
5515 | return cls.query().filter(cls.schedule_name == schedule_name).scalar() | |
5516 |
|
5516 | |||
5517 | @classmethod |
|
5517 | @classmethod | |
5518 | def get_by_schedule_id(cls, schedule_id): |
|
5518 | def get_by_schedule_id(cls, schedule_id): | |
5519 | return cls.query().filter(cls.schedule_entry_id == schedule_id).scalar() |
|
5519 | return cls.query().filter(cls.schedule_entry_id == schedule_id).scalar() | |
5520 |
|
5520 | |||
5521 | @classmethod |
|
5521 | @classmethod | |
5522 | def get_by_task_uid(cls, task_uid): |
|
5522 | def get_by_task_uid(cls, task_uid): | |
5523 | return cls.query().filter(cls.task_uid == task_uid).scalar() |
|
5523 | return cls.query().filter(cls.task_uid == task_uid).scalar() | |
5524 |
|
5524 | |||
5525 | @property |
|
5525 | @property | |
5526 | def task(self): |
|
5526 | def task(self): | |
5527 | return self.task_dot_notation |
|
5527 | return self.task_dot_notation | |
5528 |
|
5528 | |||
5529 | @property |
|
5529 | @property | |
5530 | def schedule(self): |
|
5530 | def schedule(self): | |
5531 | from rhodecode.lib.celerylib.utils import raw_2_schedule |
|
5531 | from rhodecode.lib.celerylib.utils import raw_2_schedule | |
5532 | schedule = raw_2_schedule(self.schedule_definition, self.schedule_type) |
|
5532 | schedule = raw_2_schedule(self.schedule_definition, self.schedule_type) | |
5533 | return schedule |
|
5533 | return schedule | |
5534 |
|
5534 | |||
5535 | @property |
|
5535 | @property | |
5536 | def args(self): |
|
5536 | def args(self): | |
5537 | try: |
|
5537 | try: | |
5538 | return list(self.task_args or []) |
|
5538 | return list(self.task_args or []) | |
5539 | except ValueError: |
|
5539 | except ValueError: | |
5540 | return list() |
|
5540 | return list() | |
5541 |
|
5541 | |||
5542 | @property |
|
5542 | @property | |
5543 | def kwargs(self): |
|
5543 | def kwargs(self): | |
5544 | try: |
|
5544 | try: | |
5545 | return dict(self.task_kwargs or {}) |
|
5545 | return dict(self.task_kwargs or {}) | |
5546 | except ValueError: |
|
5546 | except ValueError: | |
5547 | return dict() |
|
5547 | return dict() | |
5548 |
|
5548 | |||
5549 | def _as_raw(self, val, indent=False): |
|
5549 | def _as_raw(self, val, indent=False): | |
5550 | if hasattr(val, 'de_coerce'): |
|
5550 | if hasattr(val, 'de_coerce'): | |
5551 | val = val.de_coerce() |
|
5551 | val = val.de_coerce() | |
5552 | if val: |
|
5552 | if val: | |
5553 | if indent: |
|
5553 | if indent: | |
5554 | val = ext_json.formatted_str_json(val) |
|
5554 | val = ext_json.formatted_str_json(val) | |
5555 | else: |
|
5555 | else: | |
5556 | val = ext_json.str_json(val) |
|
5556 | val = ext_json.str_json(val) | |
5557 |
|
5557 | |||
5558 | return val |
|
5558 | return val | |
5559 |
|
5559 | |||
5560 | @property |
|
5560 | @property | |
5561 | def schedule_definition_raw(self): |
|
5561 | def schedule_definition_raw(self): | |
5562 | return self._as_raw(self.schedule_definition) |
|
5562 | return self._as_raw(self.schedule_definition) | |
5563 |
|
5563 | |||
5564 | def args_raw(self, indent=False): |
|
5564 | def args_raw(self, indent=False): | |
5565 | return self._as_raw(self.task_args, indent) |
|
5565 | return self._as_raw(self.task_args, indent) | |
5566 |
|
5566 | |||
5567 | def kwargs_raw(self, indent=False): |
|
5567 | def kwargs_raw(self, indent=False): | |
5568 | return self._as_raw(self.task_kwargs, indent) |
|
5568 | return self._as_raw(self.task_kwargs, indent) | |
5569 |
|
5569 | |||
5570 | def __repr__(self): |
|
5570 | def __repr__(self): | |
5571 | return f'<DB:ScheduleEntry({self.schedule_entry_id}:{self.schedule_name})>' |
|
5571 | return f'<DB:ScheduleEntry({self.schedule_entry_id}:{self.schedule_name})>' | |
5572 |
|
5572 | |||
5573 |
|
5573 | |||
5574 | @event.listens_for(ScheduleEntry, 'before_update') |
|
5574 | @event.listens_for(ScheduleEntry, 'before_update') | |
5575 | def update_task_uid(mapper, connection, target): |
|
5575 | def update_task_uid(mapper, connection, target): | |
5576 | target.task_uid = ScheduleEntry.get_uid(target) |
|
5576 | target.task_uid = ScheduleEntry.get_uid(target) | |
5577 |
|
5577 | |||
5578 |
|
5578 | |||
5579 | @event.listens_for(ScheduleEntry, 'before_insert') |
|
5579 | @event.listens_for(ScheduleEntry, 'before_insert') | |
5580 | def set_task_uid(mapper, connection, target): |
|
5580 | def set_task_uid(mapper, connection, target): | |
5581 | target.task_uid = ScheduleEntry.get_uid(target) |
|
5581 | target.task_uid = ScheduleEntry.get_uid(target) | |
5582 |
|
5582 | |||
5583 |
|
5583 | |||
5584 | class _BaseBranchPerms(BaseModel): |
|
5584 | class _BaseBranchPerms(BaseModel): | |
5585 | @classmethod |
|
5585 | @classmethod | |
5586 | def compute_hash(cls, value): |
|
5586 | def compute_hash(cls, value): | |
5587 | return sha1_safe(value) |
|
5587 | return sha1_safe(value) | |
5588 |
|
5588 | |||
5589 | @hybrid_property |
|
5589 | @hybrid_property | |
5590 | def branch_pattern(self): |
|
5590 | def branch_pattern(self): | |
5591 | return self._branch_pattern or '*' |
|
5591 | return self._branch_pattern or '*' | |
5592 |
|
5592 | |||
5593 | @hybrid_property |
|
5593 | @hybrid_property | |
5594 | def branch_hash(self): |
|
5594 | def branch_hash(self): | |
5595 | return self._branch_hash |
|
5595 | return self._branch_hash | |
5596 |
|
5596 | |||
5597 | def _validate_glob(self, value): |
|
5597 | def _validate_glob(self, value): | |
5598 | re.compile('^' + glob2re(value) + '$') |
|
5598 | re.compile('^' + glob2re(value) + '$') | |
5599 |
|
5599 | |||
5600 | @branch_pattern.setter |
|
5600 | @branch_pattern.setter | |
5601 | def branch_pattern(self, value): |
|
5601 | def branch_pattern(self, value): | |
5602 | self._validate_glob(value) |
|
5602 | self._validate_glob(value) | |
5603 | self._branch_pattern = value or '*' |
|
5603 | self._branch_pattern = value or '*' | |
5604 | # set the Hash when setting the branch pattern |
|
5604 | # set the Hash when setting the branch pattern | |
5605 | self._branch_hash = self.compute_hash(self._branch_pattern) |
|
5605 | self._branch_hash = self.compute_hash(self._branch_pattern) | |
5606 |
|
5606 | |||
5607 | def matches(self, branch): |
|
5607 | def matches(self, branch): | |
5608 | """ |
|
5608 | """ | |
5609 | Check if this the branch matches entry |
|
5609 | Check if this the branch matches entry | |
5610 |
|
5610 | |||
5611 | :param branch: branch name for the commit |
|
5611 | :param branch: branch name for the commit | |
5612 | """ |
|
5612 | """ | |
5613 |
|
5613 | |||
5614 | branch = branch or '' |
|
5614 | branch = branch or '' | |
5615 |
|
5615 | |||
5616 | branch_matches = True |
|
5616 | branch_matches = True | |
5617 | if branch: |
|
5617 | if branch: | |
5618 | branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$') |
|
5618 | branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$') | |
5619 | branch_matches = bool(branch_regex.search(branch)) |
|
5619 | branch_matches = bool(branch_regex.search(branch)) | |
5620 |
|
5620 | |||
5621 | return branch_matches |
|
5621 | return branch_matches | |
5622 |
|
5622 | |||
5623 |
|
5623 | |||
5624 | class UserToRepoBranchPermission(Base, _BaseBranchPerms): |
|
5624 | class UserToRepoBranchPermission(Base, _BaseBranchPerms): | |
5625 | __tablename__ = 'user_to_repo_branch_permissions' |
|
5625 | __tablename__ = 'user_to_repo_branch_permissions' | |
5626 | __table_args__ = ( |
|
5626 | __table_args__ = ( | |
5627 | base_table_args |
|
5627 | base_table_args | |
5628 | ) |
|
5628 | ) | |
5629 |
|
5629 | |||
5630 | branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True) |
|
5630 | branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True) | |
5631 |
|
5631 | |||
5632 | repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) |
|
5632 | repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) | |
5633 | repo = relationship('Repository', back_populates='user_branch_perms') |
|
5633 | repo = relationship('Repository', back_populates='user_branch_perms') | |
5634 |
|
5634 | |||
5635 | permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
5635 | permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
5636 | permission = relationship('Permission') |
|
5636 | permission = relationship('Permission') | |
5637 |
|
5637 | |||
5638 | rule_to_perm_id = Column('rule_to_perm_id', Integer(), ForeignKey('repo_to_perm.repo_to_perm_id'), nullable=False, unique=None, default=None) |
|
5638 | rule_to_perm_id = Column('rule_to_perm_id', Integer(), ForeignKey('repo_to_perm.repo_to_perm_id'), nullable=False, unique=None, default=None) | |
5639 | user_repo_to_perm = relationship('UserRepoToPerm', back_populates='branch_perm_entry') |
|
5639 | user_repo_to_perm = relationship('UserRepoToPerm', back_populates='branch_perm_entry') | |
5640 |
|
5640 | |||
5641 | rule_order = Column('rule_order', Integer(), nullable=False) |
|
5641 | rule_order = Column('rule_order', Integer(), nullable=False) | |
5642 | _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default='*') # glob |
|
5642 | _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default='*') # glob | |
5643 | _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql')) |
|
5643 | _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql')) | |
5644 |
|
5644 | |||
5645 | def __repr__(self): |
|
5645 | def __repr__(self): | |
5646 | return f'<UserBranchPermission({self.user_repo_to_perm} => {self.branch_pattern!r})>' |
|
5646 | return f'<UserBranchPermission({self.user_repo_to_perm} => {self.branch_pattern!r})>' | |
5647 |
|
5647 | |||
5648 |
|
5648 | |||
5649 | class UserGroupToRepoBranchPermission(Base, _BaseBranchPerms): |
|
5649 | class UserGroupToRepoBranchPermission(Base, _BaseBranchPerms): | |
5650 | __tablename__ = 'user_group_to_repo_branch_permissions' |
|
5650 | __tablename__ = 'user_group_to_repo_branch_permissions' | |
5651 | __table_args__ = ( |
|
5651 | __table_args__ = ( | |
5652 | base_table_args |
|
5652 | base_table_args | |
5653 | ) |
|
5653 | ) | |
5654 |
|
5654 | |||
5655 | branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True) |
|
5655 | branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True) | |
5656 |
|
5656 | |||
5657 | repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) |
|
5657 | repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) | |
5658 | repo = relationship('Repository', back_populates='user_group_branch_perms') |
|
5658 | repo = relationship('Repository', back_populates='user_group_branch_perms') | |
5659 |
|
5659 | |||
5660 | permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) |
|
5660 | permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
5661 | permission = relationship('Permission') |
|
5661 | permission = relationship('Permission') | |
5662 |
|
5662 | |||
5663 | rule_to_perm_id = Column('rule_to_perm_id', Integer(), ForeignKey('users_group_repo_to_perm.users_group_to_perm_id'), nullable=False, unique=None, default=None) |
|
5663 | rule_to_perm_id = Column('rule_to_perm_id', Integer(), ForeignKey('users_group_repo_to_perm.users_group_to_perm_id'), nullable=False, unique=None, default=None) | |
5664 | user_group_repo_to_perm = relationship('UserGroupRepoToPerm', back_populates='user_group_branch_perms') |
|
5664 | user_group_repo_to_perm = relationship('UserGroupRepoToPerm', back_populates='user_group_branch_perms') | |
5665 |
|
5665 | |||
5666 | rule_order = Column('rule_order', Integer(), nullable=False) |
|
5666 | rule_order = Column('rule_order', Integer(), nullable=False) | |
5667 | _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default='*') # glob |
|
5667 | _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default='*') # glob | |
5668 | _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql')) |
|
5668 | _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql')) | |
5669 |
|
5669 | |||
5670 | def __repr__(self): |
|
5670 | def __repr__(self): | |
5671 | return f'<UserBranchPermission({self.user_group_repo_to_perm} => {self.branch_pattern!r})>' |
|
5671 | return f'<UserBranchPermission({self.user_group_repo_to_perm} => {self.branch_pattern!r})>' | |
5672 |
|
5672 | |||
5673 |
|
5673 | |||
5674 | class UserBookmark(Base, BaseModel): |
|
5674 | class UserBookmark(Base, BaseModel): | |
5675 | __tablename__ = 'user_bookmarks' |
|
5675 | __tablename__ = 'user_bookmarks' | |
5676 | __table_args__ = ( |
|
5676 | __table_args__ = ( | |
5677 | UniqueConstraint('user_id', 'bookmark_repo_id'), |
|
5677 | UniqueConstraint('user_id', 'bookmark_repo_id'), | |
5678 | UniqueConstraint('user_id', 'bookmark_repo_group_id'), |
|
5678 | UniqueConstraint('user_id', 'bookmark_repo_group_id'), | |
5679 | UniqueConstraint('user_id', 'bookmark_position'), |
|
5679 | UniqueConstraint('user_id', 'bookmark_position'), | |
5680 | base_table_args |
|
5680 | base_table_args | |
5681 | ) |
|
5681 | ) | |
5682 |
|
5682 | |||
5683 | user_bookmark_id = Column("user_bookmark_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) |
|
5683 | user_bookmark_id = Column("user_bookmark_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
5684 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) |
|
5684 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
5685 | position = Column("bookmark_position", Integer(), nullable=False) |
|
5685 | position = Column("bookmark_position", Integer(), nullable=False) | |
5686 | title = Column("bookmark_title", String(255), nullable=True, unique=None, default=None) |
|
5686 | title = Column("bookmark_title", String(255), nullable=True, unique=None, default=None) | |
5687 | redirect_url = Column("bookmark_redirect_url", String(10240), nullable=True, unique=None, default=None) |
|
5687 | redirect_url = Column("bookmark_redirect_url", String(10240), nullable=True, unique=None, default=None) | |
5688 | created_on = Column("created_on", DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
5688 | created_on = Column("created_on", DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
5689 |
|
5689 | |||
5690 | bookmark_repo_id = Column("bookmark_repo_id", Integer(), ForeignKey("repositories.repo_id"), nullable=True, unique=None, default=None) |
|
5690 | bookmark_repo_id = Column("bookmark_repo_id", Integer(), ForeignKey("repositories.repo_id"), nullable=True, unique=None, default=None) | |
5691 | bookmark_repo_group_id = Column("bookmark_repo_group_id", Integer(), ForeignKey("groups.group_id"), nullable=True, unique=None, default=None) |
|
5691 | bookmark_repo_group_id = Column("bookmark_repo_group_id", Integer(), ForeignKey("groups.group_id"), nullable=True, unique=None, default=None) | |
5692 |
|
5692 | |||
5693 | user = relationship("User") |
|
5693 | user = relationship("User") | |
5694 |
|
5694 | |||
5695 | repository = relationship("Repository") |
|
5695 | repository = relationship("Repository") | |
5696 | repository_group = relationship("RepoGroup") |
|
5696 | repository_group = relationship("RepoGroup") | |
5697 |
|
5697 | |||
5698 | @classmethod |
|
5698 | @classmethod | |
5699 | def get_by_position_for_user(cls, position, user_id): |
|
5699 | def get_by_position_for_user(cls, position, user_id): | |
5700 | return cls.query() \ |
|
5700 | return cls.query() \ | |
5701 | .filter(UserBookmark.user_id == user_id) \ |
|
5701 | .filter(UserBookmark.user_id == user_id) \ | |
5702 | .filter(UserBookmark.position == position).scalar() |
|
5702 | .filter(UserBookmark.position == position).scalar() | |
5703 |
|
5703 | |||
5704 | @classmethod |
|
5704 | @classmethod | |
5705 | def get_bookmarks_for_user(cls, user_id, cache=True): |
|
5705 | def get_bookmarks_for_user(cls, user_id, cache=True): | |
5706 | bookmarks = select( |
|
5706 | bookmarks = select( | |
5707 | UserBookmark.title, |
|
5707 | UserBookmark.title, | |
5708 | UserBookmark.position, |
|
5708 | UserBookmark.position, | |
5709 | ) \ |
|
5709 | ) \ | |
5710 | .add_columns(Repository.repo_id, Repository.repo_type, Repository.repo_name) \ |
|
5710 | .add_columns(Repository.repo_id, Repository.repo_type, Repository.repo_name) \ | |
5711 | .add_columns(RepoGroup.group_id, RepoGroup.group_name) \ |
|
5711 | .add_columns(RepoGroup.group_id, RepoGroup.group_name) \ | |
5712 | .where(UserBookmark.user_id == user_id) \ |
|
5712 | .where(UserBookmark.user_id == user_id) \ | |
5713 | .outerjoin(Repository, Repository.repo_id == UserBookmark.bookmark_repo_id) \ |
|
5713 | .outerjoin(Repository, Repository.repo_id == UserBookmark.bookmark_repo_id) \ | |
5714 | .outerjoin(RepoGroup, RepoGroup.group_id == UserBookmark.bookmark_repo_group_id) \ |
|
5714 | .outerjoin(RepoGroup, RepoGroup.group_id == UserBookmark.bookmark_repo_group_id) \ | |
5715 | .order_by(UserBookmark.position.asc()) |
|
5715 | .order_by(UserBookmark.position.asc()) | |
5716 |
|
5716 | |||
5717 | if cache: |
|
5717 | if cache: | |
5718 | bookmarks = bookmarks.options( |
|
5718 | bookmarks = bookmarks.options( | |
5719 | FromCache("sql_cache_short", f"get_user_{user_id}_bookmarks") |
|
5719 | FromCache("sql_cache_short", f"get_user_{user_id}_bookmarks") | |
5720 | ) |
|
5720 | ) | |
5721 |
|
5721 | |||
5722 | return Session().execute(bookmarks).all() |
|
5722 | return Session().execute(bookmarks).all() | |
5723 |
|
5723 | |||
5724 | def __repr__(self): |
|
5724 | def __repr__(self): | |
5725 | return f'<UserBookmark({self.position} @ {self.redirect_url!r})>' |
|
5725 | return f'<UserBookmark({self.position} @ {self.redirect_url!r})>' | |
5726 |
|
5726 | |||
5727 |
|
5727 | |||
5728 | class FileStore(Base, BaseModel): |
|
5728 | class FileStore(Base, BaseModel): | |
5729 | __tablename__ = 'file_store' |
|
5729 | __tablename__ = 'file_store' | |
5730 | __table_args__ = ( |
|
5730 | __table_args__ = ( | |
5731 | base_table_args |
|
5731 | base_table_args | |
5732 | ) |
|
5732 | ) | |
5733 |
|
5733 | |||
5734 | file_store_id = Column('file_store_id', Integer(), primary_key=True) |
|
5734 | file_store_id = Column('file_store_id', Integer(), primary_key=True) | |
5735 | file_uid = Column('file_uid', String(1024), nullable=False) |
|
5735 | file_uid = Column('file_uid', String(1024), nullable=False) | |
5736 | file_display_name = Column('file_display_name', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), nullable=True) |
|
5736 | file_display_name = Column('file_display_name', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), nullable=True) | |
5737 | file_description = Column('file_description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), nullable=True) |
|
5737 | file_description = Column('file_description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), nullable=True) | |
5738 | file_org_name = Column('file_org_name', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), nullable=False) |
|
5738 | file_org_name = Column('file_org_name', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), nullable=False) | |
5739 |
|
5739 | |||
5740 | # sha256 hash |
|
5740 | # sha256 hash | |
5741 | file_hash = Column('file_hash', String(512), nullable=False) |
|
5741 | file_hash = Column('file_hash', String(512), nullable=False) | |
5742 | file_size = Column('file_size', BigInteger(), nullable=False) |
|
5742 | file_size = Column('file_size', BigInteger(), nullable=False) | |
5743 |
|
5743 | |||
5744 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) |
|
5744 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
5745 | accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True) |
|
5745 | accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True) | |
5746 | accessed_count = Column('accessed_count', Integer(), default=0) |
|
5746 | accessed_count = Column('accessed_count', Integer(), default=0) | |
5747 |
|
5747 | |||
5748 | enabled = Column('enabled', Boolean(), nullable=False, default=True) |
|
5748 | enabled = Column('enabled', Boolean(), nullable=False, default=True) | |
5749 |
|
5749 | |||
5750 | # if repo/repo_group reference is set, check for permissions |
|
5750 | # if repo/repo_group reference is set, check for permissions | |
5751 | check_acl = Column('check_acl', Boolean(), nullable=False, default=True) |
|
5751 | check_acl = Column('check_acl', Boolean(), nullable=False, default=True) | |
5752 |
|
5752 | |||
5753 | # hidden defines an attachment that should be hidden from showing in artifact listing |
|
5753 | # hidden defines an attachment that should be hidden from showing in artifact listing | |
5754 | hidden = Column('hidden', Boolean(), nullable=False, default=False) |
|
5754 | hidden = Column('hidden', Boolean(), nullable=False, default=False) | |
5755 |
|
5755 | |||
5756 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False) |
|
5756 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False) | |
5757 | upload_user = relationship('User', lazy='joined', primaryjoin='User.user_id==FileStore.user_id', back_populates='artifacts') |
|
5757 | upload_user = relationship('User', lazy='joined', primaryjoin='User.user_id==FileStore.user_id', back_populates='artifacts') | |
5758 |
|
5758 | |||
5759 | file_metadata = relationship('FileStoreMetadata', lazy='joined') |
|
5759 | file_metadata = relationship('FileStoreMetadata', lazy='joined') | |
5760 |
|
5760 | |||
5761 | # scope limited to user, which requester have access to |
|
5761 | # scope limited to user, which requester have access to | |
5762 | scope_user_id = Column( |
|
5762 | scope_user_id = Column( | |
5763 | 'scope_user_id', Integer(), ForeignKey('users.user_id'), |
|
5763 | 'scope_user_id', Integer(), ForeignKey('users.user_id'), | |
5764 | nullable=True, unique=None, default=None) |
|
5764 | nullable=True, unique=None, default=None) | |
5765 | user = relationship('User', lazy='joined', primaryjoin='User.user_id==FileStore.scope_user_id', back_populates='scope_artifacts') |
|
5765 | user = relationship('User', lazy='joined', primaryjoin='User.user_id==FileStore.scope_user_id', back_populates='scope_artifacts') | |
5766 |
|
5766 | |||
5767 | # scope limited to user group, which requester have access to |
|
5767 | # scope limited to user group, which requester have access to | |
5768 | scope_user_group_id = Column( |
|
5768 | scope_user_group_id = Column( | |
5769 | 'scope_user_group_id', Integer(), ForeignKey('users_groups.users_group_id'), |
|
5769 | 'scope_user_group_id', Integer(), ForeignKey('users_groups.users_group_id'), | |
5770 | nullable=True, unique=None, default=None) |
|
5770 | nullable=True, unique=None, default=None) | |
5771 | user_group = relationship('UserGroup', lazy='joined') |
|
5771 | user_group = relationship('UserGroup', lazy='joined') | |
5772 |
|
5772 | |||
5773 | # scope limited to repo, which requester have access to |
|
5773 | # scope limited to repo, which requester have access to | |
5774 | scope_repo_id = Column( |
|
5774 | scope_repo_id = Column( | |
5775 | 'scope_repo_id', Integer(), ForeignKey('repositories.repo_id'), |
|
5775 | 'scope_repo_id', Integer(), ForeignKey('repositories.repo_id'), | |
5776 | nullable=True, unique=None, default=None) |
|
5776 | nullable=True, unique=None, default=None) | |
5777 | repo = relationship('Repository', lazy='joined') |
|
5777 | repo = relationship('Repository', lazy='joined') | |
5778 |
|
5778 | |||
5779 | # scope limited to repo group, which requester have access to |
|
5779 | # scope limited to repo group, which requester have access to | |
5780 | scope_repo_group_id = Column( |
|
5780 | scope_repo_group_id = Column( | |
5781 | 'scope_repo_group_id', Integer(), ForeignKey('groups.group_id'), |
|
5781 | 'scope_repo_group_id', Integer(), ForeignKey('groups.group_id'), | |
5782 | nullable=True, unique=None, default=None) |
|
5782 | nullable=True, unique=None, default=None) | |
5783 | repo_group = relationship('RepoGroup', lazy='joined') |
|
5783 | repo_group = relationship('RepoGroup', lazy='joined') | |
5784 |
|
5784 | |||
5785 | @classmethod |
|
5785 | @classmethod | |
5786 | def get_scope(cls, scope_type, scope_id): |
|
5786 | def get_scope(cls, scope_type, scope_id): | |
5787 | if scope_type == 'repo': |
|
5787 | if scope_type == 'repo': | |
5788 | return f'repo:{scope_id}' |
|
5788 | return f'repo:{scope_id}' | |
5789 | elif scope_type == 'repo-group': |
|
5789 | elif scope_type == 'repo-group': | |
5790 | return f'repo-group:{scope_id}' |
|
5790 | return f'repo-group:{scope_id}' | |
5791 | elif scope_type == 'user': |
|
5791 | elif scope_type == 'user': | |
5792 | return f'user:{scope_id}' |
|
5792 | return f'user:{scope_id}' | |
5793 | elif scope_type == 'user-group': |
|
5793 | elif scope_type == 'user-group': | |
5794 | return f'user-group:{scope_id}' |
|
5794 | return f'user-group:{scope_id}' | |
5795 | else: |
|
5795 | else: | |
5796 | return scope_type |
|
5796 | return scope_type | |
5797 |
|
5797 | |||
5798 | @classmethod |
|
5798 | @classmethod | |
5799 | def get_by_store_uid(cls, file_store_uid, safe=False): |
|
5799 | def get_by_store_uid(cls, file_store_uid, safe=False): | |
5800 | if safe: |
|
5800 | if safe: | |
5801 | return FileStore.query().filter(FileStore.file_uid == file_store_uid).first() |
|
5801 | return FileStore.query().filter(FileStore.file_uid == file_store_uid).first() | |
5802 | else: |
|
5802 | else: | |
5803 | return FileStore.query().filter(FileStore.file_uid == file_store_uid).scalar() |
|
5803 | return FileStore.query().filter(FileStore.file_uid == file_store_uid).scalar() | |
5804 |
|
5804 | |||
5805 | @classmethod |
|
5805 | @classmethod | |
5806 | def create(cls, file_uid, filename, file_hash, file_size, file_display_name='', |
|
5806 | def create(cls, file_uid, filename, file_hash, file_size, file_display_name='', | |
5807 | file_description='', enabled=True, hidden=False, check_acl=True, |
|
5807 | file_description='', enabled=True, hidden=False, check_acl=True, | |
5808 | user_id=None, scope_user_id=None, scope_repo_id=None, scope_repo_group_id=None): |
|
5808 | user_id=None, scope_user_id=None, scope_repo_id=None, scope_repo_group_id=None): | |
5809 |
|
5809 | |||
5810 | store_entry = FileStore() |
|
5810 | store_entry = FileStore() | |
5811 | store_entry.file_uid = file_uid |
|
5811 | store_entry.file_uid = file_uid | |
5812 | store_entry.file_display_name = file_display_name |
|
5812 | store_entry.file_display_name = file_display_name | |
5813 | store_entry.file_org_name = filename |
|
5813 | store_entry.file_org_name = filename | |
5814 | store_entry.file_size = file_size |
|
5814 | store_entry.file_size = file_size | |
5815 | store_entry.file_hash = file_hash |
|
5815 | store_entry.file_hash = file_hash | |
5816 | store_entry.file_description = file_description |
|
5816 | store_entry.file_description = file_description | |
5817 |
|
5817 | |||
5818 | store_entry.check_acl = check_acl |
|
5818 | store_entry.check_acl = check_acl | |
5819 | store_entry.enabled = enabled |
|
5819 | store_entry.enabled = enabled | |
5820 | store_entry.hidden = hidden |
|
5820 | store_entry.hidden = hidden | |
5821 |
|
5821 | |||
5822 | store_entry.user_id = user_id |
|
5822 | store_entry.user_id = user_id | |
5823 | store_entry.scope_user_id = scope_user_id |
|
5823 | store_entry.scope_user_id = scope_user_id | |
5824 | store_entry.scope_repo_id = scope_repo_id |
|
5824 | store_entry.scope_repo_id = scope_repo_id | |
5825 | store_entry.scope_repo_group_id = scope_repo_group_id |
|
5825 | store_entry.scope_repo_group_id = scope_repo_group_id | |
5826 |
|
5826 | |||
5827 | return store_entry |
|
5827 | return store_entry | |
5828 |
|
5828 | |||
5829 | @classmethod |
|
5829 | @classmethod | |
5830 | def store_metadata(cls, file_store_id, args, commit=True): |
|
5830 | def store_metadata(cls, file_store_id, args, commit=True): | |
5831 | file_store = FileStore.get(file_store_id) |
|
5831 | file_store = FileStore.get(file_store_id) | |
5832 | if file_store is None: |
|
5832 | if file_store is None: | |
5833 | return |
|
5833 | return | |
5834 |
|
5834 | |||
5835 | for section, key, value, value_type in args: |
|
5835 | for section, key, value, value_type in args: | |
5836 | has_key = FileStoreMetadata().query() \ |
|
5836 | has_key = FileStoreMetadata().query() \ | |
5837 | .filter(FileStoreMetadata.file_store_id == file_store.file_store_id) \ |
|
5837 | .filter(FileStoreMetadata.file_store_id == file_store.file_store_id) \ | |
5838 | .filter(FileStoreMetadata.file_store_meta_section == section) \ |
|
5838 | .filter(FileStoreMetadata.file_store_meta_section == section) \ | |
5839 | .filter(FileStoreMetadata.file_store_meta_key == key) \ |
|
5839 | .filter(FileStoreMetadata.file_store_meta_key == key) \ | |
5840 | .scalar() |
|
5840 | .scalar() | |
5841 | if has_key: |
|
5841 | if has_key: | |
5842 | msg = 'key `{}` already defined under section `{}` for this file.'\ |
|
5842 | msg = 'key `{}` already defined under section `{}` for this file.'\ | |
5843 | .format(key, section) |
|
5843 | .format(key, section) | |
5844 | raise ArtifactMetadataDuplicate(msg, err_section=section, err_key=key) |
|
5844 | raise ArtifactMetadataDuplicate(msg, err_section=section, err_key=key) | |
5845 |
|
5845 | |||
5846 | # NOTE(marcink): raises ArtifactMetadataBadValueType |
|
5846 | # NOTE(marcink): raises ArtifactMetadataBadValueType | |
5847 | FileStoreMetadata.valid_value_type(value_type) |
|
5847 | FileStoreMetadata.valid_value_type(value_type) | |
5848 |
|
5848 | |||
5849 | meta_entry = FileStoreMetadata() |
|
5849 | meta_entry = FileStoreMetadata() | |
5850 | meta_entry.file_store = file_store |
|
5850 | meta_entry.file_store = file_store | |
5851 | meta_entry.file_store_meta_section = section |
|
5851 | meta_entry.file_store_meta_section = section | |
5852 | meta_entry.file_store_meta_key = key |
|
5852 | meta_entry.file_store_meta_key = key | |
5853 | meta_entry.file_store_meta_value_type = value_type |
|
5853 | meta_entry.file_store_meta_value_type = value_type | |
5854 | meta_entry.file_store_meta_value = value |
|
5854 | meta_entry.file_store_meta_value = value | |
5855 |
|
5855 | |||
5856 | Session().add(meta_entry) |
|
5856 | Session().add(meta_entry) | |
5857 |
|
5857 | |||
5858 | try: |
|
5858 | try: | |
5859 | if commit: |
|
5859 | if commit: | |
5860 | Session().commit() |
|
5860 | Session().commit() | |
5861 | except IntegrityError: |
|
5861 | except IntegrityError: | |
5862 | Session().rollback() |
|
5862 | Session().rollback() | |
5863 | raise ArtifactMetadataDuplicate('Duplicate section/key found for this file.') |
|
5863 | raise ArtifactMetadataDuplicate('Duplicate section/key found for this file.') | |
5864 |
|
5864 | |||
5865 | @classmethod |
|
5865 | @classmethod | |
5866 | def bump_access_counter(cls, file_uid, commit=True): |
|
5866 | def bump_access_counter(cls, file_uid, commit=True): | |
5867 | FileStore().query()\ |
|
5867 | FileStore().query()\ | |
5868 | .filter(FileStore.file_uid == file_uid)\ |
|
5868 | .filter(FileStore.file_uid == file_uid)\ | |
5869 | .update({FileStore.accessed_count: (FileStore.accessed_count + 1), |
|
5869 | .update({FileStore.accessed_count: (FileStore.accessed_count + 1), | |
5870 | FileStore.accessed_on: datetime.datetime.now()}) |
|
5870 | FileStore.accessed_on: datetime.datetime.now()}) | |
5871 | if commit: |
|
5871 | if commit: | |
5872 | Session().commit() |
|
5872 | Session().commit() | |
5873 |
|
5873 | |||
5874 | def __json__(self): |
|
5874 | def __json__(self): | |
5875 | data = { |
|
5875 | data = { | |
5876 | 'filename': self.file_display_name, |
|
5876 | 'filename': self.file_display_name, | |
5877 | 'filename_org': self.file_org_name, |
|
5877 | 'filename_org': self.file_org_name, | |
5878 | 'file_uid': self.file_uid, |
|
5878 | 'file_uid': self.file_uid, | |
5879 | 'description': self.file_description, |
|
5879 | 'description': self.file_description, | |
5880 | 'hidden': self.hidden, |
|
5880 | 'hidden': self.hidden, | |
5881 | 'size': self.file_size, |
|
5881 | 'size': self.file_size, | |
5882 | 'created_on': self.created_on, |
|
5882 | 'created_on': self.created_on, | |
5883 | 'uploaded_by': self.upload_user.get_api_data(details='basic'), |
|
5883 | 'uploaded_by': self.upload_user.get_api_data(details='basic'), | |
5884 | 'downloaded_times': self.accessed_count, |
|
5884 | 'downloaded_times': self.accessed_count, | |
5885 | 'sha256': self.file_hash, |
|
5885 | 'sha256': self.file_hash, | |
5886 | 'metadata': self.file_metadata, |
|
5886 | 'metadata': self.file_metadata, | |
5887 | } |
|
5887 | } | |
5888 |
|
5888 | |||
5889 | return data |
|
5889 | return data | |
5890 |
|
5890 | |||
5891 | def __repr__(self): |
|
5891 | def __repr__(self): | |
5892 | return f'<FileStore({self.file_store_id})>' |
|
5892 | return f'<FileStore({self.file_store_id})>' | |
5893 |
|
5893 | |||
5894 |
|
5894 | |||
5895 | class FileStoreMetadata(Base, BaseModel): |
|
5895 | class FileStoreMetadata(Base, BaseModel): | |
5896 | __tablename__ = 'file_store_metadata' |
|
5896 | __tablename__ = 'file_store_metadata' | |
5897 | __table_args__ = ( |
|
5897 | __table_args__ = ( | |
5898 | UniqueConstraint('file_store_id', 'file_store_meta_section_hash', 'file_store_meta_key_hash'), |
|
5898 | UniqueConstraint('file_store_id', 'file_store_meta_section_hash', 'file_store_meta_key_hash'), | |
5899 | Index('file_store_meta_section_idx', 'file_store_meta_section', mysql_length=255), |
|
5899 | Index('file_store_meta_section_idx', 'file_store_meta_section', mysql_length=255), | |
5900 | Index('file_store_meta_key_idx', 'file_store_meta_key', mysql_length=255), |
|
5900 | Index('file_store_meta_key_idx', 'file_store_meta_key', mysql_length=255), | |
5901 | base_table_args |
|
5901 | base_table_args | |
5902 | ) |
|
5902 | ) | |
5903 | SETTINGS_TYPES = { |
|
5903 | SETTINGS_TYPES = { | |
5904 | 'str': safe_str, |
|
5904 | 'str': safe_str, | |
5905 | 'int': safe_int, |
|
5905 | 'int': safe_int, | |
5906 | 'unicode': safe_str, |
|
5906 | 'unicode': safe_str, | |
5907 | 'bool': str2bool, |
|
5907 | 'bool': str2bool, | |
5908 | 'list': functools.partial(aslist, sep=',') |
|
5908 | 'list': functools.partial(aslist, sep=',') | |
5909 | } |
|
5909 | } | |
5910 |
|
5910 | |||
5911 | file_store_meta_id = Column( |
|
5911 | file_store_meta_id = Column( | |
5912 | "file_store_meta_id", Integer(), nullable=False, unique=True, default=None, |
|
5912 | "file_store_meta_id", Integer(), nullable=False, unique=True, default=None, | |
5913 | primary_key=True) |
|
5913 | primary_key=True) | |
5914 | _file_store_meta_section = Column( |
|
5914 | _file_store_meta_section = Column( | |
5915 | "file_store_meta_section", UnicodeText().with_variant(UnicodeText(1024), 'mysql'), |
|
5915 | "file_store_meta_section", UnicodeText().with_variant(UnicodeText(1024), 'mysql'), | |
5916 | nullable=True, unique=None, default=None) |
|
5916 | nullable=True, unique=None, default=None) | |
5917 | _file_store_meta_section_hash = Column( |
|
5917 | _file_store_meta_section_hash = Column( | |
5918 | "file_store_meta_section_hash", String(255), |
|
5918 | "file_store_meta_section_hash", String(255), | |
5919 | nullable=True, unique=None, default=None) |
|
5919 | nullable=True, unique=None, default=None) | |
5920 | _file_store_meta_key = Column( |
|
5920 | _file_store_meta_key = Column( | |
5921 | "file_store_meta_key", UnicodeText().with_variant(UnicodeText(1024), 'mysql'), |
|
5921 | "file_store_meta_key", UnicodeText().with_variant(UnicodeText(1024), 'mysql'), | |
5922 | nullable=True, unique=None, default=None) |
|
5922 | nullable=True, unique=None, default=None) | |
5923 | _file_store_meta_key_hash = Column( |
|
5923 | _file_store_meta_key_hash = Column( | |
5924 | "file_store_meta_key_hash", String(255), nullable=True, unique=None, default=None) |
|
5924 | "file_store_meta_key_hash", String(255), nullable=True, unique=None, default=None) | |
5925 | _file_store_meta_value = Column( |
|
5925 | _file_store_meta_value = Column( | |
5926 | "file_store_meta_value", UnicodeText().with_variant(UnicodeText(20480), 'mysql'), |
|
5926 | "file_store_meta_value", UnicodeText().with_variant(UnicodeText(20480), 'mysql'), | |
5927 | nullable=True, unique=None, default=None) |
|
5927 | nullable=True, unique=None, default=None) | |
5928 | _file_store_meta_value_type = Column( |
|
5928 | _file_store_meta_value_type = Column( | |
5929 | "file_store_meta_value_type", String(255), nullable=True, unique=None, |
|
5929 | "file_store_meta_value_type", String(255), nullable=True, unique=None, | |
5930 | default='unicode') |
|
5930 | default='unicode') | |
5931 |
|
5931 | |||
5932 | file_store_id = Column( |
|
5932 | file_store_id = Column( | |
5933 | 'file_store_id', Integer(), ForeignKey('file_store.file_store_id'), |
|
5933 | 'file_store_id', Integer(), ForeignKey('file_store.file_store_id'), | |
5934 | nullable=True, unique=None, default=None) |
|
5934 | nullable=True, unique=None, default=None) | |
5935 |
|
5935 | |||
5936 | file_store = relationship('FileStore', lazy='joined', viewonly=True) |
|
5936 | file_store = relationship('FileStore', lazy='joined', viewonly=True) | |
5937 |
|
5937 | |||
5938 | @classmethod |
|
5938 | @classmethod | |
5939 | def valid_value_type(cls, value): |
|
5939 | def valid_value_type(cls, value): | |
5940 | if value.split('.')[0] not in cls.SETTINGS_TYPES: |
|
5940 | if value.split('.')[0] not in cls.SETTINGS_TYPES: | |
5941 | raise ArtifactMetadataBadValueType( |
|
5941 | raise ArtifactMetadataBadValueType( | |
5942 | 'value_type must be one of %s got %s' % (cls.SETTINGS_TYPES.keys(), value)) |
|
5942 | 'value_type must be one of %s got %s' % (cls.SETTINGS_TYPES.keys(), value)) | |
5943 |
|
5943 | |||
5944 | @hybrid_property |
|
5944 | @hybrid_property | |
5945 | def file_store_meta_section(self): |
|
5945 | def file_store_meta_section(self): | |
5946 | return self._file_store_meta_section |
|
5946 | return self._file_store_meta_section | |
5947 |
|
5947 | |||
5948 | @file_store_meta_section.setter |
|
5948 | @file_store_meta_section.setter | |
5949 | def file_store_meta_section(self, value): |
|
5949 | def file_store_meta_section(self, value): | |
5950 | self._file_store_meta_section = value |
|
5950 | self._file_store_meta_section = value | |
5951 | self._file_store_meta_section_hash = _hash_key(value) |
|
5951 | self._file_store_meta_section_hash = _hash_key(value) | |
5952 |
|
5952 | |||
5953 | @hybrid_property |
|
5953 | @hybrid_property | |
5954 | def file_store_meta_key(self): |
|
5954 | def file_store_meta_key(self): | |
5955 | return self._file_store_meta_key |
|
5955 | return self._file_store_meta_key | |
5956 |
|
5956 | |||
5957 | @file_store_meta_key.setter |
|
5957 | @file_store_meta_key.setter | |
5958 | def file_store_meta_key(self, value): |
|
5958 | def file_store_meta_key(self, value): | |
5959 | self._file_store_meta_key = value |
|
5959 | self._file_store_meta_key = value | |
5960 | self._file_store_meta_key_hash = _hash_key(value) |
|
5960 | self._file_store_meta_key_hash = _hash_key(value) | |
5961 |
|
5961 | |||
5962 | @hybrid_property |
|
5962 | @hybrid_property | |
5963 | def file_store_meta_value(self): |
|
5963 | def file_store_meta_value(self): | |
5964 | val = self._file_store_meta_value |
|
5964 | val = self._file_store_meta_value | |
5965 |
|
5965 | |||
5966 | if self._file_store_meta_value_type: |
|
5966 | if self._file_store_meta_value_type: | |
5967 | # e.g unicode.encrypted == unicode |
|
5967 | # e.g unicode.encrypted == unicode | |
5968 | _type = self._file_store_meta_value_type.split('.')[0] |
|
5968 | _type = self._file_store_meta_value_type.split('.')[0] | |
5969 | # decode the encrypted value if it's encrypted field type |
|
5969 | # decode the encrypted value if it's encrypted field type | |
5970 | if '.encrypted' in self._file_store_meta_value_type: |
|
5970 | if '.encrypted' in self._file_store_meta_value_type: | |
5971 | cipher = EncryptedTextValue() |
|
5971 | cipher = EncryptedTextValue() | |
5972 | val = safe_str(cipher.process_result_value(val, None)) |
|
5972 | val = safe_str(cipher.process_result_value(val, None)) | |
5973 | # do final type conversion |
|
5973 | # do final type conversion | |
5974 | converter = self.SETTINGS_TYPES.get(_type) or self.SETTINGS_TYPES['unicode'] |
|
5974 | converter = self.SETTINGS_TYPES.get(_type) or self.SETTINGS_TYPES['unicode'] | |
5975 | val = converter(val) |
|
5975 | val = converter(val) | |
5976 |
|
5976 | |||
5977 | return val |
|
5977 | return val | |
5978 |
|
5978 | |||
5979 | @file_store_meta_value.setter |
|
5979 | @file_store_meta_value.setter | |
5980 | def file_store_meta_value(self, val): |
|
5980 | def file_store_meta_value(self, val): | |
5981 | val = safe_str(val) |
|
5981 | val = safe_str(val) | |
5982 | # encode the encrypted value |
|
5982 | # encode the encrypted value | |
5983 | if '.encrypted' in self.file_store_meta_value_type: |
|
5983 | if '.encrypted' in self.file_store_meta_value_type: | |
5984 | cipher = EncryptedTextValue() |
|
5984 | cipher = EncryptedTextValue() | |
5985 | val = safe_str(cipher.process_bind_param(val, None)) |
|
5985 | val = safe_str(cipher.process_bind_param(val, None)) | |
5986 | self._file_store_meta_value = val |
|
5986 | self._file_store_meta_value = val | |
5987 |
|
5987 | |||
5988 | @hybrid_property |
|
5988 | @hybrid_property | |
5989 | def file_store_meta_value_type(self): |
|
5989 | def file_store_meta_value_type(self): | |
5990 | return self._file_store_meta_value_type |
|
5990 | return self._file_store_meta_value_type | |
5991 |
|
5991 | |||
5992 | @file_store_meta_value_type.setter |
|
5992 | @file_store_meta_value_type.setter | |
5993 | def file_store_meta_value_type(self, val): |
|
5993 | def file_store_meta_value_type(self, val): | |
5994 | # e.g unicode.encrypted |
|
5994 | # e.g unicode.encrypted | |
5995 | self.valid_value_type(val) |
|
5995 | self.valid_value_type(val) | |
5996 | self._file_store_meta_value_type = val |
|
5996 | self._file_store_meta_value_type = val | |
5997 |
|
5997 | |||
5998 | def __json__(self): |
|
5998 | def __json__(self): | |
5999 | data = { |
|
5999 | data = { | |
6000 | 'artifact': self.file_store.file_uid, |
|
6000 | 'artifact': self.file_store.file_uid, | |
6001 | 'section': self.file_store_meta_section, |
|
6001 | 'section': self.file_store_meta_section, | |
6002 | 'key': self.file_store_meta_key, |
|
6002 | 'key': self.file_store_meta_key, | |
6003 | 'value': self.file_store_meta_value, |
|
6003 | 'value': self.file_store_meta_value, | |
6004 | } |
|
6004 | } | |
6005 |
|
6005 | |||
6006 | return data |
|
6006 | return data | |
6007 |
|
6007 | |||
6008 | def __repr__(self): |
|
6008 | def __repr__(self): | |
6009 | return '<%s[%s]%s=>%s]>' % (self.cls_name, self.file_store_meta_section, |
|
6009 | return '<%s[%s]%s=>%s]>' % (self.cls_name, self.file_store_meta_section, | |
6010 | self.file_store_meta_key, self.file_store_meta_value) |
|
6010 | self.file_store_meta_key, self.file_store_meta_value) | |
6011 |
|
6011 | |||
6012 |
|
6012 | |||
6013 | class DbMigrateVersion(Base, BaseModel): |
|
6013 | class DbMigrateVersion(Base, BaseModel): | |
6014 | __tablename__ = 'db_migrate_version' |
|
6014 | __tablename__ = 'db_migrate_version' | |
6015 | __table_args__ = ( |
|
6015 | __table_args__ = ( | |
6016 | base_table_args, |
|
6016 | base_table_args, | |
6017 | ) |
|
6017 | ) | |
6018 |
|
6018 | |||
6019 | repository_id = Column('repository_id', String(250), primary_key=True) |
|
6019 | repository_id = Column('repository_id', String(250), primary_key=True) | |
6020 | repository_path = Column('repository_path', Text) |
|
6020 | repository_path = Column('repository_path', Text) | |
6021 | version = Column('version', Integer) |
|
6021 | version = Column('version', Integer) | |
6022 |
|
6022 | |||
6023 | @classmethod |
|
6023 | @classmethod | |
6024 | def set_version(cls, version): |
|
6024 | def set_version(cls, version): | |
6025 | """ |
|
6025 | """ | |
6026 | Helper for forcing a different version, usually for debugging purposes via ishell. |
|
6026 | Helper for forcing a different version, usually for debugging purposes via ishell. | |
6027 | """ |
|
6027 | """ | |
6028 | ver = DbMigrateVersion.query().first() |
|
6028 | ver = DbMigrateVersion.query().first() | |
6029 | ver.version = version |
|
6029 | ver.version = version | |
6030 | Session().commit() |
|
6030 | Session().commit() | |
6031 |
|
6031 | |||
6032 |
|
6032 | |||
6033 | class DbSession(Base, BaseModel): |
|
6033 | class DbSession(Base, BaseModel): | |
6034 | __tablename__ = 'db_session' |
|
6034 | __tablename__ = 'db_session' | |
6035 | __table_args__ = ( |
|
6035 | __table_args__ = ( | |
6036 | base_table_args, |
|
6036 | base_table_args, | |
6037 | ) |
|
6037 | ) | |
6038 |
|
6038 | |||
6039 | def __repr__(self): |
|
6039 | def __repr__(self): | |
6040 | return f'<DB:DbSession({self.id})>' |
|
6040 | return f'<DB:DbSession({self.id})>' | |
6041 |
|
6041 | |||
6042 | id = Column('id', Integer()) |
|
6042 | id = Column('id', Integer()) | |
6043 | namespace = Column('namespace', String(255), primary_key=True) |
|
6043 | namespace = Column('namespace', String(255), primary_key=True) | |
6044 | accessed = Column('accessed', DateTime, nullable=False) |
|
6044 | accessed = Column('accessed', DateTime, nullable=False) | |
6045 | created = Column('created', DateTime, nullable=False) |
|
6045 | created = Column('created', DateTime, nullable=False) | |
6046 | data = Column('data', PickleType, nullable=False) |
|
6046 | data = Column('data', PickleType, nullable=False) |
General Comments 0
You need to be logged in to leave comments.
Login now