Show More
This diff has been collapsed as it changes many lines, (4759 lines changed) Show them Hide them | |||
@@ -0,0 +1,4759 b'' | |||
|
1 | # -*- coding: utf-8 -*- | |
|
2 | ||
|
3 | # Copyright (C) 2010-2019 RhodeCode GmbH | |
|
4 | # | |
|
5 | # This program is free software: you can redistribute it and/or modify | |
|
6 | # it under the terms of the GNU Affero General Public License, version 3 | |
|
7 | # (only), as published by the Free Software Foundation. | |
|
8 | # | |
|
9 | # This program is distributed in the hope that it will be useful, | |
|
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
|
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
|
12 | # GNU General Public License for more details. | |
|
13 | # | |
|
14 | # You should have received a copy of the GNU Affero General Public License | |
|
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
|
16 | # | |
|
17 | # This program is dual-licensed. If you wish to learn more about the | |
|
18 | # RhodeCode Enterprise Edition, including its added features, Support services, | |
|
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ | |
|
20 | ||
|
21 | """ | |
|
22 | Database Models for RhodeCode Enterprise | |
|
23 | """ | |
|
24 | ||
|
25 | import re | |
|
26 | import os | |
|
27 | import time | |
|
28 | import hashlib | |
|
29 | import logging | |
|
30 | import datetime | |
|
31 | import warnings | |
|
32 | import ipaddress | |
|
33 | import functools | |
|
34 | import traceback | |
|
35 | import collections | |
|
36 | ||
|
37 | from sqlalchemy import ( | |
|
38 | or_, and_, not_, func, TypeDecorator, event, | |
|
39 | Index, Sequence, UniqueConstraint, ForeignKey, CheckConstraint, Column, | |
|
40 | Boolean, String, Unicode, UnicodeText, DateTime, Integer, LargeBinary, | |
|
41 | Text, Float, PickleType) | |
|
42 | from sqlalchemy.sql.expression import true, false | |
|
43 | from sqlalchemy.sql.functions import coalesce, count # pragma: no cover | |
|
44 | from sqlalchemy.orm import ( | |
|
45 | relationship, joinedload, class_mapper, validates, aliased) | |
|
46 | from sqlalchemy.ext.declarative import declared_attr | |
|
47 | from sqlalchemy.ext.hybrid import hybrid_property | |
|
48 | from sqlalchemy.exc import IntegrityError # pragma: no cover | |
|
49 | from sqlalchemy.dialects.mysql import LONGTEXT | |
|
50 | from zope.cachedescriptors.property import Lazy as LazyProperty | |
|
51 | ||
|
52 | from pyramid.threadlocal import get_current_request | |
|
53 | ||
|
54 | from rhodecode.translation import _ | |
|
55 | from rhodecode.lib.vcs import get_vcs_instance | |
|
56 | from rhodecode.lib.vcs.backends.base import EmptyCommit, Reference | |
|
57 | from rhodecode.lib.utils2 import ( | |
|
58 | str2bool, safe_str, get_commit_safe, safe_unicode, sha1_safe, | |
|
59 | time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict, | |
|
60 | glob2re, StrictAttributeDict, cleaned_uri) | |
|
61 | from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType, \ | |
|
62 | JsonRaw | |
|
63 | from rhodecode.lib.ext_json import json | |
|
64 | from rhodecode.lib.caching_query import FromCache | |
|
65 | from rhodecode.lib.encrypt import AESCipher | |
|
66 | ||
|
67 | from rhodecode.model.meta import Base, Session | |
|
68 | ||
|
69 | URL_SEP = '/' | |
|
70 | log = logging.getLogger(__name__) | |
|
71 | ||
|
72 | # ============================================================================= | |
|
73 | # BASE CLASSES | |
|
74 | # ============================================================================= | |
|
75 | ||
|
76 | # this is propagated from .ini file rhodecode.encrypted_values.secret or | |
|
77 | # beaker.session.secret if first is not set. | |
|
78 | # and initialized at environment.py | |
|
79 | ENCRYPTION_KEY = None | |
|
80 | ||
|
81 | # used to sort permissions by types, '#' used here is not allowed to be in | |
|
82 | # usernames, and it's very early in sorted string.printable table. | |
|
83 | PERMISSION_TYPE_SORT = { | |
|
84 | 'admin': '####', | |
|
85 | 'write': '###', | |
|
86 | 'read': '##', | |
|
87 | 'none': '#', | |
|
88 | } | |
|
89 | ||
|
90 | ||
|
91 | def display_user_sort(obj): | |
|
92 | """ | |
|
93 | Sort function used to sort permissions in .permissions() function of | |
|
94 | Repository, RepoGroup, UserGroup. Also it put the default user in front | |
|
95 | of all other resources | |
|
96 | """ | |
|
97 | ||
|
98 | if obj.username == User.DEFAULT_USER: | |
|
99 | return '#####' | |
|
100 | prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '') | |
|
101 | return prefix + obj.username | |
|
102 | ||
|
103 | ||
|
104 | def display_user_group_sort(obj): | |
|
105 | """ | |
|
106 | Sort function used to sort permissions in .permissions() function of | |
|
107 | Repository, RepoGroup, UserGroup. Also it put the default user in front | |
|
108 | of all other resources | |
|
109 | """ | |
|
110 | ||
|
111 | prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '') | |
|
112 | return prefix + obj.users_group_name | |
|
113 | ||
|
114 | ||
|
115 | def _hash_key(k): | |
|
116 | return sha1_safe(k) | |
|
117 | ||
|
118 | ||
|
119 | def in_filter_generator(qry, items, limit=500): | |
|
120 | """ | |
|
121 | Splits IN() into multiple with OR | |
|
122 | e.g.:: | |
|
123 | cnt = Repository.query().filter( | |
|
124 | or_( | |
|
125 | *in_filter_generator(Repository.repo_id, range(100000)) | |
|
126 | )).count() | |
|
127 | """ | |
|
128 | if not items: | |
|
129 | # empty list will cause empty query which might cause security issues | |
|
130 | # this can lead to hidden unpleasant results | |
|
131 | items = [-1] | |
|
132 | ||
|
133 | parts = [] | |
|
134 | for chunk in xrange(0, len(items), limit): | |
|
135 | parts.append( | |
|
136 | qry.in_(items[chunk: chunk + limit]) | |
|
137 | ) | |
|
138 | ||
|
139 | return parts | |
|
140 | ||
|
141 | ||
|
142 | base_table_args = { | |
|
143 | 'extend_existing': True, | |
|
144 | 'mysql_engine': 'InnoDB', | |
|
145 | 'mysql_charset': 'utf8', | |
|
146 | 'sqlite_autoincrement': True | |
|
147 | } | |
|
148 | ||
|
149 | ||
|
150 | class EncryptedTextValue(TypeDecorator): | |
|
151 | """ | |
|
152 | Special column for encrypted long text data, use like:: | |
|
153 | ||
|
154 | value = Column("encrypted_value", EncryptedValue(), nullable=False) | |
|
155 | ||
|
156 | This column is intelligent so if value is in unencrypted form it return | |
|
157 | unencrypted form, but on save it always encrypts | |
|
158 | """ | |
|
159 | impl = Text | |
|
160 | ||
|
161 | def process_bind_param(self, value, dialect): | |
|
162 | if not value: | |
|
163 | return value | |
|
164 | if value.startswith('enc$aes$') or value.startswith('enc$aes_hmac$'): | |
|
165 | # protect against double encrypting if someone manually starts | |
|
166 | # doing | |
|
167 | raise ValueError('value needs to be in unencrypted format, ie. ' | |
|
168 | 'not starting with enc$aes') | |
|
169 | return 'enc$aes_hmac$%s' % AESCipher( | |
|
170 | ENCRYPTION_KEY, hmac=True).encrypt(value) | |
|
171 | ||
|
172 | def process_result_value(self, value, dialect): | |
|
173 | import rhodecode | |
|
174 | ||
|
175 | if not value: | |
|
176 | return value | |
|
177 | ||
|
178 | parts = value.split('$', 3) | |
|
179 | if not len(parts) == 3: | |
|
180 | # probably not encrypted values | |
|
181 | return value | |
|
182 | else: | |
|
183 | if parts[0] != 'enc': | |
|
184 | # parts ok but without our header ? | |
|
185 | return value | |
|
186 | enc_strict_mode = str2bool(rhodecode.CONFIG.get( | |
|
187 | 'rhodecode.encrypted_values.strict') or True) | |
|
188 | # at that stage we know it's our encryption | |
|
189 | if parts[1] == 'aes': | |
|
190 | decrypted_data = AESCipher(ENCRYPTION_KEY).decrypt(parts[2]) | |
|
191 | elif parts[1] == 'aes_hmac': | |
|
192 | decrypted_data = AESCipher( | |
|
193 | ENCRYPTION_KEY, hmac=True, | |
|
194 | strict_verification=enc_strict_mode).decrypt(parts[2]) | |
|
195 | else: | |
|
196 | raise ValueError( | |
|
197 | 'Encryption type part is wrong, must be `aes` ' | |
|
198 | 'or `aes_hmac`, got `%s` instead' % (parts[1])) | |
|
199 | return decrypted_data | |
|
200 | ||
|
201 | ||
|
202 | class BaseModel(object): | |
|
203 | """ | |
|
204 | Base Model for all classes | |
|
205 | """ | |
|
206 | ||
|
207 | @classmethod | |
|
208 | def _get_keys(cls): | |
|
209 | """return column names for this model """ | |
|
210 | return class_mapper(cls).c.keys() | |
|
211 | ||
|
212 | def get_dict(self): | |
|
213 | """ | |
|
214 | return dict with keys and values corresponding | |
|
215 | to this model data """ | |
|
216 | ||
|
217 | d = {} | |
|
218 | for k in self._get_keys(): | |
|
219 | d[k] = getattr(self, k) | |
|
220 | ||
|
221 | # also use __json__() if present to get additional fields | |
|
222 | _json_attr = getattr(self, '__json__', None) | |
|
223 | if _json_attr: | |
|
224 | # update with attributes from __json__ | |
|
225 | if callable(_json_attr): | |
|
226 | _json_attr = _json_attr() | |
|
227 | for k, val in _json_attr.iteritems(): | |
|
228 | d[k] = val | |
|
229 | return d | |
|
230 | ||
|
231 | def get_appstruct(self): | |
|
232 | """return list with keys and values tuples corresponding | |
|
233 | to this model data """ | |
|
234 | ||
|
235 | lst = [] | |
|
236 | for k in self._get_keys(): | |
|
237 | lst.append((k, getattr(self, k),)) | |
|
238 | return lst | |
|
239 | ||
|
240 | def populate_obj(self, populate_dict): | |
|
241 | """populate model with data from given populate_dict""" | |
|
242 | ||
|
243 | for k in self._get_keys(): | |
|
244 | if k in populate_dict: | |
|
245 | setattr(self, k, populate_dict[k]) | |
|
246 | ||
|
247 | @classmethod | |
|
248 | def query(cls): | |
|
249 | return Session().query(cls) | |
|
250 | ||
|
251 | @classmethod | |
|
252 | def get(cls, id_): | |
|
253 | if id_: | |
|
254 | return cls.query().get(id_) | |
|
255 | ||
|
256 | @classmethod | |
|
257 | def get_or_404(cls, id_): | |
|
258 | from pyramid.httpexceptions import HTTPNotFound | |
|
259 | ||
|
260 | try: | |
|
261 | id_ = int(id_) | |
|
262 | except (TypeError, ValueError): | |
|
263 | raise HTTPNotFound() | |
|
264 | ||
|
265 | res = cls.query().get(id_) | |
|
266 | if not res: | |
|
267 | raise HTTPNotFound() | |
|
268 | return res | |
|
269 | ||
|
270 | @classmethod | |
|
271 | def getAll(cls): | |
|
272 | # deprecated and left for backward compatibility | |
|
273 | return cls.get_all() | |
|
274 | ||
|
275 | @classmethod | |
|
276 | def get_all(cls): | |
|
277 | return cls.query().all() | |
|
278 | ||
|
279 | @classmethod | |
|
280 | def delete(cls, id_): | |
|
281 | obj = cls.query().get(id_) | |
|
282 | Session().delete(obj) | |
|
283 | ||
|
284 | @classmethod | |
|
285 | def identity_cache(cls, session, attr_name, value): | |
|
286 | exist_in_session = [] | |
|
287 | for (item_cls, pkey), instance in session.identity_map.items(): | |
|
288 | if cls == item_cls and getattr(instance, attr_name) == value: | |
|
289 | exist_in_session.append(instance) | |
|
290 | if exist_in_session: | |
|
291 | if len(exist_in_session) == 1: | |
|
292 | return exist_in_session[0] | |
|
293 | log.exception( | |
|
294 | 'multiple objects with attr %s and ' | |
|
295 | 'value %s found with same name: %r', | |
|
296 | attr_name, value, exist_in_session) | |
|
297 | ||
|
298 | def __repr__(self): | |
|
299 | if hasattr(self, '__unicode__'): | |
|
300 | # python repr needs to return str | |
|
301 | try: | |
|
302 | return safe_str(self.__unicode__()) | |
|
303 | except UnicodeDecodeError: | |
|
304 | pass | |
|
305 | return '<DB:%s>' % (self.__class__.__name__) | |
|
306 | ||
|
307 | ||
|
308 | class RhodeCodeSetting(Base, BaseModel): | |
|
309 | __tablename__ = 'rhodecode_settings' | |
|
310 | __table_args__ = ( | |
|
311 | UniqueConstraint('app_settings_name'), | |
|
312 | base_table_args | |
|
313 | ) | |
|
314 | ||
|
315 | SETTINGS_TYPES = { | |
|
316 | 'str': safe_str, | |
|
317 | 'int': safe_int, | |
|
318 | 'unicode': safe_unicode, | |
|
319 | 'bool': str2bool, | |
|
320 | 'list': functools.partial(aslist, sep=',') | |
|
321 | } | |
|
322 | DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions' | |
|
323 | GLOBAL_CONF_KEY = 'app_settings' | |
|
324 | ||
|
325 | app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
326 | app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None) | |
|
327 | _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None) | |
|
328 | _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None) | |
|
329 | ||
|
330 | def __init__(self, key='', val='', type='unicode'): | |
|
331 | self.app_settings_name = key | |
|
332 | self.app_settings_type = type | |
|
333 | self.app_settings_value = val | |
|
334 | ||
|
335 | @validates('_app_settings_value') | |
|
336 | def validate_settings_value(self, key, val): | |
|
337 | assert type(val) == unicode | |
|
338 | return val | |
|
339 | ||
|
340 | @hybrid_property | |
|
341 | def app_settings_value(self): | |
|
342 | v = self._app_settings_value | |
|
343 | _type = self.app_settings_type | |
|
344 | if _type: | |
|
345 | _type = self.app_settings_type.split('.')[0] | |
|
346 | # decode the encrypted value | |
|
347 | if 'encrypted' in self.app_settings_type: | |
|
348 | cipher = EncryptedTextValue() | |
|
349 | v = safe_unicode(cipher.process_result_value(v, None)) | |
|
350 | ||
|
351 | converter = self.SETTINGS_TYPES.get(_type) or \ | |
|
352 | self.SETTINGS_TYPES['unicode'] | |
|
353 | return converter(v) | |
|
354 | ||
|
355 | @app_settings_value.setter | |
|
356 | def app_settings_value(self, val): | |
|
357 | """ | |
|
358 | Setter that will always make sure we use unicode in app_settings_value | |
|
359 | ||
|
360 | :param val: | |
|
361 | """ | |
|
362 | val = safe_unicode(val) | |
|
363 | # encode the encrypted value | |
|
364 | if 'encrypted' in self.app_settings_type: | |
|
365 | cipher = EncryptedTextValue() | |
|
366 | val = safe_unicode(cipher.process_bind_param(val, None)) | |
|
367 | self._app_settings_value = val | |
|
368 | ||
|
369 | @hybrid_property | |
|
370 | def app_settings_type(self): | |
|
371 | return self._app_settings_type | |
|
372 | ||
|
373 | @app_settings_type.setter | |
|
374 | def app_settings_type(self, val): | |
|
375 | if val.split('.')[0] not in self.SETTINGS_TYPES: | |
|
376 | raise Exception('type must be one of %s got %s' | |
|
377 | % (self.SETTINGS_TYPES.keys(), val)) | |
|
378 | self._app_settings_type = val | |
|
379 | ||
|
380 | @classmethod | |
|
381 | def get_by_prefix(cls, prefix): | |
|
382 | return RhodeCodeSetting.query()\ | |
|
383 | .filter(RhodeCodeSetting.app_settings_name.startswith(prefix))\ | |
|
384 | .all() | |
|
385 | ||
|
386 | def __unicode__(self): | |
|
387 | return u"<%s('%s:%s[%s]')>" % ( | |
|
388 | self.__class__.__name__, | |
|
389 | self.app_settings_name, self.app_settings_value, | |
|
390 | self.app_settings_type | |
|
391 | ) | |
|
392 | ||
|
393 | ||
|
394 | class RhodeCodeUi(Base, BaseModel): | |
|
395 | __tablename__ = 'rhodecode_ui' | |
|
396 | __table_args__ = ( | |
|
397 | UniqueConstraint('ui_key'), | |
|
398 | base_table_args | |
|
399 | ) | |
|
400 | ||
|
401 | HOOK_REPO_SIZE = 'changegroup.repo_size' | |
|
402 | # HG | |
|
403 | HOOK_PRE_PULL = 'preoutgoing.pre_pull' | |
|
404 | HOOK_PULL = 'outgoing.pull_logger' | |
|
405 | HOOK_PRE_PUSH = 'prechangegroup.pre_push' | |
|
406 | HOOK_PRETX_PUSH = 'pretxnchangegroup.pre_push' | |
|
407 | HOOK_PUSH = 'changegroup.push_logger' | |
|
408 | HOOK_PUSH_KEY = 'pushkey.key_push' | |
|
409 | ||
|
410 | # TODO: johbo: Unify way how hooks are configured for git and hg, | |
|
411 | # git part is currently hardcoded. | |
|
412 | ||
|
413 | # SVN PATTERNS | |
|
414 | SVN_BRANCH_ID = 'vcs_svn_branch' | |
|
415 | SVN_TAG_ID = 'vcs_svn_tag' | |
|
416 | ||
|
417 | ui_id = Column( | |
|
418 | "ui_id", Integer(), nullable=False, unique=True, default=None, | |
|
419 | primary_key=True) | |
|
420 | ui_section = Column( | |
|
421 | "ui_section", String(255), nullable=True, unique=None, default=None) | |
|
422 | ui_key = Column( | |
|
423 | "ui_key", String(255), nullable=True, unique=None, default=None) | |
|
424 | ui_value = Column( | |
|
425 | "ui_value", String(255), nullable=True, unique=None, default=None) | |
|
426 | ui_active = Column( | |
|
427 | "ui_active", Boolean(), nullable=True, unique=None, default=True) | |
|
428 | ||
|
429 | def __repr__(self): | |
|
430 | return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section, | |
|
431 | self.ui_key, self.ui_value) | |
|
432 | ||
|
433 | ||
|
434 | class RepoRhodeCodeSetting(Base, BaseModel): | |
|
435 | __tablename__ = 'repo_rhodecode_settings' | |
|
436 | __table_args__ = ( | |
|
437 | UniqueConstraint( | |
|
438 | 'app_settings_name', 'repository_id', | |
|
439 | name='uq_repo_rhodecode_setting_name_repo_id'), | |
|
440 | base_table_args | |
|
441 | ) | |
|
442 | ||
|
443 | repository_id = Column( | |
|
444 | "repository_id", Integer(), ForeignKey('repositories.repo_id'), | |
|
445 | nullable=False) | |
|
446 | app_settings_id = Column( | |
|
447 | "app_settings_id", Integer(), nullable=False, unique=True, | |
|
448 | default=None, primary_key=True) | |
|
449 | app_settings_name = Column( | |
|
450 | "app_settings_name", String(255), nullable=True, unique=None, | |
|
451 | default=None) | |
|
452 | _app_settings_value = Column( | |
|
453 | "app_settings_value", String(4096), nullable=True, unique=None, | |
|
454 | default=None) | |
|
455 | _app_settings_type = Column( | |
|
456 | "app_settings_type", String(255), nullable=True, unique=None, | |
|
457 | default=None) | |
|
458 | ||
|
459 | repository = relationship('Repository') | |
|
460 | ||
|
461 | def __init__(self, repository_id, key='', val='', type='unicode'): | |
|
462 | self.repository_id = repository_id | |
|
463 | self.app_settings_name = key | |
|
464 | self.app_settings_type = type | |
|
465 | self.app_settings_value = val | |
|
466 | ||
|
467 | @validates('_app_settings_value') | |
|
468 | def validate_settings_value(self, key, val): | |
|
469 | assert type(val) == unicode | |
|
470 | return val | |
|
471 | ||
|
472 | @hybrid_property | |
|
473 | def app_settings_value(self): | |
|
474 | v = self._app_settings_value | |
|
475 | type_ = self.app_settings_type | |
|
476 | SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES | |
|
477 | converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode'] | |
|
478 | return converter(v) | |
|
479 | ||
|
480 | @app_settings_value.setter | |
|
481 | def app_settings_value(self, val): | |
|
482 | """ | |
|
483 | Setter that will always make sure we use unicode in app_settings_value | |
|
484 | ||
|
485 | :param val: | |
|
486 | """ | |
|
487 | self._app_settings_value = safe_unicode(val) | |
|
488 | ||
|
489 | @hybrid_property | |
|
490 | def app_settings_type(self): | |
|
491 | return self._app_settings_type | |
|
492 | ||
|
493 | @app_settings_type.setter | |
|
494 | def app_settings_type(self, val): | |
|
495 | SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES | |
|
496 | if val not in SETTINGS_TYPES: | |
|
497 | raise Exception('type must be one of %s got %s' | |
|
498 | % (SETTINGS_TYPES.keys(), val)) | |
|
499 | self._app_settings_type = val | |
|
500 | ||
|
501 | def __unicode__(self): | |
|
502 | return u"<%s('%s:%s:%s[%s]')>" % ( | |
|
503 | self.__class__.__name__, self.repository.repo_name, | |
|
504 | self.app_settings_name, self.app_settings_value, | |
|
505 | self.app_settings_type | |
|
506 | ) | |
|
507 | ||
|
508 | ||
|
509 | class RepoRhodeCodeUi(Base, BaseModel): | |
|
510 | __tablename__ = 'repo_rhodecode_ui' | |
|
511 | __table_args__ = ( | |
|
512 | UniqueConstraint( | |
|
513 | 'repository_id', 'ui_section', 'ui_key', | |
|
514 | name='uq_repo_rhodecode_ui_repository_id_section_key'), | |
|
515 | base_table_args | |
|
516 | ) | |
|
517 | ||
|
518 | repository_id = Column( | |
|
519 | "repository_id", Integer(), ForeignKey('repositories.repo_id'), | |
|
520 | nullable=False) | |
|
521 | ui_id = Column( | |
|
522 | "ui_id", Integer(), nullable=False, unique=True, default=None, | |
|
523 | primary_key=True) | |
|
524 | ui_section = Column( | |
|
525 | "ui_section", String(255), nullable=True, unique=None, default=None) | |
|
526 | ui_key = Column( | |
|
527 | "ui_key", String(255), nullable=True, unique=None, default=None) | |
|
528 | ui_value = Column( | |
|
529 | "ui_value", String(255), nullable=True, unique=None, default=None) | |
|
530 | ui_active = Column( | |
|
531 | "ui_active", Boolean(), nullable=True, unique=None, default=True) | |
|
532 | ||
|
533 | repository = relationship('Repository') | |
|
534 | ||
|
535 | def __repr__(self): | |
|
536 | return '<%s[%s:%s]%s=>%s]>' % ( | |
|
537 | self.__class__.__name__, self.repository.repo_name, | |
|
538 | self.ui_section, self.ui_key, self.ui_value) | |
|
539 | ||
|
540 | ||
|
541 | class User(Base, BaseModel): | |
|
542 | __tablename__ = 'users' | |
|
543 | __table_args__ = ( | |
|
544 | UniqueConstraint('username'), UniqueConstraint('email'), | |
|
545 | Index('u_username_idx', 'username'), | |
|
546 | Index('u_email_idx', 'email'), | |
|
547 | base_table_args | |
|
548 | ) | |
|
549 | ||
|
550 | DEFAULT_USER = 'default' | |
|
551 | DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org' | |
|
552 | DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}' | |
|
553 | ||
|
554 | user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
555 | username = Column("username", String(255), nullable=True, unique=None, default=None) | |
|
556 | password = Column("password", String(255), nullable=True, unique=None, default=None) | |
|
557 | active = Column("active", Boolean(), nullable=True, unique=None, default=True) | |
|
558 | admin = Column("admin", Boolean(), nullable=True, unique=None, default=False) | |
|
559 | name = Column("firstname", String(255), nullable=True, unique=None, default=None) | |
|
560 | lastname = Column("lastname", String(255), nullable=True, unique=None, default=None) | |
|
561 | _email = Column("email", String(255), nullable=True, unique=None, default=None) | |
|
562 | last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None) | |
|
563 | last_activity = Column('last_activity', DateTime(timezone=False), nullable=True, unique=None, default=None) | |
|
564 | ||
|
565 | extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None) | |
|
566 | extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None) | |
|
567 | _api_key = Column("api_key", String(255), nullable=True, unique=None, default=None) | |
|
568 | inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True) | |
|
569 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
|
570 | _user_data = Column("user_data", LargeBinary(), nullable=True) # JSON data | |
|
571 | ||
|
572 | user_log = relationship('UserLog') | |
|
573 | user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all') | |
|
574 | ||
|
575 | repositories = relationship('Repository') | |
|
576 | repository_groups = relationship('RepoGroup') | |
|
577 | user_groups = relationship('UserGroup') | |
|
578 | ||
|
579 | user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all') | |
|
580 | followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all') | |
|
581 | ||
|
582 | repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all') | |
|
583 | repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all') | |
|
584 | user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all') | |
|
585 | ||
|
586 | group_member = relationship('UserGroupMember', cascade='all') | |
|
587 | ||
|
588 | notifications = relationship('UserNotification', cascade='all') | |
|
589 | # notifications assigned to this user | |
|
590 | user_created_notifications = relationship('Notification', cascade='all') | |
|
591 | # comments created by this user | |
|
592 | user_comments = relationship('ChangesetComment', cascade='all') | |
|
593 | # user profile extra info | |
|
594 | user_emails = relationship('UserEmailMap', cascade='all') | |
|
595 | user_ip_map = relationship('UserIpMap', cascade='all') | |
|
596 | user_auth_tokens = relationship('UserApiKeys', cascade='all') | |
|
597 | user_ssh_keys = relationship('UserSshKeys', cascade='all') | |
|
598 | ||
|
599 | # gists | |
|
600 | user_gists = relationship('Gist', cascade='all') | |
|
601 | # user pull requests | |
|
602 | user_pull_requests = relationship('PullRequest', cascade='all') | |
|
603 | # external identities | |
|
604 | extenal_identities = relationship( | |
|
605 | 'ExternalIdentity', | |
|
606 | primaryjoin="User.user_id==ExternalIdentity.local_user_id", | |
|
607 | cascade='all') | |
|
608 | # review rules | |
|
609 | user_review_rules = relationship('RepoReviewRuleUser', cascade='all') | |
|
610 | ||
|
611 | def __unicode__(self): | |
|
612 | return u"<%s('id:%s:%s')>" % (self.__class__.__name__, | |
|
613 | self.user_id, self.username) | |
|
614 | ||
|
615 | @hybrid_property | |
|
616 | def email(self): | |
|
617 | return self._email | |
|
618 | ||
|
619 | @email.setter | |
|
620 | def email(self, val): | |
|
621 | self._email = val.lower() if val else None | |
|
622 | ||
|
623 | @hybrid_property | |
|
624 | def first_name(self): | |
|
625 | from rhodecode.lib import helpers as h | |
|
626 | if self.name: | |
|
627 | return h.escape(self.name) | |
|
628 | return self.name | |
|
629 | ||
|
630 | @hybrid_property | |
|
631 | def last_name(self): | |
|
632 | from rhodecode.lib import helpers as h | |
|
633 | if self.lastname: | |
|
634 | return h.escape(self.lastname) | |
|
635 | return self.lastname | |
|
636 | ||
|
637 | @hybrid_property | |
|
638 | def api_key(self): | |
|
639 | """ | |
|
640 | Fetch if exist an auth-token with role ALL connected to this user | |
|
641 | """ | |
|
642 | user_auth_token = UserApiKeys.query()\ | |
|
643 | .filter(UserApiKeys.user_id == self.user_id)\ | |
|
644 | .filter(or_(UserApiKeys.expires == -1, | |
|
645 | UserApiKeys.expires >= time.time()))\ | |
|
646 | .filter(UserApiKeys.role == UserApiKeys.ROLE_ALL).first() | |
|
647 | if user_auth_token: | |
|
648 | user_auth_token = user_auth_token.api_key | |
|
649 | ||
|
650 | return user_auth_token | |
|
651 | ||
|
652 | @api_key.setter | |
|
653 | def api_key(self, val): | |
|
654 | # don't allow to set API key this is deprecated for now | |
|
655 | self._api_key = None | |
|
656 | ||
|
657 | @property | |
|
658 | def reviewer_pull_requests(self): | |
|
659 | return PullRequestReviewers.query() \ | |
|
660 | .options(joinedload(PullRequestReviewers.pull_request)) \ | |
|
661 | .filter(PullRequestReviewers.user_id == self.user_id) \ | |
|
662 | .all() | |
|
663 | ||
|
664 | @property | |
|
665 | def firstname(self): | |
|
666 | # alias for future | |
|
667 | return self.name | |
|
668 | ||
|
669 | @property | |
|
670 | def emails(self): | |
|
671 | other = UserEmailMap.query()\ | |
|
672 | .filter(UserEmailMap.user == self) \ | |
|
673 | .order_by(UserEmailMap.email_id.asc()) \ | |
|
674 | .all() | |
|
675 | return [self.email] + [x.email for x in other] | |
|
676 | ||
|
677 | @property | |
|
678 | def auth_tokens(self): | |
|
679 | auth_tokens = self.get_auth_tokens() | |
|
680 | return [x.api_key for x in auth_tokens] | |
|
681 | ||
|
682 | def get_auth_tokens(self): | |
|
683 | return UserApiKeys.query()\ | |
|
684 | .filter(UserApiKeys.user == self)\ | |
|
685 | .order_by(UserApiKeys.user_api_key_id.asc())\ | |
|
686 | .all() | |
|
687 | ||
|
688 | @LazyProperty | |
|
689 | def feed_token(self): | |
|
690 | return self.get_feed_token() | |
|
691 | ||
|
692 | def get_feed_token(self, cache=True): | |
|
693 | feed_tokens = UserApiKeys.query()\ | |
|
694 | .filter(UserApiKeys.user == self)\ | |
|
695 | .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED) | |
|
696 | if cache: | |
|
697 | feed_tokens = feed_tokens.options( | |
|
698 | FromCache("sql_cache_short", "get_user_feed_token_%s" % self.user_id)) | |
|
699 | ||
|
700 | feed_tokens = feed_tokens.all() | |
|
701 | if feed_tokens: | |
|
702 | return feed_tokens[0].api_key | |
|
703 | return 'NO_FEED_TOKEN_AVAILABLE' | |
|
704 | ||
|
705 | @classmethod | |
|
706 | def get(cls, user_id, cache=False): | |
|
707 | if not user_id: | |
|
708 | return | |
|
709 | ||
|
710 | user = cls.query() | |
|
711 | if cache: | |
|
712 | user = user.options( | |
|
713 | FromCache("sql_cache_short", "get_users_%s" % user_id)) | |
|
714 | return user.get(user_id) | |
|
715 | ||
|
716 | @classmethod | |
|
717 | def extra_valid_auth_tokens(cls, user, role=None): | |
|
718 | tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\ | |
|
719 | .filter(or_(UserApiKeys.expires == -1, | |
|
720 | UserApiKeys.expires >= time.time())) | |
|
721 | if role: | |
|
722 | tokens = tokens.filter(or_(UserApiKeys.role == role, | |
|
723 | UserApiKeys.role == UserApiKeys.ROLE_ALL)) | |
|
724 | return tokens.all() | |
|
725 | ||
|
726 | def authenticate_by_token(self, auth_token, roles=None, scope_repo_id=None): | |
|
727 | from rhodecode.lib import auth | |
|
728 | ||
|
729 | log.debug('Trying to authenticate user: %s via auth-token, ' | |
|
730 | 'and roles: %s', self, roles) | |
|
731 | ||
|
732 | if not auth_token: | |
|
733 | return False | |
|
734 | ||
|
735 | crypto_backend = auth.crypto_backend() | |
|
736 | ||
|
737 | roles = (roles or []) + [UserApiKeys.ROLE_ALL] | |
|
738 | tokens_q = UserApiKeys.query()\ | |
|
739 | .filter(UserApiKeys.user_id == self.user_id)\ | |
|
740 | .filter(or_(UserApiKeys.expires == -1, | |
|
741 | UserApiKeys.expires >= time.time())) | |
|
742 | ||
|
743 | tokens_q = tokens_q.filter(UserApiKeys.role.in_(roles)) | |
|
744 | ||
|
745 | plain_tokens = [] | |
|
746 | hash_tokens = [] | |
|
747 | ||
|
748 | user_tokens = tokens_q.all() | |
|
749 | log.debug('Found %s user tokens to check for authentication', len(user_tokens)) | |
|
750 | for token in user_tokens: | |
|
751 | log.debug('AUTH_TOKEN: checking if user token with id `%s` matches', | |
|
752 | token.user_api_key_id) | |
|
753 | # verify scope first, since it's way faster than hash calculation of | |
|
754 | # encrypted tokens | |
|
755 | if token.repo_id: | |
|
756 | # token has a scope, we need to verify it | |
|
757 | if scope_repo_id != token.repo_id: | |
|
758 | log.debug( | |
|
759 | 'AUTH_TOKEN: scope mismatch, token has a set repo scope: %s, ' | |
|
760 | 'and calling scope is:%s, skipping further checks', | |
|
761 | token.repo, scope_repo_id) | |
|
762 | # token has a scope, and it doesn't match, skip token | |
|
763 | continue | |
|
764 | ||
|
765 | if token.api_key.startswith(crypto_backend.ENC_PREF): | |
|
766 | hash_tokens.append(token.api_key) | |
|
767 | else: | |
|
768 | plain_tokens.append(token.api_key) | |
|
769 | ||
|
770 | is_plain_match = auth_token in plain_tokens | |
|
771 | if is_plain_match: | |
|
772 | return True | |
|
773 | ||
|
774 | for hashed in hash_tokens: | |
|
775 | # NOTE(marcink): this is expensive to calculate, but most secure | |
|
776 | match = crypto_backend.hash_check(auth_token, hashed) | |
|
777 | if match: | |
|
778 | return True | |
|
779 | ||
|
780 | return False | |
|
781 | ||
|
782 | @property | |
|
783 | def ip_addresses(self): | |
|
784 | ret = UserIpMap.query().filter(UserIpMap.user == self).all() | |
|
785 | return [x.ip_addr for x in ret] | |
|
786 | ||
|
787 | @property | |
|
788 | def username_and_name(self): | |
|
789 | return '%s (%s %s)' % (self.username, self.first_name, self.last_name) | |
|
790 | ||
|
791 | @property | |
|
792 | def username_or_name_or_email(self): | |
|
793 | full_name = self.full_name if self.full_name is not ' ' else None | |
|
794 | return self.username or full_name or self.email | |
|
795 | ||
|
796 | @property | |
|
797 | def full_name(self): | |
|
798 | return '%s %s' % (self.first_name, self.last_name) | |
|
799 | ||
|
800 | @property | |
|
801 | def full_name_or_username(self): | |
|
802 | return ('%s %s' % (self.first_name, self.last_name) | |
|
803 | if (self.first_name and self.last_name) else self.username) | |
|
804 | ||
|
805 | @property | |
|
806 | def full_contact(self): | |
|
807 | return '%s %s <%s>' % (self.first_name, self.last_name, self.email) | |
|
808 | ||
|
809 | @property | |
|
810 | def short_contact(self): | |
|
811 | return '%s %s' % (self.first_name, self.last_name) | |
|
812 | ||
|
813 | @property | |
|
814 | def is_admin(self): | |
|
815 | return self.admin | |
|
816 | ||
|
817 | def AuthUser(self, **kwargs): | |
|
818 | """ | |
|
819 | Returns instance of AuthUser for this user | |
|
820 | """ | |
|
821 | from rhodecode.lib.auth import AuthUser | |
|
822 | return AuthUser(user_id=self.user_id, username=self.username, **kwargs) | |
|
823 | ||
|
824 | @hybrid_property | |
|
825 | def user_data(self): | |
|
826 | if not self._user_data: | |
|
827 | return {} | |
|
828 | ||
|
829 | try: | |
|
830 | return json.loads(self._user_data) | |
|
831 | except TypeError: | |
|
832 | return {} | |
|
833 | ||
|
834 | @user_data.setter | |
|
835 | def user_data(self, val): | |
|
836 | if not isinstance(val, dict): | |
|
837 | raise Exception('user_data must be dict, got %s' % type(val)) | |
|
838 | try: | |
|
839 | self._user_data = json.dumps(val) | |
|
840 | except Exception: | |
|
841 | log.error(traceback.format_exc()) | |
|
842 | ||
|
843 | @classmethod | |
|
844 | def get_by_username(cls, username, case_insensitive=False, | |
|
845 | cache=False, identity_cache=False): | |
|
846 | session = Session() | |
|
847 | ||
|
848 | if case_insensitive: | |
|
849 | q = cls.query().filter( | |
|
850 | func.lower(cls.username) == func.lower(username)) | |
|
851 | else: | |
|
852 | q = cls.query().filter(cls.username == username) | |
|
853 | ||
|
854 | if cache: | |
|
855 | if identity_cache: | |
|
856 | val = cls.identity_cache(session, 'username', username) | |
|
857 | if val: | |
|
858 | return val | |
|
859 | else: | |
|
860 | cache_key = "get_user_by_name_%s" % _hash_key(username) | |
|
861 | q = q.options( | |
|
862 | FromCache("sql_cache_short", cache_key)) | |
|
863 | ||
|
864 | return q.scalar() | |
|
865 | ||
|
866 | @classmethod | |
|
867 | def get_by_auth_token(cls, auth_token, cache=False): | |
|
868 | q = UserApiKeys.query()\ | |
|
869 | .filter(UserApiKeys.api_key == auth_token)\ | |
|
870 | .filter(or_(UserApiKeys.expires == -1, | |
|
871 | UserApiKeys.expires >= time.time())) | |
|
872 | if cache: | |
|
873 | q = q.options( | |
|
874 | FromCache("sql_cache_short", "get_auth_token_%s" % auth_token)) | |
|
875 | ||
|
876 | match = q.first() | |
|
877 | if match: | |
|
878 | return match.user | |
|
879 | ||
|
880 | @classmethod | |
|
881 | def get_by_email(cls, email, case_insensitive=False, cache=False): | |
|
882 | ||
|
883 | if case_insensitive: | |
|
884 | q = cls.query().filter(func.lower(cls.email) == func.lower(email)) | |
|
885 | ||
|
886 | else: | |
|
887 | q = cls.query().filter(cls.email == email) | |
|
888 | ||
|
889 | email_key = _hash_key(email) | |
|
890 | if cache: | |
|
891 | q = q.options( | |
|
892 | FromCache("sql_cache_short", "get_email_key_%s" % email_key)) | |
|
893 | ||
|
894 | ret = q.scalar() | |
|
895 | if ret is None: | |
|
896 | q = UserEmailMap.query() | |
|
897 | # try fetching in alternate email map | |
|
898 | if case_insensitive: | |
|
899 | q = q.filter(func.lower(UserEmailMap.email) == func.lower(email)) | |
|
900 | else: | |
|
901 | q = q.filter(UserEmailMap.email == email) | |
|
902 | q = q.options(joinedload(UserEmailMap.user)) | |
|
903 | if cache: | |
|
904 | q = q.options( | |
|
905 | FromCache("sql_cache_short", "get_email_map_key_%s" % email_key)) | |
|
906 | ret = getattr(q.scalar(), 'user', None) | |
|
907 | ||
|
908 | return ret | |
|
909 | ||
|
910 | @classmethod | |
|
911 | def get_from_cs_author(cls, author): | |
|
912 | """ | |
|
913 | Tries to get User objects out of commit author string | |
|
914 | ||
|
915 | :param author: | |
|
916 | """ | |
|
917 | from rhodecode.lib.helpers import email, author_name | |
|
918 | # Valid email in the attribute passed, see if they're in the system | |
|
919 | _email = email(author) | |
|
920 | if _email: | |
|
921 | user = cls.get_by_email(_email, case_insensitive=True) | |
|
922 | if user: | |
|
923 | return user | |
|
924 | # Maybe we can match by username? | |
|
925 | _author = author_name(author) | |
|
926 | user = cls.get_by_username(_author, case_insensitive=True) | |
|
927 | if user: | |
|
928 | return user | |
|
929 | ||
|
930 | def update_userdata(self, **kwargs): | |
|
931 | usr = self | |
|
932 | old = usr.user_data | |
|
933 | old.update(**kwargs) | |
|
934 | usr.user_data = old | |
|
935 | Session().add(usr) | |
|
936 | log.debug('updated userdata with ', kwargs) | |
|
937 | ||
|
938 | def update_lastlogin(self): | |
|
939 | """Update user lastlogin""" | |
|
940 | self.last_login = datetime.datetime.now() | |
|
941 | Session().add(self) | |
|
942 | log.debug('updated user %s lastlogin', self.username) | |
|
943 | ||
|
944 | def update_password(self, new_password): | |
|
945 | from rhodecode.lib.auth import get_crypt_password | |
|
946 | ||
|
947 | self.password = get_crypt_password(new_password) | |
|
948 | Session().add(self) | |
|
949 | ||
|
950 | @classmethod | |
|
951 | def get_first_super_admin(cls): | |
|
952 | user = User.query()\ | |
|
953 | .filter(User.admin == true()) \ | |
|
954 | .order_by(User.user_id.asc()) \ | |
|
955 | .first() | |
|
956 | ||
|
957 | if user is None: | |
|
958 | raise Exception('FATAL: Missing administrative account!') | |
|
959 | return user | |
|
960 | ||
|
961 | @classmethod | |
|
962 | def get_all_super_admins(cls): | |
|
963 | """ | |
|
964 | Returns all admin accounts sorted by username | |
|
965 | """ | |
|
966 | return User.query().filter(User.admin == true())\ | |
|
967 | .order_by(User.username.asc()).all() | |
|
968 | ||
|
969 | @classmethod | |
|
970 | def get_default_user(cls, cache=False, refresh=False): | |
|
971 | user = User.get_by_username(User.DEFAULT_USER, cache=cache) | |
|
972 | if user is None: | |
|
973 | raise Exception('FATAL: Missing default account!') | |
|
974 | if refresh: | |
|
975 | # The default user might be based on outdated state which | |
|
976 | # has been loaded from the cache. | |
|
977 | # A call to refresh() ensures that the | |
|
978 | # latest state from the database is used. | |
|
979 | Session().refresh(user) | |
|
980 | return user | |
|
981 | ||
|
982 | def _get_default_perms(self, user, suffix=''): | |
|
983 | from rhodecode.model.permission import PermissionModel | |
|
984 | return PermissionModel().get_default_perms(user.user_perms, suffix) | |
|
985 | ||
|
986 | def get_default_perms(self, suffix=''): | |
|
987 | return self._get_default_perms(self, suffix) | |
|
988 | ||
|
989 | def get_api_data(self, include_secrets=False, details='full'): | |
|
990 | """ | |
|
991 | Common function for generating user related data for API | |
|
992 | ||
|
993 | :param include_secrets: By default secrets in the API data will be replaced | |
|
994 | by a placeholder value to prevent exposing this data by accident. In case | |
|
995 | this data shall be exposed, set this flag to ``True``. | |
|
996 | ||
|
997 | :param details: details can be 'basic|full' basic gives only a subset of | |
|
998 | the available user information that includes user_id, name and emails. | |
|
999 | """ | |
|
1000 | user = self | |
|
1001 | user_data = self.user_data | |
|
1002 | data = { | |
|
1003 | 'user_id': user.user_id, | |
|
1004 | 'username': user.username, | |
|
1005 | 'firstname': user.name, | |
|
1006 | 'lastname': user.lastname, | |
|
1007 | 'email': user.email, | |
|
1008 | 'emails': user.emails, | |
|
1009 | } | |
|
1010 | if details == 'basic': | |
|
1011 | return data | |
|
1012 | ||
|
1013 | auth_token_length = 40 | |
|
1014 | auth_token_replacement = '*' * auth_token_length | |
|
1015 | ||
|
1016 | extras = { | |
|
1017 | 'auth_tokens': [auth_token_replacement], | |
|
1018 | 'active': user.active, | |
|
1019 | 'admin': user.admin, | |
|
1020 | 'extern_type': user.extern_type, | |
|
1021 | 'extern_name': user.extern_name, | |
|
1022 | 'last_login': user.last_login, | |
|
1023 | 'last_activity': user.last_activity, | |
|
1024 | 'ip_addresses': user.ip_addresses, | |
|
1025 | 'language': user_data.get('language') | |
|
1026 | } | |
|
1027 | data.update(extras) | |
|
1028 | ||
|
1029 | if include_secrets: | |
|
1030 | data['auth_tokens'] = user.auth_tokens | |
|
1031 | return data | |
|
1032 | ||
|
1033 | def __json__(self): | |
|
1034 | data = { | |
|
1035 | 'full_name': self.full_name, | |
|
1036 | 'full_name_or_username': self.full_name_or_username, | |
|
1037 | 'short_contact': self.short_contact, | |
|
1038 | 'full_contact': self.full_contact, | |
|
1039 | } | |
|
1040 | data.update(self.get_api_data()) | |
|
1041 | return data | |
|
1042 | ||
|
1043 | ||
|
1044 | class UserApiKeys(Base, BaseModel): | |
|
1045 | __tablename__ = 'user_api_keys' | |
|
1046 | __table_args__ = ( | |
|
1047 | Index('uak_api_key_idx', 'api_key', unique=True), | |
|
1048 | Index('uak_api_key_expires_idx', 'api_key', 'expires'), | |
|
1049 | base_table_args | |
|
1050 | ) | |
|
1051 | __mapper_args__ = {} | |
|
1052 | ||
|
1053 | # ApiKey role | |
|
1054 | ROLE_ALL = 'token_role_all' | |
|
1055 | ROLE_HTTP = 'token_role_http' | |
|
1056 | ROLE_VCS = 'token_role_vcs' | |
|
1057 | ROLE_API = 'token_role_api' | |
|
1058 | ROLE_FEED = 'token_role_feed' | |
|
1059 | ROLE_PASSWORD_RESET = 'token_password_reset' | |
|
1060 | ||
|
1061 | ROLES = [ROLE_ALL, ROLE_HTTP, ROLE_VCS, ROLE_API, ROLE_FEED] | |
|
1062 | ||
|
1063 | user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
1064 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) | |
|
1065 | api_key = Column("api_key", String(255), nullable=False, unique=True) | |
|
1066 | description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql')) | |
|
1067 | expires = Column('expires', Float(53), nullable=False) | |
|
1068 | role = Column('role', String(255), nullable=True) | |
|
1069 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
|
1070 | ||
|
1071 | # scope columns | |
|
1072 | repo_id = Column( | |
|
1073 | 'repo_id', Integer(), ForeignKey('repositories.repo_id'), | |
|
1074 | nullable=True, unique=None, default=None) | |
|
1075 | repo = relationship('Repository', lazy='joined') | |
|
1076 | ||
|
1077 | repo_group_id = Column( | |
|
1078 | 'repo_group_id', Integer(), ForeignKey('groups.group_id'), | |
|
1079 | nullable=True, unique=None, default=None) | |
|
1080 | repo_group = relationship('RepoGroup', lazy='joined') | |
|
1081 | ||
|
1082 | user = relationship('User', lazy='joined') | |
|
1083 | ||
|
1084 | def __unicode__(self): | |
|
1085 | return u"<%s('%s')>" % (self.__class__.__name__, self.role) | |
|
1086 | ||
|
1087 | def __json__(self): | |
|
1088 | data = { | |
|
1089 | 'auth_token': self.api_key, | |
|
1090 | 'role': self.role, | |
|
1091 | 'scope': self.scope_humanized, | |
|
1092 | 'expired': self.expired | |
|
1093 | } | |
|
1094 | return data | |
|
1095 | ||
|
1096 | def get_api_data(self, include_secrets=False): | |
|
1097 | data = self.__json__() | |
|
1098 | if include_secrets: | |
|
1099 | return data | |
|
1100 | else: | |
|
1101 | data['auth_token'] = self.token_obfuscated | |
|
1102 | return data | |
|
1103 | ||
|
1104 | @hybrid_property | |
|
1105 | def description_safe(self): | |
|
1106 | from rhodecode.lib import helpers as h | |
|
1107 | return h.escape(self.description) | |
|
1108 | ||
|
1109 | @property | |
|
1110 | def expired(self): | |
|
1111 | if self.expires == -1: | |
|
1112 | return False | |
|
1113 | return time.time() > self.expires | |
|
1114 | ||
|
1115 | @classmethod | |
|
1116 | def _get_role_name(cls, role): | |
|
1117 | return { | |
|
1118 | cls.ROLE_ALL: _('all'), | |
|
1119 | cls.ROLE_HTTP: _('http/web interface'), | |
|
1120 | cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'), | |
|
1121 | cls.ROLE_API: _('api calls'), | |
|
1122 | cls.ROLE_FEED: _('feed access'), | |
|
1123 | }.get(role, role) | |
|
1124 | ||
|
1125 | @property | |
|
1126 | def role_humanized(self): | |
|
1127 | return self._get_role_name(self.role) | |
|
1128 | ||
|
1129 | def _get_scope(self): | |
|
1130 | if self.repo: | |
|
1131 | return repr(self.repo) | |
|
1132 | if self.repo_group: | |
|
1133 | return repr(self.repo_group) + ' (recursive)' | |
|
1134 | return 'global' | |
|
1135 | ||
|
1136 | @property | |
|
1137 | def scope_humanized(self): | |
|
1138 | return self._get_scope() | |
|
1139 | ||
|
1140 | @property | |
|
1141 | def token_obfuscated(self): | |
|
1142 | if self.api_key: | |
|
1143 | return self.api_key[:4] + "****" | |
|
1144 | ||
|
1145 | ||
|
1146 | class UserEmailMap(Base, BaseModel): | |
|
1147 | __tablename__ = 'user_email_map' | |
|
1148 | __table_args__ = ( | |
|
1149 | Index('uem_email_idx', 'email'), | |
|
1150 | UniqueConstraint('email'), | |
|
1151 | base_table_args | |
|
1152 | ) | |
|
1153 | __mapper_args__ = {} | |
|
1154 | ||
|
1155 | email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
1156 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) | |
|
1157 | _email = Column("email", String(255), nullable=True, unique=False, default=None) | |
|
1158 | user = relationship('User', lazy='joined') | |
|
1159 | ||
|
1160 | @validates('_email') | |
|
1161 | def validate_email(self, key, email): | |
|
1162 | # check if this email is not main one | |
|
1163 | main_email = Session().query(User).filter(User.email == email).scalar() | |
|
1164 | if main_email is not None: | |
|
1165 | raise AttributeError('email %s is present is user table' % email) | |
|
1166 | return email | |
|
1167 | ||
|
1168 | @hybrid_property | |
|
1169 | def email(self): | |
|
1170 | return self._email | |
|
1171 | ||
|
1172 | @email.setter | |
|
1173 | def email(self, val): | |
|
1174 | self._email = val.lower() if val else None | |
|
1175 | ||
|
1176 | ||
|
1177 | class UserIpMap(Base, BaseModel): | |
|
1178 | __tablename__ = 'user_ip_map' | |
|
1179 | __table_args__ = ( | |
|
1180 | UniqueConstraint('user_id', 'ip_addr'), | |
|
1181 | base_table_args | |
|
1182 | ) | |
|
1183 | __mapper_args__ = {} | |
|
1184 | ||
|
1185 | ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
1186 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) | |
|
1187 | ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None) | |
|
1188 | active = Column("active", Boolean(), nullable=True, unique=None, default=True) | |
|
1189 | description = Column("description", String(10000), nullable=True, unique=None, default=None) | |
|
1190 | user = relationship('User', lazy='joined') | |
|
1191 | ||
|
1192 | @hybrid_property | |
|
1193 | def description_safe(self): | |
|
1194 | from rhodecode.lib import helpers as h | |
|
1195 | return h.escape(self.description) | |
|
1196 | ||
|
1197 | @classmethod | |
|
1198 | def _get_ip_range(cls, ip_addr): | |
|
1199 | net = ipaddress.ip_network(safe_unicode(ip_addr), strict=False) | |
|
1200 | return [str(net.network_address), str(net.broadcast_address)] | |
|
1201 | ||
|
1202 | def __json__(self): | |
|
1203 | return { | |
|
1204 | 'ip_addr': self.ip_addr, | |
|
1205 | 'ip_range': self._get_ip_range(self.ip_addr), | |
|
1206 | } | |
|
1207 | ||
|
1208 | def __unicode__(self): | |
|
1209 | return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__, | |
|
1210 | self.user_id, self.ip_addr) | |
|
1211 | ||
|
1212 | ||
|
1213 | class UserSshKeys(Base, BaseModel): | |
|
1214 | __tablename__ = 'user_ssh_keys' | |
|
1215 | __table_args__ = ( | |
|
1216 | Index('usk_ssh_key_fingerprint_idx', 'ssh_key_fingerprint'), | |
|
1217 | ||
|
1218 | UniqueConstraint('ssh_key_fingerprint'), | |
|
1219 | ||
|
1220 | base_table_args | |
|
1221 | ) | |
|
1222 | __mapper_args__ = {} | |
|
1223 | ||
|
1224 | ssh_key_id = Column('ssh_key_id', Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
1225 | ssh_key_data = Column('ssh_key_data', String(10240), nullable=False, unique=None, default=None) | |
|
1226 | ssh_key_fingerprint = Column('ssh_key_fingerprint', String(255), nullable=False, unique=None, default=None) | |
|
1227 | ||
|
1228 | description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql')) | |
|
1229 | ||
|
1230 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
|
1231 | accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True, default=None) | |
|
1232 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) | |
|
1233 | ||
|
1234 | user = relationship('User', lazy='joined') | |
|
1235 | ||
|
1236 | def __json__(self): | |
|
1237 | data = { | |
|
1238 | 'ssh_fingerprint': self.ssh_key_fingerprint, | |
|
1239 | 'description': self.description, | |
|
1240 | 'created_on': self.created_on | |
|
1241 | } | |
|
1242 | return data | |
|
1243 | ||
|
1244 | def get_api_data(self): | |
|
1245 | data = self.__json__() | |
|
1246 | return data | |
|
1247 | ||
|
1248 | ||
|
1249 | class UserLog(Base, BaseModel): | |
|
1250 | __tablename__ = 'user_logs' | |
|
1251 | __table_args__ = ( | |
|
1252 | base_table_args, | |
|
1253 | ) | |
|
1254 | ||
|
1255 | VERSION_1 = 'v1' | |
|
1256 | VERSION_2 = 'v2' | |
|
1257 | VERSIONS = [VERSION_1, VERSION_2] | |
|
1258 | ||
|
1259 | user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
1260 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id',ondelete='SET NULL'), nullable=True, unique=None, default=None) | |
|
1261 | username = Column("username", String(255), nullable=True, unique=None, default=None) | |
|
1262 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id', ondelete='SET NULL'), nullable=True, unique=None, default=None) | |
|
1263 | repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None) | |
|
1264 | user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None) | |
|
1265 | action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None) | |
|
1266 | action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None) | |
|
1267 | ||
|
1268 | version = Column("version", String(255), nullable=True, default=VERSION_1) | |
|
1269 | user_data = Column('user_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT())))) | |
|
1270 | action_data = Column('action_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT())))) | |
|
1271 | ||
|
1272 | def __unicode__(self): | |
|
1273 | return u"<%s('id:%s:%s')>" % ( | |
|
1274 | self.__class__.__name__, self.repository_name, self.action) | |
|
1275 | ||
|
1276 | def __json__(self): | |
|
1277 | return { | |
|
1278 | 'user_id': self.user_id, | |
|
1279 | 'username': self.username, | |
|
1280 | 'repository_id': self.repository_id, | |
|
1281 | 'repository_name': self.repository_name, | |
|
1282 | 'user_ip': self.user_ip, | |
|
1283 | 'action_date': self.action_date, | |
|
1284 | 'action': self.action, | |
|
1285 | } | |
|
1286 | ||
|
1287 | @hybrid_property | |
|
1288 | def entry_id(self): | |
|
1289 | return self.user_log_id | |
|
1290 | ||
|
1291 | @property | |
|
1292 | def action_as_day(self): | |
|
1293 | return datetime.date(*self.action_date.timetuple()[:3]) | |
|
1294 | ||
|
1295 | user = relationship('User') | |
|
1296 | repository = relationship('Repository', cascade='') | |
|
1297 | ||
|
1298 | ||
|
1299 | class UserGroup(Base, BaseModel): | |
|
1300 | __tablename__ = 'users_groups' | |
|
1301 | __table_args__ = ( | |
|
1302 | base_table_args, | |
|
1303 | ) | |
|
1304 | ||
|
1305 | users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
1306 | users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None) | |
|
1307 | user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None) | |
|
1308 | users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None) | |
|
1309 | inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True) | |
|
1310 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None) | |
|
1311 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
|
1312 | _group_data = Column("group_data", LargeBinary(), nullable=True) # JSON data | |
|
1313 | ||
|
1314 | members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined") | |
|
1315 | users_group_to_perm = relationship('UserGroupToPerm', cascade='all') | |
|
1316 | users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all') | |
|
1317 | users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all') | |
|
1318 | user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all') | |
|
1319 | user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all') | |
|
1320 | ||
|
1321 | user_group_review_rules = relationship('RepoReviewRuleUserGroup', cascade='all') | |
|
1322 | user = relationship('User', primaryjoin="User.user_id==UserGroup.user_id") | |
|
1323 | ||
|
1324 | @classmethod | |
|
1325 | def _load_group_data(cls, column): | |
|
1326 | if not column: | |
|
1327 | return {} | |
|
1328 | ||
|
1329 | try: | |
|
1330 | return json.loads(column) or {} | |
|
1331 | except TypeError: | |
|
1332 | return {} | |
|
1333 | ||
|
1334 | @hybrid_property | |
|
1335 | def description_safe(self): | |
|
1336 | from rhodecode.lib import helpers as h | |
|
1337 | return h.escape(self.user_group_description) | |
|
1338 | ||
|
1339 | @hybrid_property | |
|
1340 | def group_data(self): | |
|
1341 | return self._load_group_data(self._group_data) | |
|
1342 | ||
|
1343 | @group_data.expression | |
|
1344 | def group_data(self, **kwargs): | |
|
1345 | return self._group_data | |
|
1346 | ||
|
1347 | @group_data.setter | |
|
1348 | def group_data(self, val): | |
|
1349 | try: | |
|
1350 | self._group_data = json.dumps(val) | |
|
1351 | except Exception: | |
|
1352 | log.error(traceback.format_exc()) | |
|
1353 | ||
|
1354 | @classmethod | |
|
1355 | def _load_sync(cls, group_data): | |
|
1356 | if group_data: | |
|
1357 | return group_data.get('extern_type') | |
|
1358 | ||
|
1359 | @property | |
|
1360 | def sync(self): | |
|
1361 | return self._load_sync(self.group_data) | |
|
1362 | ||
|
1363 | def __unicode__(self): | |
|
1364 | return u"<%s('id:%s:%s')>" % (self.__class__.__name__, | |
|
1365 | self.users_group_id, | |
|
1366 | self.users_group_name) | |
|
1367 | ||
|
1368 | @classmethod | |
|
1369 | def get_by_group_name(cls, group_name, cache=False, | |
|
1370 | case_insensitive=False): | |
|
1371 | if case_insensitive: | |
|
1372 | q = cls.query().filter(func.lower(cls.users_group_name) == | |
|
1373 | func.lower(group_name)) | |
|
1374 | ||
|
1375 | else: | |
|
1376 | q = cls.query().filter(cls.users_group_name == group_name) | |
|
1377 | if cache: | |
|
1378 | q = q.options( | |
|
1379 | FromCache("sql_cache_short", "get_group_%s" % _hash_key(group_name))) | |
|
1380 | return q.scalar() | |
|
1381 | ||
|
1382 | @classmethod | |
|
1383 | def get(cls, user_group_id, cache=False): | |
|
1384 | if not user_group_id: | |
|
1385 | return | |
|
1386 | ||
|
1387 | user_group = cls.query() | |
|
1388 | if cache: | |
|
1389 | user_group = user_group.options( | |
|
1390 | FromCache("sql_cache_short", "get_users_group_%s" % user_group_id)) | |
|
1391 | return user_group.get(user_group_id) | |
|
1392 | ||
|
1393 | def permissions(self, with_admins=True, with_owner=True): | |
|
1394 | """ | |
|
1395 | Permissions for user groups | |
|
1396 | """ | |
|
1397 | _admin_perm = 'usergroup.admin' | |
|
1398 | ||
|
1399 | owner_row = [] | |
|
1400 | if with_owner: | |
|
1401 | usr = AttributeDict(self.user.get_dict()) | |
|
1402 | usr.owner_row = True | |
|
1403 | usr.permission = _admin_perm | |
|
1404 | owner_row.append(usr) | |
|
1405 | ||
|
1406 | super_admin_ids = [] | |
|
1407 | super_admin_rows = [] | |
|
1408 | if with_admins: | |
|
1409 | for usr in User.get_all_super_admins(): | |
|
1410 | super_admin_ids.append(usr.user_id) | |
|
1411 | # if this admin is also owner, don't double the record | |
|
1412 | if usr.user_id == owner_row[0].user_id: | |
|
1413 | owner_row[0].admin_row = True | |
|
1414 | else: | |
|
1415 | usr = AttributeDict(usr.get_dict()) | |
|
1416 | usr.admin_row = True | |
|
1417 | usr.permission = _admin_perm | |
|
1418 | super_admin_rows.append(usr) | |
|
1419 | ||
|
1420 | q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self) | |
|
1421 | q = q.options(joinedload(UserUserGroupToPerm.user_group), | |
|
1422 | joinedload(UserUserGroupToPerm.user), | |
|
1423 | joinedload(UserUserGroupToPerm.permission),) | |
|
1424 | ||
|
1425 | # get owners and admins and permissions. We do a trick of re-writing | |
|
1426 | # objects from sqlalchemy to named-tuples due to sqlalchemy session | |
|
1427 | # has a global reference and changing one object propagates to all | |
|
1428 | # others. This means if admin is also an owner admin_row that change | |
|
1429 | # would propagate to both objects | |
|
1430 | perm_rows = [] | |
|
1431 | for _usr in q.all(): | |
|
1432 | usr = AttributeDict(_usr.user.get_dict()) | |
|
1433 | # if this user is also owner/admin, mark as duplicate record | |
|
1434 | if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids: | |
|
1435 | usr.duplicate_perm = True | |
|
1436 | usr.permission = _usr.permission.permission_name | |
|
1437 | perm_rows.append(usr) | |
|
1438 | ||
|
1439 | # filter the perm rows by 'default' first and then sort them by | |
|
1440 | # admin,write,read,none permissions sorted again alphabetically in | |
|
1441 | # each group | |
|
1442 | perm_rows = sorted(perm_rows, key=display_user_sort) | |
|
1443 | ||
|
1444 | return super_admin_rows + owner_row + perm_rows | |
|
1445 | ||
|
1446 | def permission_user_groups(self): | |
|
1447 | q = UserGroupUserGroupToPerm.query().filter(UserGroupUserGroupToPerm.target_user_group == self) | |
|
1448 | q = q.options(joinedload(UserGroupUserGroupToPerm.user_group), | |
|
1449 | joinedload(UserGroupUserGroupToPerm.target_user_group), | |
|
1450 | joinedload(UserGroupUserGroupToPerm.permission),) | |
|
1451 | ||
|
1452 | perm_rows = [] | |
|
1453 | for _user_group in q.all(): | |
|
1454 | usr = AttributeDict(_user_group.user_group.get_dict()) | |
|
1455 | usr.permission = _user_group.permission.permission_name | |
|
1456 | perm_rows.append(usr) | |
|
1457 | ||
|
1458 | perm_rows = sorted(perm_rows, key=display_user_group_sort) | |
|
1459 | return perm_rows | |
|
1460 | ||
|
1461 | def _get_default_perms(self, user_group, suffix=''): | |
|
1462 | from rhodecode.model.permission import PermissionModel | |
|
1463 | return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix) | |
|
1464 | ||
|
1465 | def get_default_perms(self, suffix=''): | |
|
1466 | return self._get_default_perms(self, suffix) | |
|
1467 | ||
|
1468 | def get_api_data(self, with_group_members=True, include_secrets=False): | |
|
1469 | """ | |
|
1470 | :param include_secrets: See :meth:`User.get_api_data`, this parameter is | |
|
1471 | basically forwarded. | |
|
1472 | ||
|
1473 | """ | |
|
1474 | user_group = self | |
|
1475 | data = { | |
|
1476 | 'users_group_id': user_group.users_group_id, | |
|
1477 | 'group_name': user_group.users_group_name, | |
|
1478 | 'group_description': user_group.user_group_description, | |
|
1479 | 'active': user_group.users_group_active, | |
|
1480 | 'owner': user_group.user.username, | |
|
1481 | 'sync': user_group.sync, | |
|
1482 | 'owner_email': user_group.user.email, | |
|
1483 | } | |
|
1484 | ||
|
1485 | if with_group_members: | |
|
1486 | users = [] | |
|
1487 | for user in user_group.members: | |
|
1488 | user = user.user | |
|
1489 | users.append(user.get_api_data(include_secrets=include_secrets)) | |
|
1490 | data['users'] = users | |
|
1491 | ||
|
1492 | return data | |
|
1493 | ||
|
1494 | ||
|
1495 | class UserGroupMember(Base, BaseModel): | |
|
1496 | __tablename__ = 'users_groups_members' | |
|
1497 | __table_args__ = ( | |
|
1498 | base_table_args, | |
|
1499 | ) | |
|
1500 | ||
|
1501 | users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
1502 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
|
1503 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
|
1504 | ||
|
1505 | user = relationship('User', lazy='joined') | |
|
1506 | users_group = relationship('UserGroup') | |
|
1507 | ||
|
1508 | def __init__(self, gr_id='', u_id=''): | |
|
1509 | self.users_group_id = gr_id | |
|
1510 | self.user_id = u_id | |
|
1511 | ||
|
1512 | ||
|
1513 | class RepositoryField(Base, BaseModel): | |
|
1514 | __tablename__ = 'repositories_fields' | |
|
1515 | __table_args__ = ( | |
|
1516 | UniqueConstraint('repository_id', 'field_key'), # no-multi field | |
|
1517 | base_table_args, | |
|
1518 | ) | |
|
1519 | ||
|
1520 | PREFIX = 'ex_' # prefix used in form to not conflict with already existing fields | |
|
1521 | ||
|
1522 | repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
1523 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) | |
|
1524 | field_key = Column("field_key", String(250)) | |
|
1525 | field_label = Column("field_label", String(1024), nullable=False) | |
|
1526 | field_value = Column("field_value", String(10000), nullable=False) | |
|
1527 | field_desc = Column("field_desc", String(1024), nullable=False) | |
|
1528 | field_type = Column("field_type", String(255), nullable=False, unique=None) | |
|
1529 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
|
1530 | ||
|
1531 | repository = relationship('Repository') | |
|
1532 | ||
|
1533 | @property | |
|
1534 | def field_key_prefixed(self): | |
|
1535 | return 'ex_%s' % self.field_key | |
|
1536 | ||
|
1537 | @classmethod | |
|
1538 | def un_prefix_key(cls, key): | |
|
1539 | if key.startswith(cls.PREFIX): | |
|
1540 | return key[len(cls.PREFIX):] | |
|
1541 | return key | |
|
1542 | ||
|
1543 | @classmethod | |
|
1544 | def get_by_key_name(cls, key, repo): | |
|
1545 | row = cls.query()\ | |
|
1546 | .filter(cls.repository == repo)\ | |
|
1547 | .filter(cls.field_key == key).scalar() | |
|
1548 | return row | |
|
1549 | ||
|
1550 | ||
|
1551 | class Repository(Base, BaseModel): | |
|
1552 | __tablename__ = 'repositories' | |
|
1553 | __table_args__ = ( | |
|
1554 | Index('r_repo_name_idx', 'repo_name', mysql_length=255), | |
|
1555 | base_table_args, | |
|
1556 | ) | |
|
1557 | DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}' | |
|
1558 | DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}' | |
|
1559 | DEFAULT_CLONE_URI_SSH = 'ssh://{sys_user}@{hostname}/{repo}' | |
|
1560 | ||
|
1561 | STATE_CREATED = 'repo_state_created' | |
|
1562 | STATE_PENDING = 'repo_state_pending' | |
|
1563 | STATE_ERROR = 'repo_state_error' | |
|
1564 | ||
|
1565 | LOCK_AUTOMATIC = 'lock_auto' | |
|
1566 | LOCK_API = 'lock_api' | |
|
1567 | LOCK_WEB = 'lock_web' | |
|
1568 | LOCK_PULL = 'lock_pull' | |
|
1569 | ||
|
1570 | NAME_SEP = URL_SEP | |
|
1571 | ||
|
1572 | repo_id = Column( | |
|
1573 | "repo_id", Integer(), nullable=False, unique=True, default=None, | |
|
1574 | primary_key=True) | |
|
1575 | _repo_name = Column( | |
|
1576 | "repo_name", Text(), nullable=False, default=None) | |
|
1577 | _repo_name_hash = Column( | |
|
1578 | "repo_name_hash", String(255), nullable=False, unique=True) | |
|
1579 | repo_state = Column("repo_state", String(255), nullable=True) | |
|
1580 | ||
|
1581 | clone_uri = Column( | |
|
1582 | "clone_uri", EncryptedTextValue(), nullable=True, unique=False, | |
|
1583 | default=None) | |
|
1584 | push_uri = Column( | |
|
1585 | "push_uri", EncryptedTextValue(), nullable=True, unique=False, | |
|
1586 | default=None) | |
|
1587 | repo_type = Column( | |
|
1588 | "repo_type", String(255), nullable=False, unique=False, default=None) | |
|
1589 | user_id = Column( | |
|
1590 | "user_id", Integer(), ForeignKey('users.user_id'), nullable=False, | |
|
1591 | unique=False, default=None) | |
|
1592 | private = Column( | |
|
1593 | "private", Boolean(), nullable=True, unique=None, default=None) | |
|
1594 | archived = Column( | |
|
1595 | "archived", Boolean(), nullable=True, unique=None, default=None) | |
|
1596 | enable_statistics = Column( | |
|
1597 | "statistics", Boolean(), nullable=True, unique=None, default=True) | |
|
1598 | enable_downloads = Column( | |
|
1599 | "downloads", Boolean(), nullable=True, unique=None, default=True) | |
|
1600 | description = Column( | |
|
1601 | "description", String(10000), nullable=True, unique=None, default=None) | |
|
1602 | created_on = Column( | |
|
1603 | 'created_on', DateTime(timezone=False), nullable=True, unique=None, | |
|
1604 | default=datetime.datetime.now) | |
|
1605 | updated_on = Column( | |
|
1606 | 'updated_on', DateTime(timezone=False), nullable=True, unique=None, | |
|
1607 | default=datetime.datetime.now) | |
|
1608 | _landing_revision = Column( | |
|
1609 | "landing_revision", String(255), nullable=False, unique=False, | |
|
1610 | default=None) | |
|
1611 | enable_locking = Column( | |
|
1612 | "enable_locking", Boolean(), nullable=False, unique=None, | |
|
1613 | default=False) | |
|
1614 | _locked = Column( | |
|
1615 | "locked", String(255), nullable=True, unique=False, default=None) | |
|
1616 | _changeset_cache = Column( | |
|
1617 | "changeset_cache", LargeBinary(), nullable=True) # JSON data | |
|
1618 | ||
|
1619 | fork_id = Column( | |
|
1620 | "fork_id", Integer(), ForeignKey('repositories.repo_id'), | |
|
1621 | nullable=True, unique=False, default=None) | |
|
1622 | group_id = Column( | |
|
1623 | "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True, | |
|
1624 | unique=False, default=None) | |
|
1625 | ||
|
1626 | user = relationship('User', lazy='joined') | |
|
1627 | fork = relationship('Repository', remote_side=repo_id, lazy='joined') | |
|
1628 | group = relationship('RepoGroup', lazy='joined') | |
|
1629 | repo_to_perm = relationship( | |
|
1630 | 'UserRepoToPerm', cascade='all', | |
|
1631 | order_by='UserRepoToPerm.repo_to_perm_id') | |
|
1632 | users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all') | |
|
1633 | stats = relationship('Statistics', cascade='all', uselist=False) | |
|
1634 | ||
|
1635 | followers = relationship( | |
|
1636 | 'UserFollowing', | |
|
1637 | primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', | |
|
1638 | cascade='all') | |
|
1639 | extra_fields = relationship( | |
|
1640 | 'RepositoryField', cascade="all, delete, delete-orphan") | |
|
1641 | logs = relationship('UserLog') | |
|
1642 | comments = relationship( | |
|
1643 | 'ChangesetComment', cascade="all, delete, delete-orphan") | |
|
1644 | pull_requests_source = relationship( | |
|
1645 | 'PullRequest', | |
|
1646 | primaryjoin='PullRequest.source_repo_id==Repository.repo_id', | |
|
1647 | cascade="all, delete, delete-orphan") | |
|
1648 | pull_requests_target = relationship( | |
|
1649 | 'PullRequest', | |
|
1650 | primaryjoin='PullRequest.target_repo_id==Repository.repo_id', | |
|
1651 | cascade="all, delete, delete-orphan") | |
|
1652 | ui = relationship('RepoRhodeCodeUi', cascade="all") | |
|
1653 | settings = relationship('RepoRhodeCodeSetting', cascade="all") | |
|
1654 | integrations = relationship('Integration', | |
|
1655 | cascade="all, delete, delete-orphan") | |
|
1656 | ||
|
1657 | scoped_tokens = relationship('UserApiKeys', cascade="all") | |
|
1658 | ||
|
1659 | def __unicode__(self): | |
|
1660 | return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id, | |
|
1661 | safe_unicode(self.repo_name)) | |
|
1662 | ||
|
1663 | @hybrid_property | |
|
1664 | def description_safe(self): | |
|
1665 | from rhodecode.lib import helpers as h | |
|
1666 | return h.escape(self.description) | |
|
1667 | ||
|
1668 | @hybrid_property | |
|
1669 | def landing_rev(self): | |
|
1670 | # always should return [rev_type, rev] | |
|
1671 | if self._landing_revision: | |
|
1672 | _rev_info = self._landing_revision.split(':') | |
|
1673 | if len(_rev_info) < 2: | |
|
1674 | _rev_info.insert(0, 'rev') | |
|
1675 | return [_rev_info[0], _rev_info[1]] | |
|
1676 | return [None, None] | |
|
1677 | ||
|
1678 | @landing_rev.setter | |
|
1679 | def landing_rev(self, val): | |
|
1680 | if ':' not in val: | |
|
1681 | raise ValueError('value must be delimited with `:` and consist ' | |
|
1682 | 'of <rev_type>:<rev>, got %s instead' % val) | |
|
1683 | self._landing_revision = val | |
|
1684 | ||
|
1685 | @hybrid_property | |
|
1686 | def locked(self): | |
|
1687 | if self._locked: | |
|
1688 | user_id, timelocked, reason = self._locked.split(':') | |
|
1689 | lock_values = int(user_id), timelocked, reason | |
|
1690 | else: | |
|
1691 | lock_values = [None, None, None] | |
|
1692 | return lock_values | |
|
1693 | ||
|
1694 | @locked.setter | |
|
1695 | def locked(self, val): | |
|
1696 | if val and isinstance(val, (list, tuple)): | |
|
1697 | self._locked = ':'.join(map(str, val)) | |
|
1698 | else: | |
|
1699 | self._locked = None | |
|
1700 | ||
|
1701 | @hybrid_property | |
|
1702 | def changeset_cache(self): | |
|
1703 | from rhodecode.lib.vcs.backends.base import EmptyCommit | |
|
1704 | dummy = EmptyCommit().__json__() | |
|
1705 | if not self._changeset_cache: | |
|
1706 | return dummy | |
|
1707 | try: | |
|
1708 | return json.loads(self._changeset_cache) | |
|
1709 | except TypeError: | |
|
1710 | return dummy | |
|
1711 | except Exception: | |
|
1712 | log.error(traceback.format_exc()) | |
|
1713 | return dummy | |
|
1714 | ||
|
1715 | @changeset_cache.setter | |
|
1716 | def changeset_cache(self, val): | |
|
1717 | try: | |
|
1718 | self._changeset_cache = json.dumps(val) | |
|
1719 | except Exception: | |
|
1720 | log.error(traceback.format_exc()) | |
|
1721 | ||
|
1722 | @hybrid_property | |
|
1723 | def repo_name(self): | |
|
1724 | return self._repo_name | |
|
1725 | ||
|
1726 | @repo_name.setter | |
|
1727 | def repo_name(self, value): | |
|
1728 | self._repo_name = value | |
|
1729 | self._repo_name_hash = hashlib.sha1(safe_str(value)).hexdigest() | |
|
1730 | ||
|
1731 | @classmethod | |
|
1732 | def normalize_repo_name(cls, repo_name): | |
|
1733 | """ | |
|
1734 | Normalizes os specific repo_name to the format internally stored inside | |
|
1735 | database using URL_SEP | |
|
1736 | ||
|
1737 | :param cls: | |
|
1738 | :param repo_name: | |
|
1739 | """ | |
|
1740 | return cls.NAME_SEP.join(repo_name.split(os.sep)) | |
|
1741 | ||
|
1742 | @classmethod | |
|
1743 | def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False): | |
|
1744 | session = Session() | |
|
1745 | q = session.query(cls).filter(cls.repo_name == repo_name) | |
|
1746 | ||
|
1747 | if cache: | |
|
1748 | if identity_cache: | |
|
1749 | val = cls.identity_cache(session, 'repo_name', repo_name) | |
|
1750 | if val: | |
|
1751 | return val | |
|
1752 | else: | |
|
1753 | cache_key = "get_repo_by_name_%s" % _hash_key(repo_name) | |
|
1754 | q = q.options( | |
|
1755 | FromCache("sql_cache_short", cache_key)) | |
|
1756 | ||
|
1757 | return q.scalar() | |
|
1758 | ||
|
1759 | @classmethod | |
|
1760 | def get_by_id_or_repo_name(cls, repoid): | |
|
1761 | if isinstance(repoid, (int, long)): | |
|
1762 | try: | |
|
1763 | repo = cls.get(repoid) | |
|
1764 | except ValueError: | |
|
1765 | repo = None | |
|
1766 | else: | |
|
1767 | repo = cls.get_by_repo_name(repoid) | |
|
1768 | return repo | |
|
1769 | ||
|
1770 | @classmethod | |
|
1771 | def get_by_full_path(cls, repo_full_path): | |
|
1772 | repo_name = repo_full_path.split(cls.base_path(), 1)[-1] | |
|
1773 | repo_name = cls.normalize_repo_name(repo_name) | |
|
1774 | return cls.get_by_repo_name(repo_name.strip(URL_SEP)) | |
|
1775 | ||
|
1776 | @classmethod | |
|
1777 | def get_repo_forks(cls, repo_id): | |
|
1778 | return cls.query().filter(Repository.fork_id == repo_id) | |
|
1779 | ||
|
1780 | @classmethod | |
|
1781 | def base_path(cls): | |
|
1782 | """ | |
|
1783 | Returns base path when all repos are stored | |
|
1784 | ||
|
1785 | :param cls: | |
|
1786 | """ | |
|
1787 | q = Session().query(RhodeCodeUi)\ | |
|
1788 | .filter(RhodeCodeUi.ui_key == cls.NAME_SEP) | |
|
1789 | q = q.options(FromCache("sql_cache_short", "repository_repo_path")) | |
|
1790 | return q.one().ui_value | |
|
1791 | ||
|
1792 | @classmethod | |
|
1793 | def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None), | |
|
1794 | case_insensitive=True, archived=False): | |
|
1795 | q = Repository.query() | |
|
1796 | ||
|
1797 | if not archived: | |
|
1798 | q = q.filter(Repository.archived.isnot(true())) | |
|
1799 | ||
|
1800 | if not isinstance(user_id, Optional): | |
|
1801 | q = q.filter(Repository.user_id == user_id) | |
|
1802 | ||
|
1803 | if not isinstance(group_id, Optional): | |
|
1804 | q = q.filter(Repository.group_id == group_id) | |
|
1805 | ||
|
1806 | if case_insensitive: | |
|
1807 | q = q.order_by(func.lower(Repository.repo_name)) | |
|
1808 | else: | |
|
1809 | q = q.order_by(Repository.repo_name) | |
|
1810 | ||
|
1811 | return q.all() | |
|
1812 | ||
|
1813 | @property | |
|
1814 | def forks(self): | |
|
1815 | """ | |
|
1816 | Return forks of this repo | |
|
1817 | """ | |
|
1818 | return Repository.get_repo_forks(self.repo_id) | |
|
1819 | ||
|
1820 | @property | |
|
1821 | def parent(self): | |
|
1822 | """ | |
|
1823 | Returns fork parent | |
|
1824 | """ | |
|
1825 | return self.fork | |
|
1826 | ||
|
1827 | @property | |
|
1828 | def just_name(self): | |
|
1829 | return self.repo_name.split(self.NAME_SEP)[-1] | |
|
1830 | ||
|
1831 | @property | |
|
1832 | def groups_with_parents(self): | |
|
1833 | groups = [] | |
|
1834 | if self.group is None: | |
|
1835 | return groups | |
|
1836 | ||
|
1837 | cur_gr = self.group | |
|
1838 | groups.insert(0, cur_gr) | |
|
1839 | while 1: | |
|
1840 | gr = getattr(cur_gr, 'parent_group', None) | |
|
1841 | cur_gr = cur_gr.parent_group | |
|
1842 | if gr is None: | |
|
1843 | break | |
|
1844 | groups.insert(0, gr) | |
|
1845 | ||
|
1846 | return groups | |
|
1847 | ||
|
1848 | @property | |
|
1849 | def groups_and_repo(self): | |
|
1850 | return self.groups_with_parents, self | |
|
1851 | ||
|
1852 | @LazyProperty | |
|
1853 | def repo_path(self): | |
|
1854 | """ | |
|
1855 | Returns base full path for that repository means where it actually | |
|
1856 | exists on a filesystem | |
|
1857 | """ | |
|
1858 | q = Session().query(RhodeCodeUi).filter( | |
|
1859 | RhodeCodeUi.ui_key == self.NAME_SEP) | |
|
1860 | q = q.options(FromCache("sql_cache_short", "repository_repo_path")) | |
|
1861 | return q.one().ui_value | |
|
1862 | ||
|
1863 | @property | |
|
1864 | def repo_full_path(self): | |
|
1865 | p = [self.repo_path] | |
|
1866 | # we need to split the name by / since this is how we store the | |
|
1867 | # names in the database, but that eventually needs to be converted | |
|
1868 | # into a valid system path | |
|
1869 | p += self.repo_name.split(self.NAME_SEP) | |
|
1870 | return os.path.join(*map(safe_unicode, p)) | |
|
1871 | ||
|
1872 | @property | |
|
1873 | def cache_keys(self): | |
|
1874 | """ | |
|
1875 | Returns associated cache keys for that repo | |
|
1876 | """ | |
|
1877 | invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format( | |
|
1878 | repo_id=self.repo_id) | |
|
1879 | return CacheKey.query()\ | |
|
1880 | .filter(CacheKey.cache_args == invalidation_namespace)\ | |
|
1881 | .order_by(CacheKey.cache_key)\ | |
|
1882 | .all() | |
|
1883 | ||
|
1884 | @property | |
|
1885 | def cached_diffs_relative_dir(self): | |
|
1886 | """ | |
|
1887 | Return a relative to the repository store path of cached diffs | |
|
1888 | used for safe display for users, who shouldn't know the absolute store | |
|
1889 | path | |
|
1890 | """ | |
|
1891 | return os.path.join( | |
|
1892 | os.path.dirname(self.repo_name), | |
|
1893 | self.cached_diffs_dir.split(os.path.sep)[-1]) | |
|
1894 | ||
|
1895 | @property | |
|
1896 | def cached_diffs_dir(self): | |
|
1897 | path = self.repo_full_path | |
|
1898 | return os.path.join( | |
|
1899 | os.path.dirname(path), | |
|
1900 | '.__shadow_diff_cache_repo_{}'.format(self.repo_id)) | |
|
1901 | ||
|
1902 | def cached_diffs(self): | |
|
1903 | diff_cache_dir = self.cached_diffs_dir | |
|
1904 | if os.path.isdir(diff_cache_dir): | |
|
1905 | return os.listdir(diff_cache_dir) | |
|
1906 | return [] | |
|
1907 | ||
|
1908 | def shadow_repos(self): | |
|
1909 | shadow_repos_pattern = '.__shadow_repo_{}'.format(self.repo_id) | |
|
1910 | return [ | |
|
1911 | x for x in os.listdir(os.path.dirname(self.repo_full_path)) | |
|
1912 | if x.startswith(shadow_repos_pattern)] | |
|
1913 | ||
|
1914 | def get_new_name(self, repo_name): | |
|
1915 | """ | |
|
1916 | returns new full repository name based on assigned group and new new | |
|
1917 | ||
|
1918 | :param group_name: | |
|
1919 | """ | |
|
1920 | path_prefix = self.group.full_path_splitted if self.group else [] | |
|
1921 | return self.NAME_SEP.join(path_prefix + [repo_name]) | |
|
1922 | ||
|
1923 | @property | |
|
1924 | def _config(self): | |
|
1925 | """ | |
|
1926 | Returns db based config object. | |
|
1927 | """ | |
|
1928 | from rhodecode.lib.utils import make_db_config | |
|
1929 | return make_db_config(clear_session=False, repo=self) | |
|
1930 | ||
|
1931 | def permissions(self, with_admins=True, with_owner=True): | |
|
1932 | """ | |
|
1933 | Permissions for repositories | |
|
1934 | """ | |
|
1935 | _admin_perm = 'repository.admin' | |
|
1936 | ||
|
1937 | owner_row = [] | |
|
1938 | if with_owner: | |
|
1939 | usr = AttributeDict(self.user.get_dict()) | |
|
1940 | usr.owner_row = True | |
|
1941 | usr.permission = _admin_perm | |
|
1942 | usr.permission_id = None | |
|
1943 | owner_row.append(usr) | |
|
1944 | ||
|
1945 | super_admin_ids = [] | |
|
1946 | super_admin_rows = [] | |
|
1947 | if with_admins: | |
|
1948 | for usr in User.get_all_super_admins(): | |
|
1949 | super_admin_ids.append(usr.user_id) | |
|
1950 | # if this admin is also owner, don't double the record | |
|
1951 | if usr.user_id == owner_row[0].user_id: | |
|
1952 | owner_row[0].admin_row = True | |
|
1953 | else: | |
|
1954 | usr = AttributeDict(usr.get_dict()) | |
|
1955 | usr.admin_row = True | |
|
1956 | usr.permission = _admin_perm | |
|
1957 | usr.permission_id = None | |
|
1958 | super_admin_rows.append(usr) | |
|
1959 | ||
|
1960 | q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self) | |
|
1961 | q = q.options(joinedload(UserRepoToPerm.repository), | |
|
1962 | joinedload(UserRepoToPerm.user), | |
|
1963 | joinedload(UserRepoToPerm.permission),) | |
|
1964 | ||
|
1965 | # get owners and admins and permissions. We do a trick of re-writing | |
|
1966 | # objects from sqlalchemy to named-tuples due to sqlalchemy session | |
|
1967 | # has a global reference and changing one object propagates to all | |
|
1968 | # others. This means if admin is also an owner admin_row that change | |
|
1969 | # would propagate to both objects | |
|
1970 | perm_rows = [] | |
|
1971 | for _usr in q.all(): | |
|
1972 | usr = AttributeDict(_usr.user.get_dict()) | |
|
1973 | # if this user is also owner/admin, mark as duplicate record | |
|
1974 | if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids: | |
|
1975 | usr.duplicate_perm = True | |
|
1976 | # also check if this permission is maybe used by branch_permissions | |
|
1977 | if _usr.branch_perm_entry: | |
|
1978 | usr.branch_rules = [x.branch_rule_id for x in _usr.branch_perm_entry] | |
|
1979 | ||
|
1980 | usr.permission = _usr.permission.permission_name | |
|
1981 | usr.permission_id = _usr.repo_to_perm_id | |
|
1982 | perm_rows.append(usr) | |
|
1983 | ||
|
1984 | # filter the perm rows by 'default' first and then sort them by | |
|
1985 | # admin,write,read,none permissions sorted again alphabetically in | |
|
1986 | # each group | |
|
1987 | perm_rows = sorted(perm_rows, key=display_user_sort) | |
|
1988 | ||
|
1989 | return super_admin_rows + owner_row + perm_rows | |
|
1990 | ||
|
1991 | def permission_user_groups(self): | |
|
1992 | q = UserGroupRepoToPerm.query().filter( | |
|
1993 | UserGroupRepoToPerm.repository == self) | |
|
1994 | q = q.options(joinedload(UserGroupRepoToPerm.repository), | |
|
1995 | joinedload(UserGroupRepoToPerm.users_group), | |
|
1996 | joinedload(UserGroupRepoToPerm.permission),) | |
|
1997 | ||
|
1998 | perm_rows = [] | |
|
1999 | for _user_group in q.all(): | |
|
2000 | usr = AttributeDict(_user_group.users_group.get_dict()) | |
|
2001 | usr.permission = _user_group.permission.permission_name | |
|
2002 | perm_rows.append(usr) | |
|
2003 | ||
|
2004 | perm_rows = sorted(perm_rows, key=display_user_group_sort) | |
|
2005 | return perm_rows | |
|
2006 | ||
|
2007 | def get_api_data(self, include_secrets=False): | |
|
2008 | """ | |
|
2009 | Common function for generating repo api data | |
|
2010 | ||
|
2011 | :param include_secrets: See :meth:`User.get_api_data`. | |
|
2012 | ||
|
2013 | """ | |
|
2014 | # TODO: mikhail: Here there is an anti-pattern, we probably need to | |
|
2015 | # move this methods on models level. | |
|
2016 | from rhodecode.model.settings import SettingsModel | |
|
2017 | from rhodecode.model.repo import RepoModel | |
|
2018 | ||
|
2019 | repo = self | |
|
2020 | _user_id, _time, _reason = self.locked | |
|
2021 | ||
|
2022 | data = { | |
|
2023 | 'repo_id': repo.repo_id, | |
|
2024 | 'repo_name': repo.repo_name, | |
|
2025 | 'repo_type': repo.repo_type, | |
|
2026 | 'clone_uri': repo.clone_uri or '', | |
|
2027 | 'push_uri': repo.push_uri or '', | |
|
2028 | 'url': RepoModel().get_url(self), | |
|
2029 | 'private': repo.private, | |
|
2030 | 'created_on': repo.created_on, | |
|
2031 | 'description': repo.description_safe, | |
|
2032 | 'landing_rev': repo.landing_rev, | |
|
2033 | 'owner': repo.user.username, | |
|
2034 | 'fork_of': repo.fork.repo_name if repo.fork else None, | |
|
2035 | 'fork_of_id': repo.fork.repo_id if repo.fork else None, | |
|
2036 | 'enable_statistics': repo.enable_statistics, | |
|
2037 | 'enable_locking': repo.enable_locking, | |
|
2038 | 'enable_downloads': repo.enable_downloads, | |
|
2039 | 'last_changeset': repo.changeset_cache, | |
|
2040 | 'locked_by': User.get(_user_id).get_api_data( | |
|
2041 | include_secrets=include_secrets) if _user_id else None, | |
|
2042 | 'locked_date': time_to_datetime(_time) if _time else None, | |
|
2043 | 'lock_reason': _reason if _reason else None, | |
|
2044 | } | |
|
2045 | ||
|
2046 | # TODO: mikhail: should be per-repo settings here | |
|
2047 | rc_config = SettingsModel().get_all_settings() | |
|
2048 | repository_fields = str2bool( | |
|
2049 | rc_config.get('rhodecode_repository_fields')) | |
|
2050 | if repository_fields: | |
|
2051 | for f in self.extra_fields: | |
|
2052 | data[f.field_key_prefixed] = f.field_value | |
|
2053 | ||
|
2054 | return data | |
|
2055 | ||
|
2056 | @classmethod | |
|
2057 | def lock(cls, repo, user_id, lock_time=None, lock_reason=None): | |
|
2058 | if not lock_time: | |
|
2059 | lock_time = time.time() | |
|
2060 | if not lock_reason: | |
|
2061 | lock_reason = cls.LOCK_AUTOMATIC | |
|
2062 | repo.locked = [user_id, lock_time, lock_reason] | |
|
2063 | Session().add(repo) | |
|
2064 | Session().commit() | |
|
2065 | ||
|
2066 | @classmethod | |
|
2067 | def unlock(cls, repo): | |
|
2068 | repo.locked = None | |
|
2069 | Session().add(repo) | |
|
2070 | Session().commit() | |
|
2071 | ||
|
2072 | @classmethod | |
|
2073 | def getlock(cls, repo): | |
|
2074 | return repo.locked | |
|
2075 | ||
|
2076 | def is_user_lock(self, user_id): | |
|
2077 | if self.lock[0]: | |
|
2078 | lock_user_id = safe_int(self.lock[0]) | |
|
2079 | user_id = safe_int(user_id) | |
|
2080 | # both are ints, and they are equal | |
|
2081 | return all([lock_user_id, user_id]) and lock_user_id == user_id | |
|
2082 | ||
|
2083 | return False | |
|
2084 | ||
|
2085 | def get_locking_state(self, action, user_id, only_when_enabled=True): | |
|
2086 | """ | |
|
2087 | Checks locking on this repository, if locking is enabled and lock is | |
|
2088 | present returns a tuple of make_lock, locked, locked_by. | |
|
2089 | make_lock can have 3 states None (do nothing) True, make lock | |
|
2090 | False release lock, This value is later propagated to hooks, which | |
|
2091 | do the locking. Think about this as signals passed to hooks what to do. | |
|
2092 | ||
|
2093 | """ | |
|
2094 | # TODO: johbo: This is part of the business logic and should be moved | |
|
2095 | # into the RepositoryModel. | |
|
2096 | ||
|
2097 | if action not in ('push', 'pull'): | |
|
2098 | raise ValueError("Invalid action value: %s" % repr(action)) | |
|
2099 | ||
|
2100 | # defines if locked error should be thrown to user | |
|
2101 | currently_locked = False | |
|
2102 | # defines if new lock should be made, tri-state | |
|
2103 | make_lock = None | |
|
2104 | repo = self | |
|
2105 | user = User.get(user_id) | |
|
2106 | ||
|
2107 | lock_info = repo.locked | |
|
2108 | ||
|
2109 | if repo and (repo.enable_locking or not only_when_enabled): | |
|
2110 | if action == 'push': | |
|
2111 | # check if it's already locked !, if it is compare users | |
|
2112 | locked_by_user_id = lock_info[0] | |
|
2113 | if user.user_id == locked_by_user_id: | |
|
2114 | log.debug( | |
|
2115 | 'Got `push` action from user %s, now unlocking', user) | |
|
2116 | # unlock if we have push from user who locked | |
|
2117 | make_lock = False | |
|
2118 | else: | |
|
2119 | # we're not the same user who locked, ban with | |
|
2120 | # code defined in settings (default is 423 HTTP Locked) ! | |
|
2121 | log.debug('Repo %s is currently locked by %s', repo, user) | |
|
2122 | currently_locked = True | |
|
2123 | elif action == 'pull': | |
|
2124 | # [0] user [1] date | |
|
2125 | if lock_info[0] and lock_info[1]: | |
|
2126 | log.debug('Repo %s is currently locked by %s', repo, user) | |
|
2127 | currently_locked = True | |
|
2128 | else: | |
|
2129 | log.debug('Setting lock on repo %s by %s', repo, user) | |
|
2130 | make_lock = True | |
|
2131 | ||
|
2132 | else: | |
|
2133 | log.debug('Repository %s do not have locking enabled', repo) | |
|
2134 | ||
|
2135 | log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s', | |
|
2136 | make_lock, currently_locked, lock_info) | |
|
2137 | ||
|
2138 | from rhodecode.lib.auth import HasRepoPermissionAny | |
|
2139 | perm_check = HasRepoPermissionAny('repository.write', 'repository.admin') | |
|
2140 | if make_lock and not perm_check(repo_name=repo.repo_name, user=user): | |
|
2141 | # if we don't have at least write permission we cannot make a lock | |
|
2142 | log.debug('lock state reset back to FALSE due to lack ' | |
|
2143 | 'of at least read permission') | |
|
2144 | make_lock = False | |
|
2145 | ||
|
2146 | return make_lock, currently_locked, lock_info | |
|
2147 | ||
|
2148 | @property | |
|
2149 | def last_db_change(self): | |
|
2150 | return self.updated_on | |
|
2151 | ||
|
2152 | @property | |
|
2153 | def clone_uri_hidden(self): | |
|
2154 | clone_uri = self.clone_uri | |
|
2155 | if clone_uri: | |
|
2156 | import urlobject | |
|
2157 | url_obj = urlobject.URLObject(cleaned_uri(clone_uri)) | |
|
2158 | if url_obj.password: | |
|
2159 | clone_uri = url_obj.with_password('*****') | |
|
2160 | return clone_uri | |
|
2161 | ||
|
2162 | @property | |
|
2163 | def push_uri_hidden(self): | |
|
2164 | push_uri = self.push_uri | |
|
2165 | if push_uri: | |
|
2166 | import urlobject | |
|
2167 | url_obj = urlobject.URLObject(cleaned_uri(push_uri)) | |
|
2168 | if url_obj.password: | |
|
2169 | push_uri = url_obj.with_password('*****') | |
|
2170 | return push_uri | |
|
2171 | ||
|
2172 | def clone_url(self, **override): | |
|
2173 | from rhodecode.model.settings import SettingsModel | |
|
2174 | ||
|
2175 | uri_tmpl = None | |
|
2176 | if 'with_id' in override: | |
|
2177 | uri_tmpl = self.DEFAULT_CLONE_URI_ID | |
|
2178 | del override['with_id'] | |
|
2179 | ||
|
2180 | if 'uri_tmpl' in override: | |
|
2181 | uri_tmpl = override['uri_tmpl'] | |
|
2182 | del override['uri_tmpl'] | |
|
2183 | ||
|
2184 | ssh = False | |
|
2185 | if 'ssh' in override: | |
|
2186 | ssh = True | |
|
2187 | del override['ssh'] | |
|
2188 | ||
|
2189 | # we didn't override our tmpl from **overrides | |
|
2190 | if not uri_tmpl: | |
|
2191 | rc_config = SettingsModel().get_all_settings(cache=True) | |
|
2192 | if ssh: | |
|
2193 | uri_tmpl = rc_config.get( | |
|
2194 | 'rhodecode_clone_uri_ssh_tmpl') or self.DEFAULT_CLONE_URI_SSH | |
|
2195 | else: | |
|
2196 | uri_tmpl = rc_config.get( | |
|
2197 | 'rhodecode_clone_uri_tmpl') or self.DEFAULT_CLONE_URI | |
|
2198 | ||
|
2199 | request = get_current_request() | |
|
2200 | return get_clone_url(request=request, | |
|
2201 | uri_tmpl=uri_tmpl, | |
|
2202 | repo_name=self.repo_name, | |
|
2203 | repo_id=self.repo_id, **override) | |
|
2204 | ||
|
2205 | def set_state(self, state): | |
|
2206 | self.repo_state = state | |
|
2207 | Session().add(self) | |
|
2208 | #========================================================================== | |
|
2209 | # SCM PROPERTIES | |
|
2210 | #========================================================================== | |
|
2211 | ||
|
2212 | def get_commit(self, commit_id=None, commit_idx=None, pre_load=None): | |
|
2213 | return get_commit_safe( | |
|
2214 | self.scm_instance(), commit_id, commit_idx, pre_load=pre_load) | |
|
2215 | ||
|
2216 | def get_changeset(self, rev=None, pre_load=None): | |
|
2217 | warnings.warn("Use get_commit", DeprecationWarning) | |
|
2218 | commit_id = None | |
|
2219 | commit_idx = None | |
|
2220 | if isinstance(rev, basestring): | |
|
2221 | commit_id = rev | |
|
2222 | else: | |
|
2223 | commit_idx = rev | |
|
2224 | return self.get_commit(commit_id=commit_id, commit_idx=commit_idx, | |
|
2225 | pre_load=pre_load) | |
|
2226 | ||
|
2227 | def get_landing_commit(self): | |
|
2228 | """ | |
|
2229 | Returns landing commit, or if that doesn't exist returns the tip | |
|
2230 | """ | |
|
2231 | _rev_type, _rev = self.landing_rev | |
|
2232 | commit = self.get_commit(_rev) | |
|
2233 | if isinstance(commit, EmptyCommit): | |
|
2234 | return self.get_commit() | |
|
2235 | return commit | |
|
2236 | ||
|
2237 | def update_commit_cache(self, cs_cache=None, config=None): | |
|
2238 | """ | |
|
2239 | Update cache of last changeset for repository, keys should be:: | |
|
2240 | ||
|
2241 | short_id | |
|
2242 | raw_id | |
|
2243 | revision | |
|
2244 | parents | |
|
2245 | message | |
|
2246 | date | |
|
2247 | author | |
|
2248 | ||
|
2249 | :param cs_cache: | |
|
2250 | """ | |
|
2251 | from rhodecode.lib.vcs.backends.base import BaseChangeset | |
|
2252 | if cs_cache is None: | |
|
2253 | # use no-cache version here | |
|
2254 | scm_repo = self.scm_instance(cache=False, config=config) | |
|
2255 | ||
|
2256 | empty = scm_repo.is_empty() | |
|
2257 | if not empty: | |
|
2258 | cs_cache = scm_repo.get_commit( | |
|
2259 | pre_load=["author", "date", "message", "parents"]) | |
|
2260 | else: | |
|
2261 | cs_cache = EmptyCommit() | |
|
2262 | ||
|
2263 | if isinstance(cs_cache, BaseChangeset): | |
|
2264 | cs_cache = cs_cache.__json__() | |
|
2265 | ||
|
2266 | def is_outdated(new_cs_cache): | |
|
2267 | if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or | |
|
2268 | new_cs_cache['revision'] != self.changeset_cache['revision']): | |
|
2269 | return True | |
|
2270 | return False | |
|
2271 | ||
|
2272 | # check if we have maybe already latest cached revision | |
|
2273 | if is_outdated(cs_cache) or not self.changeset_cache: | |
|
2274 | _default = datetime.datetime.utcnow() | |
|
2275 | last_change = cs_cache.get('date') or _default | |
|
2276 | if self.updated_on and self.updated_on > last_change: | |
|
2277 | # we check if last update is newer than the new value | |
|
2278 | # if yes, we use the current timestamp instead. Imagine you get | |
|
2279 | # old commit pushed 1y ago, we'd set last update 1y to ago. | |
|
2280 | last_change = _default | |
|
2281 | log.debug('updated repo %s with new cs cache %s', | |
|
2282 | self.repo_name, cs_cache) | |
|
2283 | self.updated_on = last_change | |
|
2284 | self.changeset_cache = cs_cache | |
|
2285 | Session().add(self) | |
|
2286 | Session().commit() | |
|
2287 | else: | |
|
2288 | log.debug('Skipping update_commit_cache for repo:`%s` ' | |
|
2289 | 'commit already with latest changes', self.repo_name) | |
|
2290 | ||
|
2291 | @property | |
|
2292 | def tip(self): | |
|
2293 | return self.get_commit('tip') | |
|
2294 | ||
|
2295 | @property | |
|
2296 | def author(self): | |
|
2297 | return self.tip.author | |
|
2298 | ||
|
2299 | @property | |
|
2300 | def last_change(self): | |
|
2301 | return self.scm_instance().last_change | |
|
2302 | ||
|
2303 | def get_comments(self, revisions=None): | |
|
2304 | """ | |
|
2305 | Returns comments for this repository grouped by revisions | |
|
2306 | ||
|
2307 | :param revisions: filter query by revisions only | |
|
2308 | """ | |
|
2309 | cmts = ChangesetComment.query()\ | |
|
2310 | .filter(ChangesetComment.repo == self) | |
|
2311 | if revisions: | |
|
2312 | cmts = cmts.filter(ChangesetComment.revision.in_(revisions)) | |
|
2313 | grouped = collections.defaultdict(list) | |
|
2314 | for cmt in cmts.all(): | |
|
2315 | grouped[cmt.revision].append(cmt) | |
|
2316 | return grouped | |
|
2317 | ||
|
2318 | def statuses(self, revisions=None): | |
|
2319 | """ | |
|
2320 | Returns statuses for this repository | |
|
2321 | ||
|
2322 | :param revisions: list of revisions to get statuses for | |
|
2323 | """ | |
|
2324 | statuses = ChangesetStatus.query()\ | |
|
2325 | .filter(ChangesetStatus.repo == self)\ | |
|
2326 | .filter(ChangesetStatus.version == 0) | |
|
2327 | ||
|
2328 | if revisions: | |
|
2329 | # Try doing the filtering in chunks to avoid hitting limits | |
|
2330 | size = 500 | |
|
2331 | status_results = [] | |
|
2332 | for chunk in xrange(0, len(revisions), size): | |
|
2333 | status_results += statuses.filter( | |
|
2334 | ChangesetStatus.revision.in_( | |
|
2335 | revisions[chunk: chunk+size]) | |
|
2336 | ).all() | |
|
2337 | else: | |
|
2338 | status_results = statuses.all() | |
|
2339 | ||
|
2340 | grouped = {} | |
|
2341 | ||
|
2342 | # maybe we have open new pullrequest without a status? | |
|
2343 | stat = ChangesetStatus.STATUS_UNDER_REVIEW | |
|
2344 | status_lbl = ChangesetStatus.get_status_lbl(stat) | |
|
2345 | for pr in PullRequest.query().filter(PullRequest.source_repo == self).all(): | |
|
2346 | for rev in pr.revisions: | |
|
2347 | pr_id = pr.pull_request_id | |
|
2348 | pr_repo = pr.target_repo.repo_name | |
|
2349 | grouped[rev] = [stat, status_lbl, pr_id, pr_repo] | |
|
2350 | ||
|
2351 | for stat in status_results: | |
|
2352 | pr_id = pr_repo = None | |
|
2353 | if stat.pull_request: | |
|
2354 | pr_id = stat.pull_request.pull_request_id | |
|
2355 | pr_repo = stat.pull_request.target_repo.repo_name | |
|
2356 | grouped[stat.revision] = [str(stat.status), stat.status_lbl, | |
|
2357 | pr_id, pr_repo] | |
|
2358 | return grouped | |
|
2359 | ||
|
2360 | # ========================================================================== | |
|
2361 | # SCM CACHE INSTANCE | |
|
2362 | # ========================================================================== | |
|
2363 | ||
|
2364 | def scm_instance(self, **kwargs): | |
|
2365 | import rhodecode | |
|
2366 | ||
|
2367 | # Passing a config will not hit the cache currently only used | |
|
2368 | # for repo2dbmapper | |
|
2369 | config = kwargs.pop('config', None) | |
|
2370 | cache = kwargs.pop('cache', None) | |
|
2371 | full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache')) | |
|
2372 | # if cache is NOT defined use default global, else we have a full | |
|
2373 | # control over cache behaviour | |
|
2374 | if cache is None and full_cache and not config: | |
|
2375 | return self._get_instance_cached() | |
|
2376 | return self._get_instance(cache=bool(cache), config=config) | |
|
2377 | ||
|
2378 | def _get_instance_cached(self): | |
|
2379 | from rhodecode.lib import rc_cache | |
|
2380 | ||
|
2381 | cache_namespace_uid = 'cache_repo_instance.{}'.format(self.repo_id) | |
|
2382 | invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format( | |
|
2383 | repo_id=self.repo_id) | |
|
2384 | region = rc_cache.get_or_create_region('cache_repo_longterm', cache_namespace_uid) | |
|
2385 | ||
|
2386 | @region.conditional_cache_on_arguments(namespace=cache_namespace_uid) | |
|
2387 | def get_instance_cached(repo_id, context_id): | |
|
2388 | return self._get_instance() | |
|
2389 | ||
|
2390 | # we must use thread scoped cache here, | |
|
2391 | # because each thread of gevent needs it's own not shared connection and cache | |
|
2392 | # we also alter `args` so the cache key is individual for every green thread. | |
|
2393 | inv_context_manager = rc_cache.InvalidationContext( | |
|
2394 | uid=cache_namespace_uid, invalidation_namespace=invalidation_namespace, | |
|
2395 | thread_scoped=True) | |
|
2396 | with inv_context_manager as invalidation_context: | |
|
2397 | args = (self.repo_id, inv_context_manager.cache_key) | |
|
2398 | # re-compute and store cache if we get invalidate signal | |
|
2399 | if invalidation_context.should_invalidate(): | |
|
2400 | instance = get_instance_cached.refresh(*args) | |
|
2401 | else: | |
|
2402 | instance = get_instance_cached(*args) | |
|
2403 | ||
|
2404 | log.debug( | |
|
2405 | 'Repo instance fetched in %.3fs', inv_context_manager.compute_time) | |
|
2406 | return instance | |
|
2407 | ||
|
2408 | def _get_instance(self, cache=True, config=None): | |
|
2409 | config = config or self._config | |
|
2410 | custom_wire = { | |
|
2411 | 'cache': cache # controls the vcs.remote cache | |
|
2412 | } | |
|
2413 | repo = get_vcs_instance( | |
|
2414 | repo_path=safe_str(self.repo_full_path), | |
|
2415 | config=config, | |
|
2416 | with_wire=custom_wire, | |
|
2417 | create=False, | |
|
2418 | _vcs_alias=self.repo_type) | |
|
2419 | ||
|
2420 | return repo | |
|
2421 | ||
|
2422 | def __json__(self): | |
|
2423 | return {'landing_rev': self.landing_rev} | |
|
2424 | ||
|
2425 | def get_dict(self): | |
|
2426 | ||
|
2427 | # Since we transformed `repo_name` to a hybrid property, we need to | |
|
2428 | # keep compatibility with the code which uses `repo_name` field. | |
|
2429 | ||
|
2430 | result = super(Repository, self).get_dict() | |
|
2431 | result['repo_name'] = result.pop('_repo_name', None) | |
|
2432 | return result | |
|
2433 | ||
|
2434 | ||
|
2435 | class RepoGroup(Base, BaseModel): | |
|
2436 | __tablename__ = 'groups' | |
|
2437 | __table_args__ = ( | |
|
2438 | UniqueConstraint('group_name', 'group_parent_id'), | |
|
2439 | CheckConstraint('group_id != group_parent_id'), | |
|
2440 | base_table_args, | |
|
2441 | ) | |
|
2442 | __mapper_args__ = {'order_by': 'group_name'} | |
|
2443 | ||
|
2444 | CHOICES_SEPARATOR = '/' # used to generate select2 choices for nested groups | |
|
2445 | ||
|
2446 | group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
2447 | group_name = Column("group_name", String(255), nullable=False, unique=True, default=None) | |
|
2448 | group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None) | |
|
2449 | group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None) | |
|
2450 | enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False) | |
|
2451 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None) | |
|
2452 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
|
2453 | updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now) | |
|
2454 | personal = Column('personal', Boolean(), nullable=True, unique=None, default=None) | |
|
2455 | ||
|
2456 | repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id') | |
|
2457 | users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all') | |
|
2458 | parent_group = relationship('RepoGroup', remote_side=group_id) | |
|
2459 | user = relationship('User') | |
|
2460 | integrations = relationship('Integration', | |
|
2461 | cascade="all, delete, delete-orphan") | |
|
2462 | ||
|
2463 | def __init__(self, group_name='', parent_group=None): | |
|
2464 | self.group_name = group_name | |
|
2465 | self.parent_group = parent_group | |
|
2466 | ||
|
2467 | def __unicode__(self): | |
|
2468 | return u"<%s('id:%s:%s')>" % ( | |
|
2469 | self.__class__.__name__, self.group_id, self.group_name) | |
|
2470 | ||
|
2471 | @hybrid_property | |
|
2472 | def description_safe(self): | |
|
2473 | from rhodecode.lib import helpers as h | |
|
2474 | return h.escape(self.group_description) | |
|
2475 | ||
|
2476 | @classmethod | |
|
2477 | def _generate_choice(cls, repo_group): | |
|
2478 | from webhelpers.html import literal as _literal | |
|
2479 | _name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k)) | |
|
2480 | return repo_group.group_id, _name(repo_group.full_path_splitted) | |
|
2481 | ||
|
2482 | @classmethod | |
|
2483 | def groups_choices(cls, groups=None, show_empty_group=True): | |
|
2484 | if not groups: | |
|
2485 | groups = cls.query().all() | |
|
2486 | ||
|
2487 | repo_groups = [] | |
|
2488 | if show_empty_group: | |
|
2489 | repo_groups = [(-1, u'-- %s --' % _('No parent'))] | |
|
2490 | ||
|
2491 | repo_groups.extend([cls._generate_choice(x) for x in groups]) | |
|
2492 | ||
|
2493 | repo_groups = sorted( | |
|
2494 | repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0]) | |
|
2495 | return repo_groups | |
|
2496 | ||
|
2497 | @classmethod | |
|
2498 | def url_sep(cls): | |
|
2499 | return URL_SEP | |
|
2500 | ||
|
2501 | @classmethod | |
|
2502 | def get_by_group_name(cls, group_name, cache=False, case_insensitive=False): | |
|
2503 | if case_insensitive: | |
|
2504 | gr = cls.query().filter(func.lower(cls.group_name) | |
|
2505 | == func.lower(group_name)) | |
|
2506 | else: | |
|
2507 | gr = cls.query().filter(cls.group_name == group_name) | |
|
2508 | if cache: | |
|
2509 | name_key = _hash_key(group_name) | |
|
2510 | gr = gr.options( | |
|
2511 | FromCache("sql_cache_short", "get_group_%s" % name_key)) | |
|
2512 | return gr.scalar() | |
|
2513 | ||
|
2514 | @classmethod | |
|
2515 | def get_user_personal_repo_group(cls, user_id): | |
|
2516 | user = User.get(user_id) | |
|
2517 | if user.username == User.DEFAULT_USER: | |
|
2518 | return None | |
|
2519 | ||
|
2520 | return cls.query()\ | |
|
2521 | .filter(cls.personal == true()) \ | |
|
2522 | .filter(cls.user == user) \ | |
|
2523 | .order_by(cls.group_id.asc()) \ | |
|
2524 | .first() | |
|
2525 | ||
|
2526 | @classmethod | |
|
2527 | def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None), | |
|
2528 | case_insensitive=True): | |
|
2529 | q = RepoGroup.query() | |
|
2530 | ||
|
2531 | if not isinstance(user_id, Optional): | |
|
2532 | q = q.filter(RepoGroup.user_id == user_id) | |
|
2533 | ||
|
2534 | if not isinstance(group_id, Optional): | |
|
2535 | q = q.filter(RepoGroup.group_parent_id == group_id) | |
|
2536 | ||
|
2537 | if case_insensitive: | |
|
2538 | q = q.order_by(func.lower(RepoGroup.group_name)) | |
|
2539 | else: | |
|
2540 | q = q.order_by(RepoGroup.group_name) | |
|
2541 | return q.all() | |
|
2542 | ||
|
2543 | @property | |
|
2544 | def parents(self): | |
|
2545 | parents_recursion_limit = 10 | |
|
2546 | groups = [] | |
|
2547 | if self.parent_group is None: | |
|
2548 | return groups | |
|
2549 | cur_gr = self.parent_group | |
|
2550 | groups.insert(0, cur_gr) | |
|
2551 | cnt = 0 | |
|
2552 | while 1: | |
|
2553 | cnt += 1 | |
|
2554 | gr = getattr(cur_gr, 'parent_group', None) | |
|
2555 | cur_gr = cur_gr.parent_group | |
|
2556 | if gr is None: | |
|
2557 | break | |
|
2558 | if cnt == parents_recursion_limit: | |
|
2559 | # this will prevent accidental infinit loops | |
|
2560 | log.error('more than %s parents found for group %s, stopping ' | |
|
2561 | 'recursive parent fetching', parents_recursion_limit, self) | |
|
2562 | break | |
|
2563 | ||
|
2564 | groups.insert(0, gr) | |
|
2565 | return groups | |
|
2566 | ||
|
2567 | @property | |
|
2568 | def last_db_change(self): | |
|
2569 | return self.updated_on | |
|
2570 | ||
|
2571 | @property | |
|
2572 | def children(self): | |
|
2573 | return RepoGroup.query().filter(RepoGroup.parent_group == self) | |
|
2574 | ||
|
2575 | @property | |
|
2576 | def name(self): | |
|
2577 | return self.group_name.split(RepoGroup.url_sep())[-1] | |
|
2578 | ||
|
2579 | @property | |
|
2580 | def full_path(self): | |
|
2581 | return self.group_name | |
|
2582 | ||
|
2583 | @property | |
|
2584 | def full_path_splitted(self): | |
|
2585 | return self.group_name.split(RepoGroup.url_sep()) | |
|
2586 | ||
|
2587 | @property | |
|
2588 | def repositories(self): | |
|
2589 | return Repository.query()\ | |
|
2590 | .filter(Repository.group == self)\ | |
|
2591 | .order_by(Repository.repo_name) | |
|
2592 | ||
|
2593 | @property | |
|
2594 | def repositories_recursive_count(self): | |
|
2595 | cnt = self.repositories.count() | |
|
2596 | ||
|
2597 | def children_count(group): | |
|
2598 | cnt = 0 | |
|
2599 | for child in group.children: | |
|
2600 | cnt += child.repositories.count() | |
|
2601 | cnt += children_count(child) | |
|
2602 | return cnt | |
|
2603 | ||
|
2604 | return cnt + children_count(self) | |
|
2605 | ||
|
2606 | def _recursive_objects(self, include_repos=True): | |
|
2607 | all_ = [] | |
|
2608 | ||
|
2609 | def _get_members(root_gr): | |
|
2610 | if include_repos: | |
|
2611 | for r in root_gr.repositories: | |
|
2612 | all_.append(r) | |
|
2613 | childs = root_gr.children.all() | |
|
2614 | if childs: | |
|
2615 | for gr in childs: | |
|
2616 | all_.append(gr) | |
|
2617 | _get_members(gr) | |
|
2618 | ||
|
2619 | _get_members(self) | |
|
2620 | return [self] + all_ | |
|
2621 | ||
|
2622 | def recursive_groups_and_repos(self): | |
|
2623 | """ | |
|
2624 | Recursive return all groups, with repositories in those groups | |
|
2625 | """ | |
|
2626 | return self._recursive_objects() | |
|
2627 | ||
|
2628 | def recursive_groups(self): | |
|
2629 | """ | |
|
2630 | Returns all children groups for this group including children of children | |
|
2631 | """ | |
|
2632 | return self._recursive_objects(include_repos=False) | |
|
2633 | ||
|
2634 | def get_new_name(self, group_name): | |
|
2635 | """ | |
|
2636 | returns new full group name based on parent and new name | |
|
2637 | ||
|
2638 | :param group_name: | |
|
2639 | """ | |
|
2640 | path_prefix = (self.parent_group.full_path_splitted if | |
|
2641 | self.parent_group else []) | |
|
2642 | return RepoGroup.url_sep().join(path_prefix + [group_name]) | |
|
2643 | ||
|
2644 | def permissions(self, with_admins=True, with_owner=True): | |
|
2645 | """ | |
|
2646 | Permissions for repository groups | |
|
2647 | """ | |
|
2648 | _admin_perm = 'group.admin' | |
|
2649 | ||
|
2650 | owner_row = [] | |
|
2651 | if with_owner: | |
|
2652 | usr = AttributeDict(self.user.get_dict()) | |
|
2653 | usr.owner_row = True | |
|
2654 | usr.permission = _admin_perm | |
|
2655 | owner_row.append(usr) | |
|
2656 | ||
|
2657 | super_admin_ids = [] | |
|
2658 | super_admin_rows = [] | |
|
2659 | if with_admins: | |
|
2660 | for usr in User.get_all_super_admins(): | |
|
2661 | super_admin_ids.append(usr.user_id) | |
|
2662 | # if this admin is also owner, don't double the record | |
|
2663 | if usr.user_id == owner_row[0].user_id: | |
|
2664 | owner_row[0].admin_row = True | |
|
2665 | else: | |
|
2666 | usr = AttributeDict(usr.get_dict()) | |
|
2667 | usr.admin_row = True | |
|
2668 | usr.permission = _admin_perm | |
|
2669 | super_admin_rows.append(usr) | |
|
2670 | ||
|
2671 | q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self) | |
|
2672 | q = q.options(joinedload(UserRepoGroupToPerm.group), | |
|
2673 | joinedload(UserRepoGroupToPerm.user), | |
|
2674 | joinedload(UserRepoGroupToPerm.permission),) | |
|
2675 | ||
|
2676 | # get owners and admins and permissions. We do a trick of re-writing | |
|
2677 | # objects from sqlalchemy to named-tuples due to sqlalchemy session | |
|
2678 | # has a global reference and changing one object propagates to all | |
|
2679 | # others. This means if admin is also an owner admin_row that change | |
|
2680 | # would propagate to both objects | |
|
2681 | perm_rows = [] | |
|
2682 | for _usr in q.all(): | |
|
2683 | usr = AttributeDict(_usr.user.get_dict()) | |
|
2684 | # if this user is also owner/admin, mark as duplicate record | |
|
2685 | if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids: | |
|
2686 | usr.duplicate_perm = True | |
|
2687 | usr.permission = _usr.permission.permission_name | |
|
2688 | perm_rows.append(usr) | |
|
2689 | ||
|
2690 | # filter the perm rows by 'default' first and then sort them by | |
|
2691 | # admin,write,read,none permissions sorted again alphabetically in | |
|
2692 | # each group | |
|
2693 | perm_rows = sorted(perm_rows, key=display_user_sort) | |
|
2694 | ||
|
2695 | return super_admin_rows + owner_row + perm_rows | |
|
2696 | ||
|
2697 | def permission_user_groups(self): | |
|
2698 | q = UserGroupRepoGroupToPerm.query().filter( | |
|
2699 | UserGroupRepoGroupToPerm.group == self) | |
|
2700 | q = q.options(joinedload(UserGroupRepoGroupToPerm.group), | |
|
2701 | joinedload(UserGroupRepoGroupToPerm.users_group), | |
|
2702 | joinedload(UserGroupRepoGroupToPerm.permission),) | |
|
2703 | ||
|
2704 | perm_rows = [] | |
|
2705 | for _user_group in q.all(): | |
|
2706 | usr = AttributeDict(_user_group.users_group.get_dict()) | |
|
2707 | usr.permission = _user_group.permission.permission_name | |
|
2708 | perm_rows.append(usr) | |
|
2709 | ||
|
2710 | perm_rows = sorted(perm_rows, key=display_user_group_sort) | |
|
2711 | return perm_rows | |
|
2712 | ||
|
2713 | def get_api_data(self): | |
|
2714 | """ | |
|
2715 | Common function for generating api data | |
|
2716 | ||
|
2717 | """ | |
|
2718 | group = self | |
|
2719 | data = { | |
|
2720 | 'group_id': group.group_id, | |
|
2721 | 'group_name': group.group_name, | |
|
2722 | 'group_description': group.description_safe, | |
|
2723 | 'parent_group': group.parent_group.group_name if group.parent_group else None, | |
|
2724 | 'repositories': [x.repo_name for x in group.repositories], | |
|
2725 | 'owner': group.user.username, | |
|
2726 | } | |
|
2727 | return data | |
|
2728 | ||
|
2729 | ||
|
2730 | class Permission(Base, BaseModel): | |
|
2731 | __tablename__ = 'permissions' | |
|
2732 | __table_args__ = ( | |
|
2733 | Index('p_perm_name_idx', 'permission_name'), | |
|
2734 | base_table_args, | |
|
2735 | ) | |
|
2736 | ||
|
2737 | PERMS = [ | |
|
2738 | ('hg.admin', _('RhodeCode Super Administrator')), | |
|
2739 | ||
|
2740 | ('repository.none', _('Repository no access')), | |
|
2741 | ('repository.read', _('Repository read access')), | |
|
2742 | ('repository.write', _('Repository write access')), | |
|
2743 | ('repository.admin', _('Repository admin access')), | |
|
2744 | ||
|
2745 | ('group.none', _('Repository group no access')), | |
|
2746 | ('group.read', _('Repository group read access')), | |
|
2747 | ('group.write', _('Repository group write access')), | |
|
2748 | ('group.admin', _('Repository group admin access')), | |
|
2749 | ||
|
2750 | ('usergroup.none', _('User group no access')), | |
|
2751 | ('usergroup.read', _('User group read access')), | |
|
2752 | ('usergroup.write', _('User group write access')), | |
|
2753 | ('usergroup.admin', _('User group admin access')), | |
|
2754 | ||
|
2755 | ('branch.none', _('Branch no permissions')), | |
|
2756 | ('branch.merge', _('Branch access by web merge')), | |
|
2757 | ('branch.push', _('Branch access by push')), | |
|
2758 | ('branch.push_force', _('Branch access by push with force')), | |
|
2759 | ||
|
2760 | ('hg.repogroup.create.false', _('Repository Group creation disabled')), | |
|
2761 | ('hg.repogroup.create.true', _('Repository Group creation enabled')), | |
|
2762 | ||
|
2763 | ('hg.usergroup.create.false', _('User Group creation disabled')), | |
|
2764 | ('hg.usergroup.create.true', _('User Group creation enabled')), | |
|
2765 | ||
|
2766 | ('hg.create.none', _('Repository creation disabled')), | |
|
2767 | ('hg.create.repository', _('Repository creation enabled')), | |
|
2768 | ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')), | |
|
2769 | ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')), | |
|
2770 | ||
|
2771 | ('hg.fork.none', _('Repository forking disabled')), | |
|
2772 | ('hg.fork.repository', _('Repository forking enabled')), | |
|
2773 | ||
|
2774 | ('hg.register.none', _('Registration disabled')), | |
|
2775 | ('hg.register.manual_activate', _('User Registration with manual account activation')), | |
|
2776 | ('hg.register.auto_activate', _('User Registration with automatic account activation')), | |
|
2777 | ||
|
2778 | ('hg.password_reset.enabled', _('Password reset enabled')), | |
|
2779 | ('hg.password_reset.hidden', _('Password reset hidden')), | |
|
2780 | ('hg.password_reset.disabled', _('Password reset disabled')), | |
|
2781 | ||
|
2782 | ('hg.extern_activate.manual', _('Manual activation of external account')), | |
|
2783 | ('hg.extern_activate.auto', _('Automatic activation of external account')), | |
|
2784 | ||
|
2785 | ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')), | |
|
2786 | ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')), | |
|
2787 | ] | |
|
2788 | ||
|
2789 | # definition of system default permissions for DEFAULT user, created on | |
|
2790 | # system setup | |
|
2791 | DEFAULT_USER_PERMISSIONS = [ | |
|
2792 | # object perms | |
|
2793 | 'repository.read', | |
|
2794 | 'group.read', | |
|
2795 | 'usergroup.read', | |
|
2796 | # branch, for backward compat we need same value as before so forced pushed | |
|
2797 | 'branch.push_force', | |
|
2798 | # global | |
|
2799 | 'hg.create.repository', | |
|
2800 | 'hg.repogroup.create.false', | |
|
2801 | 'hg.usergroup.create.false', | |
|
2802 | 'hg.create.write_on_repogroup.true', | |
|
2803 | 'hg.fork.repository', | |
|
2804 | 'hg.register.manual_activate', | |
|
2805 | 'hg.password_reset.enabled', | |
|
2806 | 'hg.extern_activate.auto', | |
|
2807 | 'hg.inherit_default_perms.true', | |
|
2808 | ] | |
|
2809 | ||
|
2810 | # defines which permissions are more important higher the more important | |
|
2811 | # Weight defines which permissions are more important. | |
|
2812 | # The higher number the more important. | |
|
2813 | PERM_WEIGHTS = { | |
|
2814 | 'repository.none': 0, | |
|
2815 | 'repository.read': 1, | |
|
2816 | 'repository.write': 3, | |
|
2817 | 'repository.admin': 4, | |
|
2818 | ||
|
2819 | 'group.none': 0, | |
|
2820 | 'group.read': 1, | |
|
2821 | 'group.write': 3, | |
|
2822 | 'group.admin': 4, | |
|
2823 | ||
|
2824 | 'usergroup.none': 0, | |
|
2825 | 'usergroup.read': 1, | |
|
2826 | 'usergroup.write': 3, | |
|
2827 | 'usergroup.admin': 4, | |
|
2828 | ||
|
2829 | 'branch.none': 0, | |
|
2830 | 'branch.merge': 1, | |
|
2831 | 'branch.push': 3, | |
|
2832 | 'branch.push_force': 4, | |
|
2833 | ||
|
2834 | 'hg.repogroup.create.false': 0, | |
|
2835 | 'hg.repogroup.create.true': 1, | |
|
2836 | ||
|
2837 | 'hg.usergroup.create.false': 0, | |
|
2838 | 'hg.usergroup.create.true': 1, | |
|
2839 | ||
|
2840 | 'hg.fork.none': 0, | |
|
2841 | 'hg.fork.repository': 1, | |
|
2842 | 'hg.create.none': 0, | |
|
2843 | 'hg.create.repository': 1 | |
|
2844 | } | |
|
2845 | ||
|
2846 | permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
2847 | permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None) | |
|
2848 | permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None) | |
|
2849 | ||
|
2850 | def __unicode__(self): | |
|
2851 | return u"<%s('%s:%s')>" % ( | |
|
2852 | self.__class__.__name__, self.permission_id, self.permission_name | |
|
2853 | ) | |
|
2854 | ||
|
2855 | @classmethod | |
|
2856 | def get_by_key(cls, key): | |
|
2857 | return cls.query().filter(cls.permission_name == key).scalar() | |
|
2858 | ||
|
2859 | @classmethod | |
|
2860 | def get_default_repo_perms(cls, user_id, repo_id=None): | |
|
2861 | q = Session().query(UserRepoToPerm, Repository, Permission)\ | |
|
2862 | .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\ | |
|
2863 | .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\ | |
|
2864 | .filter(UserRepoToPerm.user_id == user_id) | |
|
2865 | if repo_id: | |
|
2866 | q = q.filter(UserRepoToPerm.repository_id == repo_id) | |
|
2867 | return q.all() | |
|
2868 | ||
|
2869 | @classmethod | |
|
2870 | def get_default_repo_branch_perms(cls, user_id, repo_id=None): | |
|
2871 | q = Session().query(UserToRepoBranchPermission, UserRepoToPerm, Permission) \ | |
|
2872 | .join( | |
|
2873 | Permission, | |
|
2874 | UserToRepoBranchPermission.permission_id == Permission.permission_id) \ | |
|
2875 | .join( | |
|
2876 | UserRepoToPerm, | |
|
2877 | UserToRepoBranchPermission.rule_to_perm_id == UserRepoToPerm.repo_to_perm_id) \ | |
|
2878 | .filter(UserRepoToPerm.user_id == user_id) | |
|
2879 | ||
|
2880 | if repo_id: | |
|
2881 | q = q.filter(UserToRepoBranchPermission.repository_id == repo_id) | |
|
2882 | return q.order_by(UserToRepoBranchPermission.rule_order).all() | |
|
2883 | ||
|
2884 | @classmethod | |
|
2885 | def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None): | |
|
2886 | q = Session().query(UserGroupRepoToPerm, Repository, Permission)\ | |
|
2887 | .join( | |
|
2888 | Permission, | |
|
2889 | UserGroupRepoToPerm.permission_id == Permission.permission_id)\ | |
|
2890 | .join( | |
|
2891 | Repository, | |
|
2892 | UserGroupRepoToPerm.repository_id == Repository.repo_id)\ | |
|
2893 | .join( | |
|
2894 | UserGroup, | |
|
2895 | UserGroupRepoToPerm.users_group_id == | |
|
2896 | UserGroup.users_group_id)\ | |
|
2897 | .join( | |
|
2898 | UserGroupMember, | |
|
2899 | UserGroupRepoToPerm.users_group_id == | |
|
2900 | UserGroupMember.users_group_id)\ | |
|
2901 | .filter( | |
|
2902 | UserGroupMember.user_id == user_id, | |
|
2903 | UserGroup.users_group_active == true()) | |
|
2904 | if repo_id: | |
|
2905 | q = q.filter(UserGroupRepoToPerm.repository_id == repo_id) | |
|
2906 | return q.all() | |
|
2907 | ||
|
2908 | @classmethod | |
|
2909 | def get_default_repo_branch_perms_from_user_group(cls, user_id, repo_id=None): | |
|
2910 | q = Session().query(UserGroupToRepoBranchPermission, UserGroupRepoToPerm, Permission) \ | |
|
2911 | .join( | |
|
2912 | Permission, | |
|
2913 | UserGroupToRepoBranchPermission.permission_id == Permission.permission_id) \ | |
|
2914 | .join( | |
|
2915 | UserGroupRepoToPerm, | |
|
2916 | UserGroupToRepoBranchPermission.rule_to_perm_id == UserGroupRepoToPerm.users_group_to_perm_id) \ | |
|
2917 | .join( | |
|
2918 | UserGroup, | |
|
2919 | UserGroupRepoToPerm.users_group_id == UserGroup.users_group_id) \ | |
|
2920 | .join( | |
|
2921 | UserGroupMember, | |
|
2922 | UserGroupRepoToPerm.users_group_id == UserGroupMember.users_group_id) \ | |
|
2923 | .filter( | |
|
2924 | UserGroupMember.user_id == user_id, | |
|
2925 | UserGroup.users_group_active == true()) | |
|
2926 | ||
|
2927 | if repo_id: | |
|
2928 | q = q.filter(UserGroupToRepoBranchPermission.repository_id == repo_id) | |
|
2929 | return q.order_by(UserGroupToRepoBranchPermission.rule_order).all() | |
|
2930 | ||
|
2931 | @classmethod | |
|
2932 | def get_default_group_perms(cls, user_id, repo_group_id=None): | |
|
2933 | q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\ | |
|
2934 | .join( | |
|
2935 | Permission, | |
|
2936 | UserRepoGroupToPerm.permission_id == Permission.permission_id)\ | |
|
2937 | .join( | |
|
2938 | RepoGroup, | |
|
2939 | UserRepoGroupToPerm.group_id == RepoGroup.group_id)\ | |
|
2940 | .filter(UserRepoGroupToPerm.user_id == user_id) | |
|
2941 | if repo_group_id: | |
|
2942 | q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id) | |
|
2943 | return q.all() | |
|
2944 | ||
|
2945 | @classmethod | |
|
2946 | def get_default_group_perms_from_user_group( | |
|
2947 | cls, user_id, repo_group_id=None): | |
|
2948 | q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\ | |
|
2949 | .join( | |
|
2950 | Permission, | |
|
2951 | UserGroupRepoGroupToPerm.permission_id == | |
|
2952 | Permission.permission_id)\ | |
|
2953 | .join( | |
|
2954 | RepoGroup, | |
|
2955 | UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\ | |
|
2956 | .join( | |
|
2957 | UserGroup, | |
|
2958 | UserGroupRepoGroupToPerm.users_group_id == | |
|
2959 | UserGroup.users_group_id)\ | |
|
2960 | .join( | |
|
2961 | UserGroupMember, | |
|
2962 | UserGroupRepoGroupToPerm.users_group_id == | |
|
2963 | UserGroupMember.users_group_id)\ | |
|
2964 | .filter( | |
|
2965 | UserGroupMember.user_id == user_id, | |
|
2966 | UserGroup.users_group_active == true()) | |
|
2967 | if repo_group_id: | |
|
2968 | q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id) | |
|
2969 | return q.all() | |
|
2970 | ||
|
2971 | @classmethod | |
|
2972 | def get_default_user_group_perms(cls, user_id, user_group_id=None): | |
|
2973 | q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\ | |
|
2974 | .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\ | |
|
2975 | .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\ | |
|
2976 | .filter(UserUserGroupToPerm.user_id == user_id) | |
|
2977 | if user_group_id: | |
|
2978 | q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id) | |
|
2979 | return q.all() | |
|
2980 | ||
|
2981 | @classmethod | |
|
2982 | def get_default_user_group_perms_from_user_group( | |
|
2983 | cls, user_id, user_group_id=None): | |
|
2984 | TargetUserGroup = aliased(UserGroup, name='target_user_group') | |
|
2985 | q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\ | |
|
2986 | .join( | |
|
2987 | Permission, | |
|
2988 | UserGroupUserGroupToPerm.permission_id == | |
|
2989 | Permission.permission_id)\ | |
|
2990 | .join( | |
|
2991 | TargetUserGroup, | |
|
2992 | UserGroupUserGroupToPerm.target_user_group_id == | |
|
2993 | TargetUserGroup.users_group_id)\ | |
|
2994 | .join( | |
|
2995 | UserGroup, | |
|
2996 | UserGroupUserGroupToPerm.user_group_id == | |
|
2997 | UserGroup.users_group_id)\ | |
|
2998 | .join( | |
|
2999 | UserGroupMember, | |
|
3000 | UserGroupUserGroupToPerm.user_group_id == | |
|
3001 | UserGroupMember.users_group_id)\ | |
|
3002 | .filter( | |
|
3003 | UserGroupMember.user_id == user_id, | |
|
3004 | UserGroup.users_group_active == true()) | |
|
3005 | if user_group_id: | |
|
3006 | q = q.filter( | |
|
3007 | UserGroupUserGroupToPerm.user_group_id == user_group_id) | |
|
3008 | ||
|
3009 | return q.all() | |
|
3010 | ||
|
3011 | ||
|
3012 | class UserRepoToPerm(Base, BaseModel): | |
|
3013 | __tablename__ = 'repo_to_perm' | |
|
3014 | __table_args__ = ( | |
|
3015 | UniqueConstraint('user_id', 'repository_id', 'permission_id'), | |
|
3016 | base_table_args | |
|
3017 | ) | |
|
3018 | ||
|
3019 | repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
3020 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
|
3021 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
|
3022 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) | |
|
3023 | ||
|
3024 | user = relationship('User') | |
|
3025 | repository = relationship('Repository') | |
|
3026 | permission = relationship('Permission') | |
|
3027 | ||
|
3028 | branch_perm_entry = relationship('UserToRepoBranchPermission', cascade="all, delete, delete-orphan", lazy='joined') | |
|
3029 | ||
|
3030 | @classmethod | |
|
3031 | def create(cls, user, repository, permission): | |
|
3032 | n = cls() | |
|
3033 | n.user = user | |
|
3034 | n.repository = repository | |
|
3035 | n.permission = permission | |
|
3036 | Session().add(n) | |
|
3037 | return n | |
|
3038 | ||
|
3039 | def __unicode__(self): | |
|
3040 | return u'<%s => %s >' % (self.user, self.repository) | |
|
3041 | ||
|
3042 | ||
|
3043 | class UserUserGroupToPerm(Base, BaseModel): | |
|
3044 | __tablename__ = 'user_user_group_to_perm' | |
|
3045 | __table_args__ = ( | |
|
3046 | UniqueConstraint('user_id', 'user_group_id', 'permission_id'), | |
|
3047 | base_table_args | |
|
3048 | ) | |
|
3049 | ||
|
3050 | user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
3051 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
|
3052 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
|
3053 | user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
|
3054 | ||
|
3055 | user = relationship('User') | |
|
3056 | user_group = relationship('UserGroup') | |
|
3057 | permission = relationship('Permission') | |
|
3058 | ||
|
3059 | @classmethod | |
|
3060 | def create(cls, user, user_group, permission): | |
|
3061 | n = cls() | |
|
3062 | n.user = user | |
|
3063 | n.user_group = user_group | |
|
3064 | n.permission = permission | |
|
3065 | Session().add(n) | |
|
3066 | return n | |
|
3067 | ||
|
3068 | def __unicode__(self): | |
|
3069 | return u'<%s => %s >' % (self.user, self.user_group) | |
|
3070 | ||
|
3071 | ||
|
3072 | class UserToPerm(Base, BaseModel): | |
|
3073 | __tablename__ = 'user_to_perm' | |
|
3074 | __table_args__ = ( | |
|
3075 | UniqueConstraint('user_id', 'permission_id'), | |
|
3076 | base_table_args | |
|
3077 | ) | |
|
3078 | ||
|
3079 | user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
3080 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
|
3081 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
|
3082 | ||
|
3083 | user = relationship('User') | |
|
3084 | permission = relationship('Permission', lazy='joined') | |
|
3085 | ||
|
3086 | def __unicode__(self): | |
|
3087 | return u'<%s => %s >' % (self.user, self.permission) | |
|
3088 | ||
|
3089 | ||
|
3090 | class UserGroupRepoToPerm(Base, BaseModel): | |
|
3091 | __tablename__ = 'users_group_repo_to_perm' | |
|
3092 | __table_args__ = ( | |
|
3093 | UniqueConstraint('repository_id', 'users_group_id', 'permission_id'), | |
|
3094 | base_table_args | |
|
3095 | ) | |
|
3096 | ||
|
3097 | users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
3098 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
|
3099 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
|
3100 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) | |
|
3101 | ||
|
3102 | users_group = relationship('UserGroup') | |
|
3103 | permission = relationship('Permission') | |
|
3104 | repository = relationship('Repository') | |
|
3105 | user_group_branch_perms = relationship('UserGroupToRepoBranchPermission', cascade='all') | |
|
3106 | ||
|
3107 | @classmethod | |
|
3108 | def create(cls, users_group, repository, permission): | |
|
3109 | n = cls() | |
|
3110 | n.users_group = users_group | |
|
3111 | n.repository = repository | |
|
3112 | n.permission = permission | |
|
3113 | Session().add(n) | |
|
3114 | return n | |
|
3115 | ||
|
3116 | def __unicode__(self): | |
|
3117 | return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository) | |
|
3118 | ||
|
3119 | ||
|
3120 | class UserGroupUserGroupToPerm(Base, BaseModel): | |
|
3121 | __tablename__ = 'user_group_user_group_to_perm' | |
|
3122 | __table_args__ = ( | |
|
3123 | UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'), | |
|
3124 | CheckConstraint('target_user_group_id != user_group_id'), | |
|
3125 | base_table_args | |
|
3126 | ) | |
|
3127 | ||
|
3128 | 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) | |
|
3129 | target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
|
3130 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
|
3131 | user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
|
3132 | ||
|
3133 | target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id') | |
|
3134 | user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id') | |
|
3135 | permission = relationship('Permission') | |
|
3136 | ||
|
3137 | @classmethod | |
|
3138 | def create(cls, target_user_group, user_group, permission): | |
|
3139 | n = cls() | |
|
3140 | n.target_user_group = target_user_group | |
|
3141 | n.user_group = user_group | |
|
3142 | n.permission = permission | |
|
3143 | Session().add(n) | |
|
3144 | return n | |
|
3145 | ||
|
3146 | def __unicode__(self): | |
|
3147 | return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group) | |
|
3148 | ||
|
3149 | ||
|
3150 | class UserGroupToPerm(Base, BaseModel): | |
|
3151 | __tablename__ = 'users_group_to_perm' | |
|
3152 | __table_args__ = ( | |
|
3153 | UniqueConstraint('users_group_id', 'permission_id',), | |
|
3154 | base_table_args | |
|
3155 | ) | |
|
3156 | ||
|
3157 | users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
3158 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
|
3159 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
|
3160 | ||
|
3161 | users_group = relationship('UserGroup') | |
|
3162 | permission = relationship('Permission') | |
|
3163 | ||
|
3164 | ||
|
3165 | class UserRepoGroupToPerm(Base, BaseModel): | |
|
3166 | __tablename__ = 'user_repo_group_to_perm' | |
|
3167 | __table_args__ = ( | |
|
3168 | UniqueConstraint('user_id', 'group_id', 'permission_id'), | |
|
3169 | base_table_args | |
|
3170 | ) | |
|
3171 | ||
|
3172 | group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
3173 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
|
3174 | group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None) | |
|
3175 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
|
3176 | ||
|
3177 | user = relationship('User') | |
|
3178 | group = relationship('RepoGroup') | |
|
3179 | permission = relationship('Permission') | |
|
3180 | ||
|
3181 | @classmethod | |
|
3182 | def create(cls, user, repository_group, permission): | |
|
3183 | n = cls() | |
|
3184 | n.user = user | |
|
3185 | n.group = repository_group | |
|
3186 | n.permission = permission | |
|
3187 | Session().add(n) | |
|
3188 | return n | |
|
3189 | ||
|
3190 | ||
|
3191 | class UserGroupRepoGroupToPerm(Base, BaseModel): | |
|
3192 | __tablename__ = 'users_group_repo_group_to_perm' | |
|
3193 | __table_args__ = ( | |
|
3194 | UniqueConstraint('users_group_id', 'group_id'), | |
|
3195 | base_table_args | |
|
3196 | ) | |
|
3197 | ||
|
3198 | 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) | |
|
3199 | users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None) | |
|
3200 | group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None) | |
|
3201 | permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
|
3202 | ||
|
3203 | users_group = relationship('UserGroup') | |
|
3204 | permission = relationship('Permission') | |
|
3205 | group = relationship('RepoGroup') | |
|
3206 | ||
|
3207 | @classmethod | |
|
3208 | def create(cls, user_group, repository_group, permission): | |
|
3209 | n = cls() | |
|
3210 | n.users_group = user_group | |
|
3211 | n.group = repository_group | |
|
3212 | n.permission = permission | |
|
3213 | Session().add(n) | |
|
3214 | return n | |
|
3215 | ||
|
3216 | def __unicode__(self): | |
|
3217 | return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group) | |
|
3218 | ||
|
3219 | ||
|
3220 | class Statistics(Base, BaseModel): | |
|
3221 | __tablename__ = 'statistics' | |
|
3222 | __table_args__ = ( | |
|
3223 | base_table_args | |
|
3224 | ) | |
|
3225 | ||
|
3226 | stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
3227 | repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None) | |
|
3228 | stat_on_revision = Column("stat_on_revision", Integer(), nullable=False) | |
|
3229 | commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data | |
|
3230 | commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data | |
|
3231 | languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data | |
|
3232 | ||
|
3233 | repository = relationship('Repository', single_parent=True) | |
|
3234 | ||
|
3235 | ||
|
3236 | class UserFollowing(Base, BaseModel): | |
|
3237 | __tablename__ = 'user_followings' | |
|
3238 | __table_args__ = ( | |
|
3239 | UniqueConstraint('user_id', 'follows_repository_id'), | |
|
3240 | UniqueConstraint('user_id', 'follows_user_id'), | |
|
3241 | base_table_args | |
|
3242 | ) | |
|
3243 | ||
|
3244 | user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
3245 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None) | |
|
3246 | follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None) | |
|
3247 | follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None) | |
|
3248 | follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now) | |
|
3249 | ||
|
3250 | user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id') | |
|
3251 | ||
|
3252 | follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id') | |
|
3253 | follows_repository = relationship('Repository', order_by='Repository.repo_name') | |
|
3254 | ||
|
3255 | @classmethod | |
|
3256 | def get_repo_followers(cls, repo_id): | |
|
3257 | return cls.query().filter(cls.follows_repo_id == repo_id) | |
|
3258 | ||
|
3259 | ||
|
3260 | class CacheKey(Base, BaseModel): | |
|
3261 | __tablename__ = 'cache_invalidation' | |
|
3262 | __table_args__ = ( | |
|
3263 | UniqueConstraint('cache_key'), | |
|
3264 | Index('key_idx', 'cache_key'), | |
|
3265 | base_table_args, | |
|
3266 | ) | |
|
3267 | ||
|
3268 | CACHE_TYPE_FEED = 'FEED' | |
|
3269 | CACHE_TYPE_README = 'README' | |
|
3270 | # namespaces used to register process/thread aware caches | |
|
3271 | REPO_INVALIDATION_NAMESPACE = 'repo_cache:{repo_id}' | |
|
3272 | SETTINGS_INVALIDATION_NAMESPACE = 'system_settings' | |
|
3273 | ||
|
3274 | cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True) | |
|
3275 | cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None) | |
|
3276 | cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None) | |
|
3277 | cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False) | |
|
3278 | ||
|
3279 | def __init__(self, cache_key, cache_args=''): | |
|
3280 | self.cache_key = cache_key | |
|
3281 | self.cache_args = cache_args | |
|
3282 | self.cache_active = False | |
|
3283 | ||
|
3284 | def __unicode__(self): | |
|
3285 | return u"<%s('%s:%s[%s]')>" % ( | |
|
3286 | self.__class__.__name__, | |
|
3287 | self.cache_id, self.cache_key, self.cache_active) | |
|
3288 | ||
|
3289 | def _cache_key_partition(self): | |
|
3290 | prefix, repo_name, suffix = self.cache_key.partition(self.cache_args) | |
|
3291 | return prefix, repo_name, suffix | |
|
3292 | ||
|
3293 | def get_prefix(self): | |
|
3294 | """ | |
|
3295 | Try to extract prefix from existing cache key. The key could consist | |
|
3296 | of prefix, repo_name, suffix | |
|
3297 | """ | |
|
3298 | # this returns prefix, repo_name, suffix | |
|
3299 | return self._cache_key_partition()[0] | |
|
3300 | ||
|
3301 | def get_suffix(self): | |
|
3302 | """ | |
|
3303 | get suffix that might have been used in _get_cache_key to | |
|
3304 | generate self.cache_key. Only used for informational purposes | |
|
3305 | in repo_edit.mako. | |
|
3306 | """ | |
|
3307 | # prefix, repo_name, suffix | |
|
3308 | return self._cache_key_partition()[2] | |
|
3309 | ||
|
3310 | @classmethod | |
|
3311 | def delete_all_cache(cls): | |
|
3312 | """ | |
|
3313 | Delete all cache keys from database. | |
|
3314 | Should only be run when all instances are down and all entries | |
|
3315 | thus stale. | |
|
3316 | """ | |
|
3317 | cls.query().delete() | |
|
3318 | Session().commit() | |
|
3319 | ||
|
3320 | @classmethod | |
|
3321 | def set_invalidate(cls, cache_uid, delete=False): | |
|
3322 | """ | |
|
3323 | Mark all caches of a repo as invalid in the database. | |
|
3324 | """ | |
|
3325 | ||
|
3326 | try: | |
|
3327 | qry = Session().query(cls).filter(cls.cache_args == cache_uid) | |
|
3328 | if delete: | |
|
3329 | qry.delete() | |
|
3330 | log.debug('cache objects deleted for cache args %s', | |
|
3331 | safe_str(cache_uid)) | |
|
3332 | else: | |
|
3333 | qry.update({"cache_active": False}) | |
|
3334 | log.debug('cache objects marked as invalid for cache args %s', | |
|
3335 | safe_str(cache_uid)) | |
|
3336 | ||
|
3337 | Session().commit() | |
|
3338 | except Exception: | |
|
3339 | log.exception( | |
|
3340 | 'Cache key invalidation failed for cache args %s', | |
|
3341 | safe_str(cache_uid)) | |
|
3342 | Session().rollback() | |
|
3343 | ||
|
3344 | @classmethod | |
|
3345 | def get_active_cache(cls, cache_key): | |
|
3346 | inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar() | |
|
3347 | if inv_obj: | |
|
3348 | return inv_obj | |
|
3349 | return None | |
|
3350 | ||
|
3351 | ||
|
3352 | class ChangesetComment(Base, BaseModel): | |
|
3353 | __tablename__ = 'changeset_comments' | |
|
3354 | __table_args__ = ( | |
|
3355 | Index('cc_revision_idx', 'revision'), | |
|
3356 | base_table_args, | |
|
3357 | ) | |
|
3358 | ||
|
3359 | COMMENT_OUTDATED = u'comment_outdated' | |
|
3360 | COMMENT_TYPE_NOTE = u'note' | |
|
3361 | COMMENT_TYPE_TODO = u'todo' | |
|
3362 | COMMENT_TYPES = [COMMENT_TYPE_NOTE, COMMENT_TYPE_TODO] | |
|
3363 | ||
|
3364 | comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True) | |
|
3365 | repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False) | |
|
3366 | revision = Column('revision', String(40), nullable=True) | |
|
3367 | pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True) | |
|
3368 | pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True) | |
|
3369 | line_no = Column('line_no', Unicode(10), nullable=True) | |
|
3370 | hl_lines = Column('hl_lines', Unicode(512), nullable=True) | |
|
3371 | f_path = Column('f_path', Unicode(1000), nullable=True) | |
|
3372 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False) | |
|
3373 | text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False) | |
|
3374 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
|
3375 | modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
|
3376 | renderer = Column('renderer', Unicode(64), nullable=True) | |
|
3377 | display_state = Column('display_state', Unicode(128), nullable=True) | |
|
3378 | ||
|
3379 | comment_type = Column('comment_type', Unicode(128), nullable=True, default=COMMENT_TYPE_NOTE) | |
|
3380 | resolved_comment_id = Column('resolved_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=True) | |
|
3381 | ||
|
3382 | resolved_comment = relationship('ChangesetComment', remote_side=comment_id, back_populates='resolved_by') | |
|
3383 | resolved_by = relationship('ChangesetComment', back_populates='resolved_comment') | |
|
3384 | ||
|
3385 | author = relationship('User', lazy='joined') | |
|
3386 | repo = relationship('Repository') | |
|
3387 | status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan", lazy='joined') | |
|
3388 | pull_request = relationship('PullRequest', lazy='joined') | |
|
3389 | pull_request_version = relationship('PullRequestVersion') | |
|
3390 | ||
|
3391 | @classmethod | |
|
3392 | def get_users(cls, revision=None, pull_request_id=None): | |
|
3393 | """ | |
|
3394 | Returns user associated with this ChangesetComment. ie those | |
|
3395 | who actually commented | |
|
3396 | ||
|
3397 | :param cls: | |
|
3398 | :param revision: | |
|
3399 | """ | |
|
3400 | q = Session().query(User)\ | |
|
3401 | .join(ChangesetComment.author) | |
|
3402 | if revision: | |
|
3403 | q = q.filter(cls.revision == revision) | |
|
3404 | elif pull_request_id: | |
|
3405 | q = q.filter(cls.pull_request_id == pull_request_id) | |
|
3406 | return q.all() | |
|
3407 | ||
|
3408 | @classmethod | |
|
3409 | def get_index_from_version(cls, pr_version, versions): | |
|
3410 | num_versions = [x.pull_request_version_id for x in versions] | |
|
3411 | try: | |
|
3412 | return num_versions.index(pr_version) +1 | |
|
3413 | except (IndexError, ValueError): | |
|
3414 | return | |
|
3415 | ||
|
3416 | @property | |
|
3417 | def outdated(self): | |
|
3418 | return self.display_state == self.COMMENT_OUTDATED | |
|
3419 | ||
|
3420 | def outdated_at_version(self, version): | |
|
3421 | """ | |
|
3422 | Checks if comment is outdated for given pull request version | |
|
3423 | """ | |
|
3424 | return self.outdated and self.pull_request_version_id != version | |
|
3425 | ||
|
3426 | def older_than_version(self, version): | |
|
3427 | """ | |
|
3428 | Checks if comment is made from previous version than given | |
|
3429 | """ | |
|
3430 | if version is None: | |
|
3431 | return self.pull_request_version_id is not None | |
|
3432 | ||
|
3433 | return self.pull_request_version_id < version | |
|
3434 | ||
|
3435 | @property | |
|
3436 | def resolved(self): | |
|
3437 | return self.resolved_by[0] if self.resolved_by else None | |
|
3438 | ||
|
3439 | @property | |
|
3440 | def is_todo(self): | |
|
3441 | return self.comment_type == self.COMMENT_TYPE_TODO | |
|
3442 | ||
|
3443 | @property | |
|
3444 | def is_inline(self): | |
|
3445 | return self.line_no and self.f_path | |
|
3446 | ||
|
3447 | def get_index_version(self, versions): | |
|
3448 | return self.get_index_from_version( | |
|
3449 | self.pull_request_version_id, versions) | |
|
3450 | ||
|
3451 | def __repr__(self): | |
|
3452 | if self.comment_id: | |
|
3453 | return '<DB:Comment #%s>' % self.comment_id | |
|
3454 | else: | |
|
3455 | return '<DB:Comment at %#x>' % id(self) | |
|
3456 | ||
|
3457 | def get_api_data(self): | |
|
3458 | comment = self | |
|
3459 | data = { | |
|
3460 | 'comment_id': comment.comment_id, | |
|
3461 | 'comment_type': comment.comment_type, | |
|
3462 | 'comment_text': comment.text, | |
|
3463 | 'comment_status': comment.status_change, | |
|
3464 | 'comment_f_path': comment.f_path, | |
|
3465 | 'comment_lineno': comment.line_no, | |
|
3466 | 'comment_author': comment.author, | |
|
3467 | 'comment_created_on': comment.created_on | |
|
3468 | } | |
|
3469 | return data | |
|
3470 | ||
|
3471 | def __json__(self): | |
|
3472 | data = dict() | |
|
3473 | data.update(self.get_api_data()) | |
|
3474 | return data | |
|
3475 | ||
|
3476 | ||
|
3477 | class ChangesetStatus(Base, BaseModel): | |
|
3478 | __tablename__ = 'changeset_statuses' | |
|
3479 | __table_args__ = ( | |
|
3480 | Index('cs_revision_idx', 'revision'), | |
|
3481 | Index('cs_version_idx', 'version'), | |
|
3482 | UniqueConstraint('repo_id', 'revision', 'version'), | |
|
3483 | base_table_args | |
|
3484 | ) | |
|
3485 | ||
|
3486 | STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed' | |
|
3487 | STATUS_APPROVED = 'approved' | |
|
3488 | STATUS_REJECTED = 'rejected' | |
|
3489 | STATUS_UNDER_REVIEW = 'under_review' | |
|
3490 | ||
|
3491 | STATUSES = [ | |
|
3492 | (STATUS_NOT_REVIEWED, _("Not Reviewed")), # (no icon) and default | |
|
3493 | (STATUS_APPROVED, _("Approved")), | |
|
3494 | (STATUS_REJECTED, _("Rejected")), | |
|
3495 | (STATUS_UNDER_REVIEW, _("Under Review")), | |
|
3496 | ] | |
|
3497 | ||
|
3498 | changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True) | |
|
3499 | repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False) | |
|
3500 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None) | |
|
3501 | revision = Column('revision', String(40), nullable=False) | |
|
3502 | status = Column('status', String(128), nullable=False, default=DEFAULT) | |
|
3503 | changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id')) | |
|
3504 | modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now) | |
|
3505 | version = Column('version', Integer(), nullable=False, default=0) | |
|
3506 | pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True) | |
|
3507 | ||
|
3508 | author = relationship('User', lazy='joined') | |
|
3509 | repo = relationship('Repository') | |
|
3510 | comment = relationship('ChangesetComment', lazy='joined') | |
|
3511 | pull_request = relationship('PullRequest', lazy='joined') | |
|
3512 | ||
|
3513 | def __unicode__(self): | |
|
3514 | return u"<%s('%s[v%s]:%s')>" % ( | |
|
3515 | self.__class__.__name__, | |
|
3516 | self.status, self.version, self.author | |
|
3517 | ) | |
|
3518 | ||
|
3519 | @classmethod | |
|
3520 | def get_status_lbl(cls, value): | |
|
3521 | return dict(cls.STATUSES).get(value) | |
|
3522 | ||
|
3523 | @property | |
|
3524 | def status_lbl(self): | |
|
3525 | return ChangesetStatus.get_status_lbl(self.status) | |
|
3526 | ||
|
3527 | def get_api_data(self): | |
|
3528 | status = self | |
|
3529 | data = { | |
|
3530 | 'status_id': status.changeset_status_id, | |
|
3531 | 'status': status.status, | |
|
3532 | } | |
|
3533 | return data | |
|
3534 | ||
|
3535 | def __json__(self): | |
|
3536 | data = dict() | |
|
3537 | data.update(self.get_api_data()) | |
|
3538 | return data | |
|
3539 | ||
|
3540 | ||
|
3541 | class _PullRequestBase(BaseModel): | |
|
3542 | """ | |
|
3543 | Common attributes of pull request and version entries. | |
|
3544 | """ | |
|
3545 | ||
|
3546 | # .status values | |
|
3547 | STATUS_NEW = u'new' | |
|
3548 | STATUS_OPEN = u'open' | |
|
3549 | STATUS_CLOSED = u'closed' | |
|
3550 | ||
|
3551 | # available states | |
|
3552 | STATE_CREATING = u'creating' | |
|
3553 | STATE_UPDATING = u'updating' | |
|
3554 | STATE_MERGING = u'merging' | |
|
3555 | STATE_CREATED = u'created' | |
|
3556 | ||
|
3557 | title = Column('title', Unicode(255), nullable=True) | |
|
3558 | description = Column( | |
|
3559 | 'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), | |
|
3560 | nullable=True) | |
|
3561 | description_renderer = Column('description_renderer', Unicode(64), nullable=True) | |
|
3562 | ||
|
3563 | # new/open/closed status of pull request (not approve/reject/etc) | |
|
3564 | status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW) | |
|
3565 | created_on = Column( | |
|
3566 | 'created_on', DateTime(timezone=False), nullable=False, | |
|
3567 | default=datetime.datetime.now) | |
|
3568 | updated_on = Column( | |
|
3569 | 'updated_on', DateTime(timezone=False), nullable=False, | |
|
3570 | default=datetime.datetime.now) | |
|
3571 | ||
|
3572 | pull_request_state = Column("pull_request_state", String(255), nullable=True) | |
|
3573 | ||
|
3574 | @declared_attr | |
|
3575 | def user_id(cls): | |
|
3576 | return Column( | |
|
3577 | "user_id", Integer(), ForeignKey('users.user_id'), nullable=False, | |
|
3578 | unique=None) | |
|
3579 | ||
|
3580 | # 500 revisions max | |
|
3581 | _revisions = Column( | |
|
3582 | 'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql')) | |
|
3583 | ||
|
3584 | @declared_attr | |
|
3585 | def source_repo_id(cls): | |
|
3586 | # TODO: dan: rename column to source_repo_id | |
|
3587 | return Column( | |
|
3588 | 'org_repo_id', Integer(), ForeignKey('repositories.repo_id'), | |
|
3589 | nullable=False) | |
|
3590 | ||
|
3591 | _source_ref = Column('org_ref', Unicode(255), nullable=False) | |
|
3592 | ||
|
3593 | @hybrid_property | |
|
3594 | def source_ref(self): | |
|
3595 | return self._source_ref | |
|
3596 | ||
|
3597 | @source_ref.setter | |
|
3598 | def source_ref(self, val): | |
|
3599 | parts = (val or '').split(':') | |
|
3600 | if len(parts) != 3: | |
|
3601 | raise ValueError( | |
|
3602 | 'Invalid reference format given: {}, expected X:Y:Z'.format(val)) | |
|
3603 | self._source_ref = safe_unicode(val) | |
|
3604 | ||
|
3605 | _target_ref = Column('other_ref', Unicode(255), nullable=False) | |
|
3606 | ||
|
3607 | @hybrid_property | |
|
3608 | def target_ref(self): | |
|
3609 | return self._target_ref | |
|
3610 | ||
|
3611 | @target_ref.setter | |
|
3612 | def target_ref(self, val): | |
|
3613 | parts = (val or '').split(':') | |
|
3614 | if len(parts) != 3: | |
|
3615 | raise ValueError( | |
|
3616 | 'Invalid reference format given: {}, expected X:Y:Z'.format(val)) | |
|
3617 | self._target_ref = safe_unicode(val) | |
|
3618 | ||
|
3619 | @declared_attr | |
|
3620 | def target_repo_id(cls): | |
|
3621 | # TODO: dan: rename column to target_repo_id | |
|
3622 | return Column( | |
|
3623 | 'other_repo_id', Integer(), ForeignKey('repositories.repo_id'), | |
|
3624 | nullable=False) | |
|
3625 | ||
|
3626 | _shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True) | |
|
3627 | ||
|
3628 | # TODO: dan: rename column to last_merge_source_rev | |
|
3629 | _last_merge_source_rev = Column( | |
|
3630 | 'last_merge_org_rev', String(40), nullable=True) | |
|
3631 | # TODO: dan: rename column to last_merge_target_rev | |
|
3632 | _last_merge_target_rev = Column( | |
|
3633 | 'last_merge_other_rev', String(40), nullable=True) | |
|
3634 | _last_merge_status = Column('merge_status', Integer(), nullable=True) | |
|
3635 | merge_rev = Column('merge_rev', String(40), nullable=True) | |
|
3636 | ||
|
3637 | reviewer_data = Column( | |
|
3638 | 'reviewer_data_json', MutationObj.as_mutable( | |
|
3639 | JsonType(dialect_map=dict(mysql=UnicodeText(16384))))) | |
|
3640 | ||
|
3641 | @property | |
|
3642 | def reviewer_data_json(self): | |
|
3643 | return json.dumps(self.reviewer_data) | |
|
3644 | ||
|
3645 | @hybrid_property | |
|
3646 | def description_safe(self): | |
|
3647 | from rhodecode.lib import helpers as h | |
|
3648 | return h.escape(self.description) | |
|
3649 | ||
|
3650 | @hybrid_property | |
|
3651 | def revisions(self): | |
|
3652 | return self._revisions.split(':') if self._revisions else [] | |
|
3653 | ||
|
3654 | @revisions.setter | |
|
3655 | def revisions(self, val): | |
|
3656 | self._revisions = ':'.join(val) | |
|
3657 | ||
|
3658 | @hybrid_property | |
|
3659 | def last_merge_status(self): | |
|
3660 | return safe_int(self._last_merge_status) | |
|
3661 | ||
|
3662 | @last_merge_status.setter | |
|
3663 | def last_merge_status(self, val): | |
|
3664 | self._last_merge_status = val | |
|
3665 | ||
|
3666 | @declared_attr | |
|
3667 | def author(cls): | |
|
3668 | return relationship('User', lazy='joined') | |
|
3669 | ||
|
3670 | @declared_attr | |
|
3671 | def source_repo(cls): | |
|
3672 | return relationship( | |
|
3673 | 'Repository', | |
|
3674 | primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__) | |
|
3675 | ||
|
3676 | @property | |
|
3677 | def source_ref_parts(self): | |
|
3678 | return self.unicode_to_reference(self.source_ref) | |
|
3679 | ||
|
3680 | @declared_attr | |
|
3681 | def target_repo(cls): | |
|
3682 | return relationship( | |
|
3683 | 'Repository', | |
|
3684 | primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__) | |
|
3685 | ||
|
3686 | @property | |
|
3687 | def target_ref_parts(self): | |
|
3688 | return self.unicode_to_reference(self.target_ref) | |
|
3689 | ||
|
3690 | @property | |
|
3691 | def shadow_merge_ref(self): | |
|
3692 | return self.unicode_to_reference(self._shadow_merge_ref) | |
|
3693 | ||
|
3694 | @shadow_merge_ref.setter | |
|
3695 | def shadow_merge_ref(self, ref): | |
|
3696 | self._shadow_merge_ref = self.reference_to_unicode(ref) | |
|
3697 | ||
|
3698 | @staticmethod | |
|
3699 | def unicode_to_reference(raw): | |
|
3700 | """ | |
|
3701 | Convert a unicode (or string) to a reference object. | |
|
3702 | If unicode evaluates to False it returns None. | |
|
3703 | """ | |
|
3704 | if raw: | |
|
3705 | refs = raw.split(':') | |
|
3706 | return Reference(*refs) | |
|
3707 | else: | |
|
3708 | return None | |
|
3709 | ||
|
3710 | @staticmethod | |
|
3711 | def reference_to_unicode(ref): | |
|
3712 | """ | |
|
3713 | Convert a reference object to unicode. | |
|
3714 | If reference is None it returns None. | |
|
3715 | """ | |
|
3716 | if ref: | |
|
3717 | return u':'.join(ref) | |
|
3718 | else: | |
|
3719 | return None | |
|
3720 | ||
|
3721 | def get_api_data(self, with_merge_state=True): | |
|
3722 | from rhodecode.model.pull_request import PullRequestModel | |
|
3723 | ||
|
3724 | pull_request = self | |
|
3725 | if with_merge_state: | |
|
3726 | merge_status = PullRequestModel().merge_status(pull_request) | |
|
3727 | merge_state = { | |
|
3728 | 'status': merge_status[0], | |
|
3729 | 'message': safe_unicode(merge_status[1]), | |
|
3730 | } | |
|
3731 | else: | |
|
3732 | merge_state = {'status': 'not_available', | |
|
3733 | 'message': 'not_available'} | |
|
3734 | ||
|
3735 | merge_data = { | |
|
3736 | 'clone_url': PullRequestModel().get_shadow_clone_url(pull_request), | |
|
3737 | 'reference': ( | |
|
3738 | pull_request.shadow_merge_ref._asdict() | |
|
3739 | if pull_request.shadow_merge_ref else None), | |
|
3740 | } | |
|
3741 | ||
|
3742 | data = { | |
|
3743 | 'pull_request_id': pull_request.pull_request_id, | |
|
3744 | 'url': PullRequestModel().get_url(pull_request), | |
|
3745 | 'title': pull_request.title, | |
|
3746 | 'description': pull_request.description, | |
|
3747 | 'status': pull_request.status, | |
|
3748 | 'created_on': pull_request.created_on, | |
|
3749 | 'updated_on': pull_request.updated_on, | |
|
3750 | 'commit_ids': pull_request.revisions, | |
|
3751 | 'review_status': pull_request.calculated_review_status(), | |
|
3752 | 'mergeable': merge_state, | |
|
3753 | 'source': { | |
|
3754 | 'clone_url': pull_request.source_repo.clone_url(), | |
|
3755 | 'repository': pull_request.source_repo.repo_name, | |
|
3756 | 'reference': { | |
|
3757 | 'name': pull_request.source_ref_parts.name, | |
|
3758 | 'type': pull_request.source_ref_parts.type, | |
|
3759 | 'commit_id': pull_request.source_ref_parts.commit_id, | |
|
3760 | }, | |
|
3761 | }, | |
|
3762 | 'target': { | |
|
3763 | 'clone_url': pull_request.target_repo.clone_url(), | |
|
3764 | 'repository': pull_request.target_repo.repo_name, | |
|
3765 | 'reference': { | |
|
3766 | 'name': pull_request.target_ref_parts.name, | |
|
3767 | 'type': pull_request.target_ref_parts.type, | |
|
3768 | 'commit_id': pull_request.target_ref_parts.commit_id, | |
|
3769 | }, | |
|
3770 | }, | |
|
3771 | 'merge': merge_data, | |
|
3772 | 'author': pull_request.author.get_api_data(include_secrets=False, | |
|
3773 | details='basic'), | |
|
3774 | 'reviewers': [ | |
|
3775 | { | |
|
3776 | 'user': reviewer.get_api_data(include_secrets=False, | |
|
3777 | details='basic'), | |
|
3778 | 'reasons': reasons, | |
|
3779 | 'review_status': st[0][1].status if st else 'not_reviewed', | |
|
3780 | } | |
|
3781 | for obj, reviewer, reasons, mandatory, st in | |
|
3782 | pull_request.reviewers_statuses() | |
|
3783 | ] | |
|
3784 | } | |
|
3785 | ||
|
3786 | return data | |
|
3787 | ||
|
3788 | ||
|
3789 | class PullRequest(Base, _PullRequestBase): | |
|
3790 | __tablename__ = 'pull_requests' | |
|
3791 | __table_args__ = ( | |
|
3792 | base_table_args, | |
|
3793 | ) | |
|
3794 | ||
|
3795 | pull_request_id = Column( | |
|
3796 | 'pull_request_id', Integer(), nullable=False, primary_key=True) | |
|
3797 | ||
|
3798 | def __repr__(self): | |
|
3799 | if self.pull_request_id: | |
|
3800 | return '<DB:PullRequest #%s>' % self.pull_request_id | |
|
3801 | else: | |
|
3802 | return '<DB:PullRequest at %#x>' % id(self) | |
|
3803 | ||
|
3804 | reviewers = relationship('PullRequestReviewers', | |
|
3805 | cascade="all, delete, delete-orphan") | |
|
3806 | statuses = relationship('ChangesetStatus', | |
|
3807 | cascade="all, delete, delete-orphan") | |
|
3808 | comments = relationship('ChangesetComment', | |
|
3809 | cascade="all, delete, delete-orphan") | |
|
3810 | versions = relationship('PullRequestVersion', | |
|
3811 | cascade="all, delete, delete-orphan", | |
|
3812 | lazy='dynamic') | |
|
3813 | ||
|
3814 | @classmethod | |
|
3815 | def get_pr_display_object(cls, pull_request_obj, org_pull_request_obj, | |
|
3816 | internal_methods=None): | |
|
3817 | ||
|
3818 | class PullRequestDisplay(object): | |
|
3819 | """ | |
|
3820 | Special object wrapper for showing PullRequest data via Versions | |
|
3821 | It mimics PR object as close as possible. This is read only object | |
|
3822 | just for display | |
|
3823 | """ | |
|
3824 | ||
|
3825 | def __init__(self, attrs, internal=None): | |
|
3826 | self.attrs = attrs | |
|
3827 | # internal have priority over the given ones via attrs | |
|
3828 | self.internal = internal or ['versions'] | |
|
3829 | ||
|
3830 | def __getattr__(self, item): | |
|
3831 | if item in self.internal: | |
|
3832 | return getattr(self, item) | |
|
3833 | try: | |
|
3834 | return self.attrs[item] | |
|
3835 | except KeyError: | |
|
3836 | raise AttributeError( | |
|
3837 | '%s object has no attribute %s' % (self, item)) | |
|
3838 | ||
|
3839 | def __repr__(self): | |
|
3840 | return '<DB:PullRequestDisplay #%s>' % self.attrs.get('pull_request_id') | |
|
3841 | ||
|
3842 | def versions(self): | |
|
3843 | return pull_request_obj.versions.order_by( | |
|
3844 | PullRequestVersion.pull_request_version_id).all() | |
|
3845 | ||
|
3846 | def is_closed(self): | |
|
3847 | return pull_request_obj.is_closed() | |
|
3848 | ||
|
3849 | @property | |
|
3850 | def pull_request_version_id(self): | |
|
3851 | return getattr(pull_request_obj, 'pull_request_version_id', None) | |
|
3852 | ||
|
3853 | attrs = StrictAttributeDict(pull_request_obj.get_api_data()) | |
|
3854 | ||
|
3855 | attrs.author = StrictAttributeDict( | |
|
3856 | pull_request_obj.author.get_api_data()) | |
|
3857 | if pull_request_obj.target_repo: | |
|
3858 | attrs.target_repo = StrictAttributeDict( | |
|
3859 | pull_request_obj.target_repo.get_api_data()) | |
|
3860 | attrs.target_repo.clone_url = pull_request_obj.target_repo.clone_url | |
|
3861 | ||
|
3862 | if pull_request_obj.source_repo: | |
|
3863 | attrs.source_repo = StrictAttributeDict( | |
|
3864 | pull_request_obj.source_repo.get_api_data()) | |
|
3865 | attrs.source_repo.clone_url = pull_request_obj.source_repo.clone_url | |
|
3866 | ||
|
3867 | attrs.source_ref_parts = pull_request_obj.source_ref_parts | |
|
3868 | attrs.target_ref_parts = pull_request_obj.target_ref_parts | |
|
3869 | attrs.revisions = pull_request_obj.revisions | |
|
3870 | ||
|
3871 | attrs.shadow_merge_ref = org_pull_request_obj.shadow_merge_ref | |
|
3872 | attrs.reviewer_data = org_pull_request_obj.reviewer_data | |
|
3873 | attrs.reviewer_data_json = org_pull_request_obj.reviewer_data_json | |
|
3874 | ||
|
3875 | return PullRequestDisplay(attrs, internal=internal_methods) | |
|
3876 | ||
|
3877 | def is_closed(self): | |
|
3878 | return self.status == self.STATUS_CLOSED | |
|
3879 | ||
|
3880 | def __json__(self): | |
|
3881 | return { | |
|
3882 | 'revisions': self.revisions, | |
|
3883 | } | |
|
3884 | ||
|
3885 | def calculated_review_status(self): | |
|
3886 | from rhodecode.model.changeset_status import ChangesetStatusModel | |
|
3887 | return ChangesetStatusModel().calculated_review_status(self) | |
|
3888 | ||
|
3889 | def reviewers_statuses(self): | |
|
3890 | from rhodecode.model.changeset_status import ChangesetStatusModel | |
|
3891 | return ChangesetStatusModel().reviewers_statuses(self) | |
|
3892 | ||
|
3893 | @property | |
|
3894 | def workspace_id(self): | |
|
3895 | from rhodecode.model.pull_request import PullRequestModel | |
|
3896 | return PullRequestModel()._workspace_id(self) | |
|
3897 | ||
|
3898 | def get_shadow_repo(self): | |
|
3899 | workspace_id = self.workspace_id | |
|
3900 | vcs_obj = self.target_repo.scm_instance() | |
|
3901 | shadow_repository_path = vcs_obj._get_shadow_repository_path( | |
|
3902 | self.target_repo.repo_id, workspace_id) | |
|
3903 | if os.path.isdir(shadow_repository_path): | |
|
3904 | return vcs_obj._get_shadow_instance(shadow_repository_path) | |
|
3905 | ||
|
3906 | ||
|
3907 | class PullRequestVersion(Base, _PullRequestBase): | |
|
3908 | __tablename__ = 'pull_request_versions' | |
|
3909 | __table_args__ = ( | |
|
3910 | base_table_args, | |
|
3911 | ) | |
|
3912 | ||
|
3913 | pull_request_version_id = Column( | |
|
3914 | 'pull_request_version_id', Integer(), nullable=False, primary_key=True) | |
|
3915 | pull_request_id = Column( | |
|
3916 | 'pull_request_id', Integer(), | |
|
3917 | ForeignKey('pull_requests.pull_request_id'), nullable=False) | |
|
3918 | pull_request = relationship('PullRequest') | |
|
3919 | ||
|
3920 | def __repr__(self): | |
|
3921 | if self.pull_request_version_id: | |
|
3922 | return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id | |
|
3923 | else: | |
|
3924 | return '<DB:PullRequestVersion at %#x>' % id(self) | |
|
3925 | ||
|
3926 | @property | |
|
3927 | def reviewers(self): | |
|
3928 | return self.pull_request.reviewers | |
|
3929 | ||
|
3930 | @property | |
|
3931 | def versions(self): | |
|
3932 | return self.pull_request.versions | |
|
3933 | ||
|
3934 | def is_closed(self): | |
|
3935 | # calculate from original | |
|
3936 | return self.pull_request.status == self.STATUS_CLOSED | |
|
3937 | ||
|
3938 | def calculated_review_status(self): | |
|
3939 | return self.pull_request.calculated_review_status() | |
|
3940 | ||
|
3941 | def reviewers_statuses(self): | |
|
3942 | return self.pull_request.reviewers_statuses() | |
|
3943 | ||
|
3944 | ||
|
3945 | class PullRequestReviewers(Base, BaseModel): | |
|
3946 | __tablename__ = 'pull_request_reviewers' | |
|
3947 | __table_args__ = ( | |
|
3948 | base_table_args, | |
|
3949 | ) | |
|
3950 | ||
|
3951 | @hybrid_property | |
|
3952 | def reasons(self): | |
|
3953 | if not self._reasons: | |
|
3954 | return [] | |
|
3955 | return self._reasons | |
|
3956 | ||
|
3957 | @reasons.setter | |
|
3958 | def reasons(self, val): | |
|
3959 | val = val or [] | |
|
3960 | if any(not isinstance(x, basestring) for x in val): | |
|
3961 | raise Exception('invalid reasons type, must be list of strings') | |
|
3962 | self._reasons = val | |
|
3963 | ||
|
3964 | pull_requests_reviewers_id = Column( | |
|
3965 | 'pull_requests_reviewers_id', Integer(), nullable=False, | |
|
3966 | primary_key=True) | |
|
3967 | pull_request_id = Column( | |
|
3968 | "pull_request_id", Integer(), | |
|
3969 | ForeignKey('pull_requests.pull_request_id'), nullable=False) | |
|
3970 | user_id = Column( | |
|
3971 | "user_id", Integer(), ForeignKey('users.user_id'), nullable=True) | |
|
3972 | _reasons = Column( | |
|
3973 | 'reason', MutationList.as_mutable( | |
|
3974 | JsonType('list', dialect_map=dict(mysql=UnicodeText(16384))))) | |
|
3975 | ||
|
3976 | mandatory = Column("mandatory", Boolean(), nullable=False, default=False) | |
|
3977 | user = relationship('User') | |
|
3978 | pull_request = relationship('PullRequest') | |
|
3979 | ||
|
3980 | rule_data = Column( | |
|
3981 | 'rule_data_json', | |
|
3982 | JsonType(dialect_map=dict(mysql=UnicodeText(16384)))) | |
|
3983 | ||
|
3984 | def rule_user_group_data(self): | |
|
3985 | """ | |
|
3986 | Returns the voting user group rule data for this reviewer | |
|
3987 | """ | |
|
3988 | ||
|
3989 | if self.rule_data and 'vote_rule' in self.rule_data: | |
|
3990 | user_group_data = {} | |
|
3991 | if 'rule_user_group_entry_id' in self.rule_data: | |
|
3992 | # means a group with voting rules ! | |
|
3993 | user_group_data['id'] = self.rule_data['rule_user_group_entry_id'] | |
|
3994 | user_group_data['name'] = self.rule_data['rule_name'] | |
|
3995 | user_group_data['vote_rule'] = self.rule_data['vote_rule'] | |
|
3996 | ||
|
3997 | return user_group_data | |
|
3998 | ||
|
3999 | def __unicode__(self): | |
|
4000 | return u"<%s('id:%s')>" % (self.__class__.__name__, | |
|
4001 | self.pull_requests_reviewers_id) | |
|
4002 | ||
|
4003 | ||
|
4004 | class Notification(Base, BaseModel): | |
|
4005 | __tablename__ = 'notifications' | |
|
4006 | __table_args__ = ( | |
|
4007 | Index('notification_type_idx', 'type'), | |
|
4008 | base_table_args, | |
|
4009 | ) | |
|
4010 | ||
|
4011 | TYPE_CHANGESET_COMMENT = u'cs_comment' | |
|
4012 | TYPE_MESSAGE = u'message' | |
|
4013 | TYPE_MENTION = u'mention' | |
|
4014 | TYPE_REGISTRATION = u'registration' | |
|
4015 | TYPE_PULL_REQUEST = u'pull_request' | |
|
4016 | TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment' | |
|
4017 | ||
|
4018 | notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True) | |
|
4019 | subject = Column('subject', Unicode(512), nullable=True) | |
|
4020 | body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True) | |
|
4021 | created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True) | |
|
4022 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
|
4023 | type_ = Column('type', Unicode(255)) | |
|
4024 | ||
|
4025 | created_by_user = relationship('User') | |
|
4026 | notifications_to_users = relationship('UserNotification', lazy='joined', | |
|
4027 | cascade="all, delete, delete-orphan") | |
|
4028 | ||
|
4029 | @property | |
|
4030 | def recipients(self): | |
|
4031 | return [x.user for x in UserNotification.query()\ | |
|
4032 | .filter(UserNotification.notification == self)\ | |
|
4033 | .order_by(UserNotification.user_id.asc()).all()] | |
|
4034 | ||
|
4035 | @classmethod | |
|
4036 | def create(cls, created_by, subject, body, recipients, type_=None): | |
|
4037 | if type_ is None: | |
|
4038 | type_ = Notification.TYPE_MESSAGE | |
|
4039 | ||
|
4040 | notification = cls() | |
|
4041 | notification.created_by_user = created_by | |
|
4042 | notification.subject = subject | |
|
4043 | notification.body = body | |
|
4044 | notification.type_ = type_ | |
|
4045 | notification.created_on = datetime.datetime.now() | |
|
4046 | ||
|
4047 | # For each recipient link the created notification to his account | |
|
4048 | for u in recipients: | |
|
4049 | assoc = UserNotification() | |
|
4050 | assoc.user_id = u.user_id | |
|
4051 | assoc.notification = notification | |
|
4052 | ||
|
4053 | # if created_by is inside recipients mark his notification | |
|
4054 | # as read | |
|
4055 | if u.user_id == created_by.user_id: | |
|
4056 | assoc.read = True | |
|
4057 | Session().add(assoc) | |
|
4058 | ||
|
4059 | Session().add(notification) | |
|
4060 | ||
|
4061 | return notification | |
|
4062 | ||
|
4063 | ||
|
4064 | class UserNotification(Base, BaseModel): | |
|
4065 | __tablename__ = 'user_to_notification' | |
|
4066 | __table_args__ = ( | |
|
4067 | UniqueConstraint('user_id', 'notification_id'), | |
|
4068 | base_table_args | |
|
4069 | ) | |
|
4070 | ||
|
4071 | user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True) | |
|
4072 | notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True) | |
|
4073 | read = Column('read', Boolean, default=False) | |
|
4074 | sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None) | |
|
4075 | ||
|
4076 | user = relationship('User', lazy="joined") | |
|
4077 | notification = relationship('Notification', lazy="joined", | |
|
4078 | order_by=lambda: Notification.created_on.desc(),) | |
|
4079 | ||
|
4080 | def mark_as_read(self): | |
|
4081 | self.read = True | |
|
4082 | Session().add(self) | |
|
4083 | ||
|
4084 | ||
|
4085 | class Gist(Base, BaseModel): | |
|
4086 | __tablename__ = 'gists' | |
|
4087 | __table_args__ = ( | |
|
4088 | Index('g_gist_access_id_idx', 'gist_access_id'), | |
|
4089 | Index('g_created_on_idx', 'created_on'), | |
|
4090 | base_table_args | |
|
4091 | ) | |
|
4092 | ||
|
4093 | GIST_PUBLIC = u'public' | |
|
4094 | GIST_PRIVATE = u'private' | |
|
4095 | DEFAULT_FILENAME = u'gistfile1.txt' | |
|
4096 | ||
|
4097 | ACL_LEVEL_PUBLIC = u'acl_public' | |
|
4098 | ACL_LEVEL_PRIVATE = u'acl_private' | |
|
4099 | ||
|
4100 | gist_id = Column('gist_id', Integer(), primary_key=True) | |
|
4101 | gist_access_id = Column('gist_access_id', Unicode(250)) | |
|
4102 | gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql')) | |
|
4103 | gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True) | |
|
4104 | gist_expires = Column('gist_expires', Float(53), nullable=False) | |
|
4105 | gist_type = Column('gist_type', Unicode(128), nullable=False) | |
|
4106 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
|
4107 | modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
|
4108 | acl_level = Column('acl_level', Unicode(128), nullable=True) | |
|
4109 | ||
|
4110 | owner = relationship('User') | |
|
4111 | ||
|
4112 | def __repr__(self): | |
|
4113 | return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id) | |
|
4114 | ||
|
4115 | @hybrid_property | |
|
4116 | def description_safe(self): | |
|
4117 | from rhodecode.lib import helpers as h | |
|
4118 | return h.escape(self.gist_description) | |
|
4119 | ||
|
4120 | @classmethod | |
|
4121 | def get_or_404(cls, id_): | |
|
4122 | from pyramid.httpexceptions import HTTPNotFound | |
|
4123 | ||
|
4124 | res = cls.query().filter(cls.gist_access_id == id_).scalar() | |
|
4125 | if not res: | |
|
4126 | raise HTTPNotFound() | |
|
4127 | return res | |
|
4128 | ||
|
4129 | @classmethod | |
|
4130 | def get_by_access_id(cls, gist_access_id): | |
|
4131 | return cls.query().filter(cls.gist_access_id == gist_access_id).scalar() | |
|
4132 | ||
|
4133 | def gist_url(self): | |
|
4134 | from rhodecode.model.gist import GistModel | |
|
4135 | return GistModel().get_url(self) | |
|
4136 | ||
|
4137 | @classmethod | |
|
4138 | def base_path(cls): | |
|
4139 | """ | |
|
4140 | Returns base path when all gists are stored | |
|
4141 | ||
|
4142 | :param cls: | |
|
4143 | """ | |
|
4144 | from rhodecode.model.gist import GIST_STORE_LOC | |
|
4145 | q = Session().query(RhodeCodeUi)\ | |
|
4146 | .filter(RhodeCodeUi.ui_key == URL_SEP) | |
|
4147 | q = q.options(FromCache("sql_cache_short", "repository_repo_path")) | |
|
4148 | return os.path.join(q.one().ui_value, GIST_STORE_LOC) | |
|
4149 | ||
|
4150 | def get_api_data(self): | |
|
4151 | """ | |
|
4152 | Common function for generating gist related data for API | |
|
4153 | """ | |
|
4154 | gist = self | |
|
4155 | data = { | |
|
4156 | 'gist_id': gist.gist_id, | |
|
4157 | 'type': gist.gist_type, | |
|
4158 | 'access_id': gist.gist_access_id, | |
|
4159 | 'description': gist.gist_description, | |
|
4160 | 'url': gist.gist_url(), | |
|
4161 | 'expires': gist.gist_expires, | |
|
4162 | 'created_on': gist.created_on, | |
|
4163 | 'modified_at': gist.modified_at, | |
|
4164 | 'content': None, | |
|
4165 | 'acl_level': gist.acl_level, | |
|
4166 | } | |
|
4167 | return data | |
|
4168 | ||
|
4169 | def __json__(self): | |
|
4170 | data = dict( | |
|
4171 | ) | |
|
4172 | data.update(self.get_api_data()) | |
|
4173 | return data | |
|
4174 | # SCM functions | |
|
4175 | ||
|
4176 | def scm_instance(self, **kwargs): | |
|
4177 | full_repo_path = os.path.join(self.base_path(), self.gist_access_id) | |
|
4178 | return get_vcs_instance( | |
|
4179 | repo_path=safe_str(full_repo_path), create=False) | |
|
4180 | ||
|
4181 | ||
|
4182 | class ExternalIdentity(Base, BaseModel): | |
|
4183 | __tablename__ = 'external_identities' | |
|
4184 | __table_args__ = ( | |
|
4185 | Index('local_user_id_idx', 'local_user_id'), | |
|
4186 | Index('external_id_idx', 'external_id'), | |
|
4187 | base_table_args | |
|
4188 | ) | |
|
4189 | ||
|
4190 | external_id = Column('external_id', Unicode(255), default=u'', primary_key=True) | |
|
4191 | external_username = Column('external_username', Unicode(1024), default=u'') | |
|
4192 | local_user_id = Column('local_user_id', Integer(), ForeignKey('users.user_id'), primary_key=True) | |
|
4193 | provider_name = Column('provider_name', Unicode(255), default=u'', primary_key=True) | |
|
4194 | access_token = Column('access_token', String(1024), default=u'') | |
|
4195 | alt_token = Column('alt_token', String(1024), default=u'') | |
|
4196 | token_secret = Column('token_secret', String(1024), default=u'') | |
|
4197 | ||
|
4198 | @classmethod | |
|
4199 | def by_external_id_and_provider(cls, external_id, provider_name, local_user_id=None): | |
|
4200 | """ | |
|
4201 | Returns ExternalIdentity instance based on search params | |
|
4202 | ||
|
4203 | :param external_id: | |
|
4204 | :param provider_name: | |
|
4205 | :return: ExternalIdentity | |
|
4206 | """ | |
|
4207 | query = cls.query() | |
|
4208 | query = query.filter(cls.external_id == external_id) | |
|
4209 | query = query.filter(cls.provider_name == provider_name) | |
|
4210 | if local_user_id: | |
|
4211 | query = query.filter(cls.local_user_id == local_user_id) | |
|
4212 | return query.first() | |
|
4213 | ||
|
4214 | @classmethod | |
|
4215 | def user_by_external_id_and_provider(cls, external_id, provider_name): | |
|
4216 | """ | |
|
4217 | Returns User instance based on search params | |
|
4218 | ||
|
4219 | :param external_id: | |
|
4220 | :param provider_name: | |
|
4221 | :return: User | |
|
4222 | """ | |
|
4223 | query = User.query() | |
|
4224 | query = query.filter(cls.external_id == external_id) | |
|
4225 | query = query.filter(cls.provider_name == provider_name) | |
|
4226 | query = query.filter(User.user_id == cls.local_user_id) | |
|
4227 | return query.first() | |
|
4228 | ||
|
4229 | @classmethod | |
|
4230 | def by_local_user_id(cls, local_user_id): | |
|
4231 | """ | |
|
4232 | Returns all tokens for user | |
|
4233 | ||
|
4234 | :param local_user_id: | |
|
4235 | :return: ExternalIdentity | |
|
4236 | """ | |
|
4237 | query = cls.query() | |
|
4238 | query = query.filter(cls.local_user_id == local_user_id) | |
|
4239 | return query | |
|
4240 | ||
|
4241 | @classmethod | |
|
4242 | def load_provider_plugin(cls, plugin_id): | |
|
4243 | from rhodecode.authentication.base import loadplugin | |
|
4244 | _plugin_id = 'egg:rhodecode-enterprise-ee#{}'.format(plugin_id) | |
|
4245 | auth_plugin = loadplugin(_plugin_id) | |
|
4246 | return auth_plugin | |
|
4247 | ||
|
4248 | ||
|
4249 | class Integration(Base, BaseModel): | |
|
4250 | __tablename__ = 'integrations' | |
|
4251 | __table_args__ = ( | |
|
4252 | base_table_args | |
|
4253 | ) | |
|
4254 | ||
|
4255 | integration_id = Column('integration_id', Integer(), primary_key=True) | |
|
4256 | integration_type = Column('integration_type', String(255)) | |
|
4257 | enabled = Column('enabled', Boolean(), nullable=False) | |
|
4258 | name = Column('name', String(255), nullable=False) | |
|
4259 | child_repos_only = Column('child_repos_only', Boolean(), nullable=False, | |
|
4260 | default=False) | |
|
4261 | ||
|
4262 | settings = Column( | |
|
4263 | 'settings_json', MutationObj.as_mutable( | |
|
4264 | JsonType(dialect_map=dict(mysql=UnicodeText(16384))))) | |
|
4265 | repo_id = Column( | |
|
4266 | 'repo_id', Integer(), ForeignKey('repositories.repo_id'), | |
|
4267 | nullable=True, unique=None, default=None) | |
|
4268 | repo = relationship('Repository', lazy='joined') | |
|
4269 | ||
|
4270 | repo_group_id = Column( | |
|
4271 | 'repo_group_id', Integer(), ForeignKey('groups.group_id'), | |
|
4272 | nullable=True, unique=None, default=None) | |
|
4273 | repo_group = relationship('RepoGroup', lazy='joined') | |
|
4274 | ||
|
4275 | @property | |
|
4276 | def scope(self): | |
|
4277 | if self.repo: | |
|
4278 | return repr(self.repo) | |
|
4279 | if self.repo_group: | |
|
4280 | if self.child_repos_only: | |
|
4281 | return repr(self.repo_group) + ' (child repos only)' | |
|
4282 | else: | |
|
4283 | return repr(self.repo_group) + ' (recursive)' | |
|
4284 | if self.child_repos_only: | |
|
4285 | return 'root_repos' | |
|
4286 | return 'global' | |
|
4287 | ||
|
4288 | def __repr__(self): | |
|
4289 | return '<Integration(%r, %r)>' % (self.integration_type, self.scope) | |
|
4290 | ||
|
4291 | ||
|
4292 | class RepoReviewRuleUser(Base, BaseModel): | |
|
4293 | __tablename__ = 'repo_review_rules_users' | |
|
4294 | __table_args__ = ( | |
|
4295 | base_table_args | |
|
4296 | ) | |
|
4297 | ||
|
4298 | repo_review_rule_user_id = Column('repo_review_rule_user_id', Integer(), primary_key=True) | |
|
4299 | repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id')) | |
|
4300 | user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False) | |
|
4301 | mandatory = Column("mandatory", Boolean(), nullable=False, default=False) | |
|
4302 | user = relationship('User') | |
|
4303 | ||
|
4304 | def rule_data(self): | |
|
4305 | return { | |
|
4306 | 'mandatory': self.mandatory | |
|
4307 | } | |
|
4308 | ||
|
4309 | ||
|
4310 | class RepoReviewRuleUserGroup(Base, BaseModel): | |
|
4311 | __tablename__ = 'repo_review_rules_users_groups' | |
|
4312 | __table_args__ = ( | |
|
4313 | base_table_args | |
|
4314 | ) | |
|
4315 | ||
|
4316 | VOTE_RULE_ALL = -1 | |
|
4317 | ||
|
4318 | repo_review_rule_users_group_id = Column('repo_review_rule_users_group_id', Integer(), primary_key=True) | |
|
4319 | repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id')) | |
|
4320 | users_group_id = Column("users_group_id", Integer(),ForeignKey('users_groups.users_group_id'), nullable=False) | |
|
4321 | mandatory = Column("mandatory", Boolean(), nullable=False, default=False) | |
|
4322 | vote_rule = Column("vote_rule", Integer(), nullable=True, default=VOTE_RULE_ALL) | |
|
4323 | users_group = relationship('UserGroup') | |
|
4324 | ||
|
4325 | def rule_data(self): | |
|
4326 | return { | |
|
4327 | 'mandatory': self.mandatory, | |
|
4328 | 'vote_rule': self.vote_rule | |
|
4329 | } | |
|
4330 | ||
|
4331 | @property | |
|
4332 | def vote_rule_label(self): | |
|
4333 | if not self.vote_rule or self.vote_rule == self.VOTE_RULE_ALL: | |
|
4334 | return 'all must vote' | |
|
4335 | else: | |
|
4336 | return 'min. vote {}'.format(self.vote_rule) | |
|
4337 | ||
|
4338 | ||
|
4339 | class RepoReviewRule(Base, BaseModel): | |
|
4340 | __tablename__ = 'repo_review_rules' | |
|
4341 | __table_args__ = ( | |
|
4342 | base_table_args | |
|
4343 | ) | |
|
4344 | ||
|
4345 | repo_review_rule_id = Column( | |
|
4346 | 'repo_review_rule_id', Integer(), primary_key=True) | |
|
4347 | repo_id = Column( | |
|
4348 | "repo_id", Integer(), ForeignKey('repositories.repo_id')) | |
|
4349 | repo = relationship('Repository', backref='review_rules') | |
|
4350 | ||
|
4351 | review_rule_name = Column('review_rule_name', String(255)) | |
|
4352 | _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob | |
|
4353 | _target_branch_pattern = Column("target_branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob | |
|
4354 | _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob | |
|
4355 | ||
|
4356 | use_authors_for_review = Column("use_authors_for_review", Boolean(), nullable=False, default=False) | |
|
4357 | forbid_author_to_review = Column("forbid_author_to_review", Boolean(), nullable=False, default=False) | |
|
4358 | forbid_commit_author_to_review = Column("forbid_commit_author_to_review", Boolean(), nullable=False, default=False) | |
|
4359 | forbid_adding_reviewers = Column("forbid_adding_reviewers", Boolean(), nullable=False, default=False) | |
|
4360 | ||
|
4361 | rule_users = relationship('RepoReviewRuleUser') | |
|
4362 | rule_user_groups = relationship('RepoReviewRuleUserGroup') | |
|
4363 | ||
|
4364 | def _validate_pattern(self, value): | |
|
4365 | re.compile('^' + glob2re(value) + '$') | |
|
4366 | ||
|
4367 | @hybrid_property | |
|
4368 | def source_branch_pattern(self): | |
|
4369 | return self._branch_pattern or '*' | |
|
4370 | ||
|
4371 | @source_branch_pattern.setter | |
|
4372 | def source_branch_pattern(self, value): | |
|
4373 | self._validate_pattern(value) | |
|
4374 | self._branch_pattern = value or '*' | |
|
4375 | ||
|
4376 | @hybrid_property | |
|
4377 | def target_branch_pattern(self): | |
|
4378 | return self._target_branch_pattern or '*' | |
|
4379 | ||
|
4380 | @target_branch_pattern.setter | |
|
4381 | def target_branch_pattern(self, value): | |
|
4382 | self._validate_pattern(value) | |
|
4383 | self._target_branch_pattern = value or '*' | |
|
4384 | ||
|
4385 | @hybrid_property | |
|
4386 | def file_pattern(self): | |
|
4387 | return self._file_pattern or '*' | |
|
4388 | ||
|
4389 | @file_pattern.setter | |
|
4390 | def file_pattern(self, value): | |
|
4391 | self._validate_pattern(value) | |
|
4392 | self._file_pattern = value or '*' | |
|
4393 | ||
|
4394 | def matches(self, source_branch, target_branch, files_changed): | |
|
4395 | """ | |
|
4396 | Check if this review rule matches a branch/files in a pull request | |
|
4397 | ||
|
4398 | :param source_branch: source branch name for the commit | |
|
4399 | :param target_branch: target branch name for the commit | |
|
4400 | :param files_changed: list of file paths changed in the pull request | |
|
4401 | """ | |
|
4402 | ||
|
4403 | source_branch = source_branch or '' | |
|
4404 | target_branch = target_branch or '' | |
|
4405 | files_changed = files_changed or [] | |
|
4406 | ||
|
4407 | branch_matches = True | |
|
4408 | if source_branch or target_branch: | |
|
4409 | if self.source_branch_pattern == '*': | |
|
4410 | source_branch_match = True | |
|
4411 | else: | |
|
4412 | if self.source_branch_pattern.startswith('re:'): | |
|
4413 | source_pattern = self.source_branch_pattern[3:] | |
|
4414 | else: | |
|
4415 | source_pattern = '^' + glob2re(self.source_branch_pattern) + '$' | |
|
4416 | source_branch_regex = re.compile(source_pattern) | |
|
4417 | source_branch_match = bool(source_branch_regex.search(source_branch)) | |
|
4418 | if self.target_branch_pattern == '*': | |
|
4419 | target_branch_match = True | |
|
4420 | else: | |
|
4421 | if self.target_branch_pattern.startswith('re:'): | |
|
4422 | target_pattern = self.target_branch_pattern[3:] | |
|
4423 | else: | |
|
4424 | target_pattern = '^' + glob2re(self.target_branch_pattern) + '$' | |
|
4425 | target_branch_regex = re.compile(target_pattern) | |
|
4426 | target_branch_match = bool(target_branch_regex.search(target_branch)) | |
|
4427 | ||
|
4428 | branch_matches = source_branch_match and target_branch_match | |
|
4429 | ||
|
4430 | files_matches = True | |
|
4431 | if self.file_pattern != '*': | |
|
4432 | files_matches = False | |
|
4433 | if self.file_pattern.startswith('re:'): | |
|
4434 | file_pattern = self.file_pattern[3:] | |
|
4435 | else: | |
|
4436 | file_pattern = glob2re(self.file_pattern) | |
|
4437 | file_regex = re.compile(file_pattern) | |
|
4438 | for filename in files_changed: | |
|
4439 | if file_regex.search(filename): | |
|
4440 | files_matches = True | |
|
4441 | break | |
|
4442 | ||
|
4443 | return branch_matches and files_matches | |
|
4444 | ||
|
4445 | @property | |
|
4446 | def review_users(self): | |
|
4447 | """ Returns the users which this rule applies to """ | |
|
4448 | ||
|
4449 | users = collections.OrderedDict() | |
|
4450 | ||
|
4451 | for rule_user in self.rule_users: | |
|
4452 | if rule_user.user.active: | |
|
4453 | if rule_user.user not in users: | |
|
4454 | users[rule_user.user.username] = { | |
|
4455 | 'user': rule_user.user, | |
|
4456 | 'source': 'user', | |
|
4457 | 'source_data': {}, | |
|
4458 | 'data': rule_user.rule_data() | |
|
4459 | } | |
|
4460 | ||
|
4461 | for rule_user_group in self.rule_user_groups: | |
|
4462 | source_data = { | |
|
4463 | 'user_group_id': rule_user_group.users_group.users_group_id, | |
|
4464 | 'name': rule_user_group.users_group.users_group_name, | |
|
4465 | 'members': len(rule_user_group.users_group.members) | |
|
4466 | } | |
|
4467 | for member in rule_user_group.users_group.members: | |
|
4468 | if member.user.active: | |
|
4469 | key = member.user.username | |
|
4470 | if key in users: | |
|
4471 | # skip this member as we have him already | |
|
4472 | # this prevents from override the "first" matched | |
|
4473 | # users with duplicates in multiple groups | |
|
4474 | continue | |
|
4475 | ||
|
4476 | users[key] = { | |
|
4477 | 'user': member.user, | |
|
4478 | 'source': 'user_group', | |
|
4479 | 'source_data': source_data, | |
|
4480 | 'data': rule_user_group.rule_data() | |
|
4481 | } | |
|
4482 | ||
|
4483 | return users | |
|
4484 | ||
|
4485 | def user_group_vote_rule(self, user_id): | |
|
4486 | ||
|
4487 | rules = [] | |
|
4488 | if not self.rule_user_groups: | |
|
4489 | return rules | |
|
4490 | ||
|
4491 | for user_group in self.rule_user_groups: | |
|
4492 | user_group_members = [x.user_id for x in user_group.users_group.members] | |
|
4493 | if user_id in user_group_members: | |
|
4494 | rules.append(user_group) | |
|
4495 | return rules | |
|
4496 | ||
|
4497 | def __repr__(self): | |
|
4498 | return '<RepoReviewerRule(id=%r, repo=%r)>' % ( | |
|
4499 | self.repo_review_rule_id, self.repo) | |
|
4500 | ||
|
4501 | ||
|
4502 | class ScheduleEntry(Base, BaseModel): | |
|
4503 | __tablename__ = 'schedule_entries' | |
|
4504 | __table_args__ = ( | |
|
4505 | UniqueConstraint('schedule_name', name='s_schedule_name_idx'), | |
|
4506 | UniqueConstraint('task_uid', name='s_task_uid_idx'), | |
|
4507 | base_table_args, | |
|
4508 | ) | |
|
4509 | ||
|
4510 | schedule_types = ['crontab', 'timedelta', 'integer'] | |
|
4511 | schedule_entry_id = Column('schedule_entry_id', Integer(), primary_key=True) | |
|
4512 | ||
|
4513 | schedule_name = Column("schedule_name", String(255), nullable=False, unique=None, default=None) | |
|
4514 | schedule_description = Column("schedule_description", String(10000), nullable=True, unique=None, default=None) | |
|
4515 | schedule_enabled = Column("schedule_enabled", Boolean(), nullable=False, unique=None, default=True) | |
|
4516 | ||
|
4517 | _schedule_type = Column("schedule_type", String(255), nullable=False, unique=None, default=None) | |
|
4518 | schedule_definition = Column('schedule_definition_json', MutationObj.as_mutable(JsonType(default=lambda: "", dialect_map=dict(mysql=LONGTEXT())))) | |
|
4519 | ||
|
4520 | schedule_last_run = Column('schedule_last_run', DateTime(timezone=False), nullable=True, unique=None, default=None) | |
|
4521 | schedule_total_run_count = Column('schedule_total_run_count', Integer(), nullable=True, unique=None, default=0) | |
|
4522 | ||
|
4523 | # task | |
|
4524 | task_uid = Column("task_uid", String(255), nullable=False, unique=None, default=None) | |
|
4525 | task_dot_notation = Column("task_dot_notation", String(4096), nullable=False, unique=None, default=None) | |
|
4526 | task_args = Column('task_args_json', MutationObj.as_mutable(JsonType(default=list, dialect_map=dict(mysql=LONGTEXT())))) | |
|
4527 | task_kwargs = Column('task_kwargs_json', MutationObj.as_mutable(JsonType(default=dict, dialect_map=dict(mysql=LONGTEXT())))) | |
|
4528 | ||
|
4529 | created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now) | |
|
4530 | updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=None) | |
|
4531 | ||
|
4532 | @hybrid_property | |
|
4533 | def schedule_type(self): | |
|
4534 | return self._schedule_type | |
|
4535 | ||
|
4536 | @schedule_type.setter | |
|
4537 | def schedule_type(self, val): | |
|
4538 | if val not in self.schedule_types: | |
|
4539 | raise ValueError('Value must be on of `{}` and got `{}`'.format( | |
|
4540 | val, self.schedule_type)) | |
|
4541 | ||
|
4542 | self._schedule_type = val | |
|
4543 | ||
|
4544 | @classmethod | |
|
4545 | def get_uid(cls, obj): | |
|
4546 | args = obj.task_args | |
|
4547 | kwargs = obj.task_kwargs | |
|
4548 | if isinstance(args, JsonRaw): | |
|
4549 | try: | |
|
4550 | args = json.loads(args) | |
|
4551 | except ValueError: | |
|
4552 | args = tuple() | |
|
4553 | ||
|
4554 | if isinstance(kwargs, JsonRaw): | |
|
4555 | try: | |
|
4556 | kwargs = json.loads(kwargs) | |
|
4557 | except ValueError: | |
|
4558 | kwargs = dict() | |
|
4559 | ||
|
4560 | dot_notation = obj.task_dot_notation | |
|
4561 | val = '.'.join(map(safe_str, [ | |
|
4562 | sorted(dot_notation), args, sorted(kwargs.items())])) | |
|
4563 | return hashlib.sha1(val).hexdigest() | |
|
4564 | ||
|
4565 | @classmethod | |
|
4566 | def get_by_schedule_name(cls, schedule_name): | |
|
4567 | return cls.query().filter(cls.schedule_name == schedule_name).scalar() | |
|
4568 | ||
|
4569 | @classmethod | |
|
4570 | def get_by_schedule_id(cls, schedule_id): | |
|
4571 | return cls.query().filter(cls.schedule_entry_id == schedule_id).scalar() | |
|
4572 | ||
|
4573 | @property | |
|
4574 | def task(self): | |
|
4575 | return self.task_dot_notation | |
|
4576 | ||
|
4577 | @property | |
|
4578 | def schedule(self): | |
|
4579 | from rhodecode.lib.celerylib.utils import raw_2_schedule | |
|
4580 | schedule = raw_2_schedule(self.schedule_definition, self.schedule_type) | |
|
4581 | return schedule | |
|
4582 | ||
|
4583 | @property | |
|
4584 | def args(self): | |
|
4585 | try: | |
|
4586 | return list(self.task_args or []) | |
|
4587 | except ValueError: | |
|
4588 | return list() | |
|
4589 | ||
|
4590 | @property | |
|
4591 | def kwargs(self): | |
|
4592 | try: | |
|
4593 | return dict(self.task_kwargs or {}) | |
|
4594 | except ValueError: | |
|
4595 | return dict() | |
|
4596 | ||
|
4597 | def _as_raw(self, val): | |
|
4598 | if hasattr(val, 'de_coerce'): | |
|
4599 | val = val.de_coerce() | |
|
4600 | if val: | |
|
4601 | val = json.dumps(val) | |
|
4602 | ||
|
4603 | return val | |
|
4604 | ||
|
4605 | @property | |
|
4606 | def schedule_definition_raw(self): | |
|
4607 | return self._as_raw(self.schedule_definition) | |
|
4608 | ||
|
4609 | @property | |
|
4610 | def args_raw(self): | |
|
4611 | return self._as_raw(self.task_args) | |
|
4612 | ||
|
4613 | @property | |
|
4614 | def kwargs_raw(self): | |
|
4615 | return self._as_raw(self.task_kwargs) | |
|
4616 | ||
|
4617 | def __repr__(self): | |
|
4618 | return '<DB:ScheduleEntry({}:{})>'.format( | |
|
4619 | self.schedule_entry_id, self.schedule_name) | |
|
4620 | ||
|
4621 | ||
|
4622 | @event.listens_for(ScheduleEntry, 'before_update') | |
|
4623 | def update_task_uid(mapper, connection, target): | |
|
4624 | target.task_uid = ScheduleEntry.get_uid(target) | |
|
4625 | ||
|
4626 | ||
|
4627 | @event.listens_for(ScheduleEntry, 'before_insert') | |
|
4628 | def set_task_uid(mapper, connection, target): | |
|
4629 | target.task_uid = ScheduleEntry.get_uid(target) | |
|
4630 | ||
|
4631 | ||
|
4632 | class _BaseBranchPerms(BaseModel): | |
|
4633 | @classmethod | |
|
4634 | def compute_hash(cls, value): | |
|
4635 | return sha1_safe(value) | |
|
4636 | ||
|
4637 | @hybrid_property | |
|
4638 | def branch_pattern(self): | |
|
4639 | return self._branch_pattern or '*' | |
|
4640 | ||
|
4641 | @hybrid_property | |
|
4642 | def branch_hash(self): | |
|
4643 | return self._branch_hash | |
|
4644 | ||
|
4645 | def _validate_glob(self, value): | |
|
4646 | re.compile('^' + glob2re(value) + '$') | |
|
4647 | ||
|
4648 | @branch_pattern.setter | |
|
4649 | def branch_pattern(self, value): | |
|
4650 | self._validate_glob(value) | |
|
4651 | self._branch_pattern = value or '*' | |
|
4652 | # set the Hash when setting the branch pattern | |
|
4653 | self._branch_hash = self.compute_hash(self._branch_pattern) | |
|
4654 | ||
|
4655 | def matches(self, branch): | |
|
4656 | """ | |
|
4657 | Check if this the branch matches entry | |
|
4658 | ||
|
4659 | :param branch: branch name for the commit | |
|
4660 | """ | |
|
4661 | ||
|
4662 | branch = branch or '' | |
|
4663 | ||
|
4664 | branch_matches = True | |
|
4665 | if branch: | |
|
4666 | branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$') | |
|
4667 | branch_matches = bool(branch_regex.search(branch)) | |
|
4668 | ||
|
4669 | return branch_matches | |
|
4670 | ||
|
4671 | ||
|
4672 | class UserToRepoBranchPermission(Base, _BaseBranchPerms): | |
|
4673 | __tablename__ = 'user_to_repo_branch_permissions' | |
|
4674 | __table_args__ = ( | |
|
4675 | {'extend_existing': True, 'mysql_engine': 'InnoDB', | |
|
4676 | 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,} | |
|
4677 | ) | |
|
4678 | ||
|
4679 | branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True) | |
|
4680 | ||
|
4681 | repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) | |
|
4682 | repo = relationship('Repository', backref='user_branch_perms') | |
|
4683 | ||
|
4684 | permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
|
4685 | permission = relationship('Permission') | |
|
4686 | ||
|
4687 | rule_to_perm_id = Column('rule_to_perm_id', Integer(), ForeignKey('repo_to_perm.repo_to_perm_id'), nullable=False, unique=None, default=None) | |
|
4688 | user_repo_to_perm = relationship('UserRepoToPerm') | |
|
4689 | ||
|
4690 | rule_order = Column('rule_order', Integer(), nullable=False) | |
|
4691 | _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default=u'*') # glob | |
|
4692 | _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql')) | |
|
4693 | ||
|
4694 | def __unicode__(self): | |
|
4695 | return u'<UserBranchPermission(%s => %r)>' % ( | |
|
4696 | self.user_repo_to_perm, self.branch_pattern) | |
|
4697 | ||
|
4698 | ||
|
4699 | class UserGroupToRepoBranchPermission(Base, _BaseBranchPerms): | |
|
4700 | __tablename__ = 'user_group_to_repo_branch_permissions' | |
|
4701 | __table_args__ = ( | |
|
4702 | {'extend_existing': True, 'mysql_engine': 'InnoDB', | |
|
4703 | 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,} | |
|
4704 | ) | |
|
4705 | ||
|
4706 | branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True) | |
|
4707 | ||
|
4708 | repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None) | |
|
4709 | repo = relationship('Repository', backref='user_group_branch_perms') | |
|
4710 | ||
|
4711 | permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None) | |
|
4712 | permission = relationship('Permission') | |
|
4713 | ||
|
4714 | 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) | |
|
4715 | user_group_repo_to_perm = relationship('UserGroupRepoToPerm') | |
|
4716 | ||
|
4717 | rule_order = Column('rule_order', Integer(), nullable=False) | |
|
4718 | _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default=u'*') # glob | |
|
4719 | _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql')) | |
|
4720 | ||
|
4721 | def __unicode__(self): | |
|
4722 | return u'<UserBranchPermission(%s => %r)>' % ( | |
|
4723 | self.user_group_repo_to_perm, self.branch_pattern) | |
|
4724 | ||
|
4725 | ||
|
4726 | class DbMigrateVersion(Base, BaseModel): | |
|
4727 | __tablename__ = 'db_migrate_version' | |
|
4728 | __table_args__ = ( | |
|
4729 | base_table_args, | |
|
4730 | ) | |
|
4731 | ||
|
4732 | repository_id = Column('repository_id', String(250), primary_key=True) | |
|
4733 | repository_path = Column('repository_path', Text) | |
|
4734 | version = Column('version', Integer) | |
|
4735 | ||
|
4736 | @classmethod | |
|
4737 | def set_version(cls, version): | |
|
4738 | """ | |
|
4739 | Helper for forcing a different version, usually for debugging purposes via ishell. | |
|
4740 | """ | |
|
4741 | ver = DbMigrateVersion.query().first() | |
|
4742 | ver.version = version | |
|
4743 | Session().commit() | |
|
4744 | ||
|
4745 | ||
|
4746 | class DbSession(Base, BaseModel): | |
|
4747 | __tablename__ = 'db_session' | |
|
4748 | __table_args__ = ( | |
|
4749 | base_table_args, | |
|
4750 | ) | |
|
4751 | ||
|
4752 | def __repr__(self): | |
|
4753 | return '<DB:DbSession({})>'.format(self.id) | |
|
4754 | ||
|
4755 | id = Column('id', Integer()) | |
|
4756 | namespace = Column('namespace', String(255), primary_key=True) | |
|
4757 | accessed = Column('accessed', DateTime, nullable=False) | |
|
4758 | created = Column('created', DateTime, nullable=False) | |
|
4759 | data = Column('data', PickleType, nullable=False) |
@@ -0,0 +1,37 b'' | |||
|
1 | import logging | |
|
2 | ||
|
3 | from sqlalchemy import * | |
|
4 | ||
|
5 | from rhodecode.model import meta | |
|
6 | from rhodecode.lib.dbmigrate.versions import _reset_base, notify | |
|
7 | ||
|
8 | log = logging.getLogger(__name__) | |
|
9 | ||
|
10 | ||
|
11 | def upgrade(migrate_engine): | |
|
12 | """ | |
|
13 | Upgrade operations go here. | |
|
14 | Don't create your own engine; bind migrate_engine to your metadata | |
|
15 | """ | |
|
16 | _reset_base(migrate_engine) | |
|
17 | from rhodecode.lib.dbmigrate.schema import db_4_13_0_0 as db | |
|
18 | ||
|
19 | pull_request = db.PullRequest.__table__ | |
|
20 | pull_request_version = db.PullRequestVersion.__table__ | |
|
21 | ||
|
22 | repo_state_1 = Column("pull_request_state", String(255), nullable=True) | |
|
23 | repo_state_1.create(table=pull_request) | |
|
24 | ||
|
25 | repo_state_2 = Column("pull_request_state", String(255), nullable=True) | |
|
26 | repo_state_2.create(table=pull_request_version) | |
|
27 | ||
|
28 | fixups(db, meta.Session) | |
|
29 | ||
|
30 | ||
|
31 | def downgrade(migrate_engine): | |
|
32 | meta = MetaData() | |
|
33 | meta.bind = migrate_engine | |
|
34 | ||
|
35 | ||
|
36 | def fixups(models, _SESSION): | |
|
37 | pass |
@@ -0,0 +1,41 b'' | |||
|
1 | import logging | |
|
2 | ||
|
3 | from sqlalchemy import * | |
|
4 | ||
|
5 | from rhodecode.model import meta | |
|
6 | from rhodecode.lib.dbmigrate.versions import _reset_base, notify | |
|
7 | ||
|
8 | log = logging.getLogger(__name__) | |
|
9 | ||
|
10 | ||
|
11 | def upgrade(migrate_engine): | |
|
12 | """ | |
|
13 | Upgrade operations go here. | |
|
14 | Don't create your own engine; bind migrate_engine to your metadata | |
|
15 | """ | |
|
16 | _reset_base(migrate_engine) | |
|
17 | from rhodecode.lib.dbmigrate.schema import db_4_16_0_0 as db | |
|
18 | ||
|
19 | fixups(db, meta.Session) | |
|
20 | ||
|
21 | ||
|
22 | def downgrade(migrate_engine): | |
|
23 | meta = MetaData() | |
|
24 | meta.bind = migrate_engine | |
|
25 | ||
|
26 | ||
|
27 | def fixups(models, _SESSION): | |
|
28 | # move the builtin token to external tokens | |
|
29 | ||
|
30 | log.info('Updating pull request pull_request_state to %s', | |
|
31 | models.PullRequest.STATE_CREATED) | |
|
32 | qry = _SESSION().query(models.PullRequest) | |
|
33 | qry.update({"pull_request_state": models.PullRequest.STATE_CREATED}) | |
|
34 | _SESSION().commit() | |
|
35 | ||
|
36 | log.info('Updating pull_request_version pull_request_state to %s', | |
|
37 | models.PullRequest.STATE_CREATED) | |
|
38 | qry = _SESSION().query(models.PullRequestVersion) | |
|
39 | qry.update({"pull_request_state": models.PullRequest.STATE_CREATED}) | |
|
40 | _SESSION().commit() | |
|
41 |
@@ -18,12 +18,6 b'' | |||
|
18 | 18 | # RhodeCode Enterprise Edition, including its added features, Support services, |
|
19 | 19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ |
|
20 | 20 | |
|
21 | """ | |
|
22 | ||
|
23 | RhodeCode, a web based repository management software | |
|
24 | versioning implementation: http://www.python.org/dev/peps/pep-0386/ | |
|
25 | """ | |
|
26 | ||
|
27 | 21 | import os |
|
28 | 22 | import sys |
|
29 | 23 | import platform |
@@ -51,7 +45,7 b' PYRAMID_SETTINGS = {}' | |||
|
51 | 45 | EXTENSIONS = {} |
|
52 | 46 | |
|
53 | 47 | __version__ = ('.'.join((str(each) for each in VERSION[:3]))) |
|
54 |
__dbversion__ = 9 |
|
|
48 | __dbversion__ = 93 # defines current db version for migrations | |
|
55 | 49 | __platform__ = platform.system() |
|
56 | 50 | __license__ = 'AGPLv3, and Commercial License' |
|
57 | 51 | __author__ = 'RhodeCode GmbH' |
@@ -65,6 +65,7 b' class TestGetPullRequest(object):' | |||
|
65 | 65 | 'title': pull_request.title, |
|
66 | 66 | 'description': pull_request.description, |
|
67 | 67 | 'status': pull_request.status, |
|
68 | 'state': pull_request.pull_request_state, | |
|
68 | 69 | 'created_on': pull_request.created_on, |
|
69 | 70 | 'updated_on': pull_request.updated_on, |
|
70 | 71 | 'commit_ids': pull_request.revisions, |
@@ -29,11 +29,10 b' from rhodecode.api.tests.utils import (' | |||
|
29 | 29 | |
|
30 | 30 | @pytest.mark.usefixtures("testuser_api", "app") |
|
31 | 31 | class TestMergePullRequest(object): |
|
32 | ||
|
32 | 33 | @pytest.mark.backends("git", "hg") |
|
33 | 34 | def test_api_merge_pull_request_merge_failed(self, pr_util, no_notifications): |
|
34 | 35 | pull_request = pr_util.create_pull_request(mergeable=True) |
|
35 | author = pull_request.user_id | |
|
36 | repo = pull_request.target_repo.repo_id | |
|
37 | 36 | pull_request_id = pull_request.pull_request_id |
|
38 | 37 | pull_request_repo = pull_request.target_repo.repo_name |
|
39 | 38 | |
@@ -46,8 +45,7 b' class TestMergePullRequest(object):' | |||
|
46 | 45 | |
|
47 | 46 | # The above api call detaches the pull request DB object from the |
|
48 | 47 | # session because of an unconditional transaction rollback in our |
|
49 | # middleware. Therefore we need to add it back here if we want to use | |
|
50 | # it. | |
|
48 | # middleware. Therefore we need to add it back here if we want to use it. | |
|
51 | 49 | Session().add(pull_request) |
|
52 | 50 | |
|
53 | 51 | expected = 'merge not possible for following reasons: ' \ |
@@ -55,6 +53,29 b' class TestMergePullRequest(object):' | |||
|
55 | 53 | assert_error(id_, expected, given=response.body) |
|
56 | 54 | |
|
57 | 55 | @pytest.mark.backends("git", "hg") |
|
56 | def test_api_merge_pull_request_merge_failed_disallowed_state( | |
|
57 | self, pr_util, no_notifications): | |
|
58 | pull_request = pr_util.create_pull_request(mergeable=True, approved=True) | |
|
59 | pull_request_id = pull_request.pull_request_id | |
|
60 | pull_request_repo = pull_request.target_repo.repo_name | |
|
61 | ||
|
62 | pr = PullRequest.get(pull_request_id) | |
|
63 | pr.pull_request_state = pull_request.STATE_UPDATING | |
|
64 | Session().add(pr) | |
|
65 | Session().commit() | |
|
66 | ||
|
67 | id_, params = build_data( | |
|
68 | self.apikey, 'merge_pull_request', | |
|
69 | repoid=pull_request_repo, | |
|
70 | pullrequestid=pull_request_id) | |
|
71 | ||
|
72 | response = api_call(self.app, params) | |
|
73 | expected = 'Operation forbidden because pull request is in state {}, '\ | |
|
74 | 'only state {} is allowed.'.format(PullRequest.STATE_UPDATING, | |
|
75 | PullRequest.STATE_CREATED) | |
|
76 | assert_error(id_, expected, given=response.body) | |
|
77 | ||
|
78 | @pytest.mark.backends("git", "hg") | |
|
58 | 79 | def test_api_merge_pull_request(self, pr_util, no_notifications): |
|
59 | 80 | pull_request = pr_util.create_pull_request(mergeable=True, approved=True) |
|
60 | 81 | author = pull_request.user_id |
@@ -123,8 +144,7 b' class TestMergePullRequest(object):' | |||
|
123 | 144 | assert_error(id_, expected, given=response.body) |
|
124 | 145 | |
|
125 | 146 | @pytest.mark.backends("git", "hg") |
|
126 | def test_api_merge_pull_request_non_admin_with_userid_error(self, | |
|
127 | pr_util): | |
|
147 | def test_api_merge_pull_request_non_admin_with_userid_error(self, pr_util): | |
|
128 | 148 | pull_request = pr_util.create_pull_request(mergeable=True) |
|
129 | 149 | id_, params = build_data( |
|
130 | 150 | self.apikey_regular, 'merge_pull_request', |
@@ -32,7 +32,7 b' from rhodecode.lib.base import vcs_opera' | |||
|
32 | 32 | from rhodecode.lib.utils2 import str2bool |
|
33 | 33 | from rhodecode.model.changeset_status import ChangesetStatusModel |
|
34 | 34 | from rhodecode.model.comment import CommentsModel |
|
35 | from rhodecode.model.db import Session, ChangesetStatus, ChangesetComment | |
|
35 | from rhodecode.model.db import Session, ChangesetStatus, ChangesetComment, PullRequest | |
|
36 | 36 | from rhodecode.model.pull_request import PullRequestModel, MergeCheck |
|
37 | 37 | from rhodecode.model.settings import SettingsModel |
|
38 | 38 | from rhodecode.model.validation_schema import Invalid |
@@ -128,11 +128,15 b' def get_pull_request(request, apiuser, p' | |||
|
128 | 128 | else: |
|
129 | 129 | repo = pull_request.target_repo |
|
130 | 130 | |
|
131 | if not PullRequestModel().check_user_read( | |
|
132 | pull_request, apiuser, api=True): | |
|
131 | if not PullRequestModel().check_user_read(pull_request, apiuser, api=True): | |
|
133 | 132 | raise JSONRPCError('repository `%s` or pull request `%s` ' |
|
134 | 133 | 'does not exist' % (repoid, pullrequestid)) |
|
135 | data = pull_request.get_api_data() | |
|
134 | ||
|
135 | # NOTE(marcink): only calculate and return merge state if the pr state is 'created' | |
|
136 | # otherwise we can lock the repo on calculation of merge state while update/merge | |
|
137 | # is happening. | |
|
138 | merge_state = pull_request.pull_request_state == pull_request.STATE_CREATED | |
|
139 | data = pull_request.get_api_data(with_merge_state=merge_state) | |
|
136 | 140 | return data |
|
137 | 141 | |
|
138 | 142 | |
@@ -283,8 +287,16 b' def merge_pull_request(' | |||
|
283 | 287 | else: |
|
284 | 288 | raise JSONRPCError('userid is not the same as your user') |
|
285 | 289 | |
|
290 | if pull_request.pull_request_state != PullRequest.STATE_CREATED: | |
|
291 | raise JSONRPCError( | |
|
292 | 'Operation forbidden because pull request is in state {}, ' | |
|
293 | 'only state {} is allowed.'.format( | |
|
294 | pull_request.pull_request_state, PullRequest.STATE_CREATED)) | |
|
295 | ||
|
296 | with pull_request.set_state(PullRequest.STATE_UPDATING): | |
|
286 | 297 | check = MergeCheck.validate( |
|
287 |
pull_request, auth_user=apiuser, |
|
|
298 | pull_request, auth_user=apiuser, | |
|
299 | translator=request.translate) | |
|
288 | 300 | merge_possible = not check.failed |
|
289 | 301 | |
|
290 | 302 | if not merge_possible: |
@@ -302,6 +314,7 b' def merge_pull_request(' | |||
|
302 | 314 | request.environ, repo_name=target_repo.repo_name, |
|
303 | 315 | username=apiuser.username, action='push', |
|
304 | 316 | scm=target_repo.repo_type) |
|
317 | with pull_request.set_state(PullRequest.STATE_UPDATING): | |
|
305 | 318 | merge_response = PullRequestModel().merge_repo( |
|
306 | 319 | pull_request, apiuser, extras=extras) |
|
307 | 320 | if merge_response.executed: |
@@ -829,9 +842,16 b' def update_pull_request(' | |||
|
829 | 842 | |
|
830 | 843 | commit_changes = {"added": [], "common": [], "removed": []} |
|
831 | 844 | if str2bool(Optional.extract(update_commits)): |
|
845 | ||
|
846 | if pull_request.pull_request_state != PullRequest.STATE_CREATED: | |
|
847 | raise JSONRPCError( | |
|
848 | 'Operation forbidden because pull request is in state {}, ' | |
|
849 | 'only state {} is allowed.'.format( | |
|
850 | pull_request.pull_request_state, PullRequest.STATE_CREATED)) | |
|
851 | ||
|
852 | with pull_request.set_state(PullRequest.STATE_UPDATING): | |
|
832 | 853 | if PullRequestModel().has_valid_update_type(pull_request): |
|
833 | update_response = PullRequestModel().update_commits( | |
|
834 | pull_request) | |
|
854 | update_response = PullRequestModel().update_commits(pull_request) | |
|
835 | 855 | commit_changes = update_response.changes or commit_changes |
|
836 | 856 | Session().commit() |
|
837 | 857 |
@@ -655,20 +655,20 b' class TestPullrequestsView(object):' | |||
|
655 | 655 | |
|
656 | 656 | # create pr from a in source to A in target |
|
657 | 657 | pull_request = PullRequest() |
|
658 | ||
|
658 | 659 | pull_request.source_repo = source |
|
659 | # TODO: johbo: Make sure that we write the source ref this way! | |
|
660 | 660 | pull_request.source_ref = 'branch:{branch}:{commit_id}'.format( |
|
661 | 661 | branch=backend.default_branch_name, commit_id=commit_ids['change']) |
|
662 | ||
|
662 | 663 | pull_request.target_repo = target |
|
663 | ||
|
664 | 664 | pull_request.target_ref = 'branch:{branch}:{commit_id}'.format( |
|
665 | branch=backend.default_branch_name, | |
|
666 | commit_id=commit_ids['ancestor']) | |
|
665 | branch=backend.default_branch_name, commit_id=commit_ids['ancestor']) | |
|
666 | ||
|
667 | 667 | pull_request.revisions = [commit_ids['change']] |
|
668 | 668 | pull_request.title = u"Test" |
|
669 | 669 | pull_request.description = u"Description" |
|
670 | pull_request.author = UserModel().get_by_username( | |
|
671 | TEST_USER_ADMIN_LOGIN) | |
|
670 | pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN) | |
|
671 | pull_request.pull_request_state = PullRequest.STATE_CREATED | |
|
672 | 672 | Session().add(pull_request) |
|
673 | 673 | Session().commit() |
|
674 | 674 | pull_request_id = pull_request.pull_request_id |
@@ -679,23 +679,21 b' class TestPullrequestsView(object):' | |||
|
679 | 679 | # update PR |
|
680 | 680 | self.app.post( |
|
681 | 681 | route_path('pullrequest_update', |
|
682 | repo_name=target.repo_name, pull_request_id=pull_request_id), | |
|
683 | params={'update_commits': 'true', 'csrf_token': csrf_token}) | |
|
684 | ||
|
685 | response = self.app.get( | |
|
686 | route_path('pullrequest_show', | |
|
682 | 687 | repo_name=target.repo_name, |
|
683 |
pull_request_id=pull_request_id) |
|
|
684 | params={'update_commits': 'true', | |
|
685 | 'csrf_token': csrf_token}) | |
|
688 | pull_request_id=pull_request.pull_request_id)) | |
|
689 | ||
|
690 | assert response.status_int == 200 | |
|
691 | assert 'Pull request updated to' in response.body | |
|
692 | assert 'with 1 added, 0 removed commits.' in response.body | |
|
686 | 693 | |
|
687 | 694 | # check that we have now both revisions |
|
688 | 695 | pull_request = PullRequest.get(pull_request_id) |
|
689 | assert pull_request.revisions == [ | |
|
690 | commit_ids['change-2'], commit_ids['change']] | |
|
691 | ||
|
692 | # TODO: johbo: this should be a test on its own | |
|
693 | response = self.app.get(route_path( | |
|
694 | 'pullrequest_new', | |
|
695 | repo_name=target.repo_name)) | |
|
696 | assert response.status_int == 200 | |
|
697 | assert 'Pull request updated to' in response.body | |
|
698 | assert 'with 1 added, 0 removed commits.' in response.body | |
|
696 | assert pull_request.revisions == [commit_ids['change-2'], commit_ids['change']] | |
|
699 | 697 | |
|
700 | 698 | def test_update_target_revision(self, backend, csrf_token): |
|
701 | 699 | commits = [ |
@@ -710,21 +708,21 b' class TestPullrequestsView(object):' | |||
|
710 | 708 | |
|
711 | 709 | # create pr from a in source to A in target |
|
712 | 710 | pull_request = PullRequest() |
|
711 | ||
|
713 | 712 | pull_request.source_repo = source |
|
714 | # TODO: johbo: Make sure that we write the source ref this way! | |
|
715 | 713 | pull_request.source_ref = 'branch:{branch}:{commit_id}'.format( |
|
716 | 714 | branch=backend.default_branch_name, commit_id=commit_ids['change']) |
|
715 | ||
|
717 | 716 | pull_request.target_repo = target |
|
718 | # TODO: johbo: Target ref should be branch based, since tip can jump | |
|
719 | # from branch to branch | |
|
720 | 717 | pull_request.target_ref = 'branch:{branch}:{commit_id}'.format( |
|
721 | branch=backend.default_branch_name, | |
|
722 | commit_id=commit_ids['ancestor']) | |
|
718 | branch=backend.default_branch_name, commit_id=commit_ids['ancestor']) | |
|
719 | ||
|
723 | 720 | pull_request.revisions = [commit_ids['change']] |
|
724 | 721 | pull_request.title = u"Test" |
|
725 | 722 | pull_request.description = u"Description" |
|
726 | pull_request.author = UserModel().get_by_username( | |
|
727 | TEST_USER_ADMIN_LOGIN) | |
|
723 | pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN) | |
|
724 | pull_request.pull_request_state = PullRequest.STATE_CREATED | |
|
725 | ||
|
728 | 726 | Session().add(pull_request) |
|
729 | 727 | Session().commit() |
|
730 | 728 | pull_request_id = pull_request.pull_request_id |
@@ -739,21 +737,19 b' class TestPullrequestsView(object):' | |||
|
739 | 737 | route_path('pullrequest_update', |
|
740 | 738 | repo_name=target.repo_name, |
|
741 | 739 | pull_request_id=pull_request_id), |
|
742 | params={'update_commits': 'true', | |
|
743 | 'csrf_token': csrf_token}, | |
|
740 | params={'update_commits': 'true', 'csrf_token': csrf_token}, | |
|
744 | 741 | status=200) |
|
745 | 742 | |
|
746 | 743 | # check that we have now both revisions |
|
747 | 744 | pull_request = PullRequest.get(pull_request_id) |
|
748 | 745 | assert pull_request.revisions == [commit_ids['change-rebased']] |
|
749 | 746 | assert pull_request.target_ref == 'branch:{branch}:{commit_id}'.format( |
|
750 | branch=backend.default_branch_name, | |
|
751 | commit_id=commit_ids['ancestor-new']) | |
|
747 | branch=backend.default_branch_name, commit_id=commit_ids['ancestor-new']) | |
|
752 | 748 | |
|
753 | # TODO: johbo: This should be a test on its own | |
|
754 | response = self.app.get(route_path( | |
|
755 | 'pullrequest_new', | |
|
756 | repo_name=target.repo_name)) | |
|
749 | response = self.app.get( | |
|
750 | route_path('pullrequest_show', | |
|
751 | repo_name=target.repo_name, | |
|
752 | pull_request_id=pull_request.pull_request_id)) | |
|
757 | 753 | assert response.status_int == 200 |
|
758 | 754 | assert 'Pull request updated to' in response.body |
|
759 | 755 | assert 'with 1 added, 1 removed commits.' in response.body |
@@ -775,17 +771,14 b' class TestPullrequestsView(object):' | |||
|
775 | 771 | # create pr from a in source to A in target |
|
776 | 772 | pull_request = PullRequest() |
|
777 | 773 | pull_request.source_repo = source |
|
778 | # TODO: johbo: Make sure that we write the source ref this way! | |
|
774 | ||
|
779 | 775 | pull_request.source_ref = 'branch:{branch}:{commit_id}'.format( |
|
780 | 776 | branch=backend.default_branch_name, |
|
781 | 777 | commit_id=commit_ids['master-commit-3-change-2']) |
|
782 | 778 | |
|
783 | 779 | pull_request.target_repo = target |
|
784 | # TODO: johbo: Target ref should be branch based, since tip can jump | |
|
785 | # from branch to branch | |
|
786 | 780 | pull_request.target_ref = 'branch:{branch}:{commit_id}'.format( |
|
787 | branch=backend.default_branch_name, | |
|
788 | commit_id=commit_ids['feat-commit-2']) | |
|
781 | branch=backend.default_branch_name, commit_id=commit_ids['feat-commit-2']) | |
|
789 | 782 | |
|
790 | 783 | pull_request.revisions = [ |
|
791 | 784 | commit_ids['feat-commit-1'], |
@@ -793,8 +786,8 b' class TestPullrequestsView(object):' | |||
|
793 | 786 | ] |
|
794 | 787 | pull_request.title = u"Test" |
|
795 | 788 | pull_request.description = u"Description" |
|
796 | pull_request.author = UserModel().get_by_username( | |
|
797 | TEST_USER_ADMIN_LOGIN) | |
|
789 | pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN) | |
|
790 | pull_request.pull_request_state = PullRequest.STATE_CREATED | |
|
798 | 791 | Session().add(pull_request) |
|
799 | 792 | Session().commit() |
|
800 | 793 | pull_request_id = pull_request.pull_request_id |
@@ -810,13 +803,10 b' class TestPullrequestsView(object):' | |||
|
810 | 803 | route_path('pullrequest_update', |
|
811 | 804 | repo_name=target.repo_name, |
|
812 | 805 | pull_request_id=pull_request_id), |
|
813 | params={'update_commits': 'true', | |
|
814 | 'csrf_token': csrf_token}, | |
|
806 | params={'update_commits': 'true', 'csrf_token': csrf_token}, | |
|
815 | 807 | status=200) |
|
816 | 808 | |
|
817 | response = self.app.get(route_path( | |
|
818 | 'pullrequest_new', | |
|
819 | repo_name=target.repo_name)) | |
|
809 | response = self.app.get(route_path('pullrequest_new', repo_name=target.repo_name)) | |
|
820 | 810 | assert response.status_int == 200 |
|
821 | 811 | response.mustcontain('Pull request updated to') |
|
822 | 812 | response.mustcontain('with 0 added, 0 removed commits.') |
@@ -836,21 +826,17 b' class TestPullrequestsView(object):' | |||
|
836 | 826 | # create pr from a in source to A in target |
|
837 | 827 | pull_request = PullRequest() |
|
838 | 828 | pull_request.source_repo = source |
|
839 | # TODO: johbo: Make sure that we write the source ref this way! | |
|
829 | ||
|
840 | 830 | pull_request.source_ref = 'branch:{branch}:{commit_id}'.format( |
|
841 | branch=backend.default_branch_name, | |
|
842 | commit_id=commit_ids['change']) | |
|
831 | branch=backend.default_branch_name, commit_id=commit_ids['change']) | |
|
843 | 832 | pull_request.target_repo = target |
|
844 | # TODO: johbo: Target ref should be branch based, since tip can jump | |
|
845 | # from branch to branch | |
|
846 | 833 | pull_request.target_ref = 'branch:{branch}:{commit_id}'.format( |
|
847 | branch=backend.default_branch_name, | |
|
848 | commit_id=commit_ids['ancestor']) | |
|
834 | branch=backend.default_branch_name, commit_id=commit_ids['ancestor']) | |
|
849 | 835 | pull_request.revisions = [commit_ids['change']] |
|
850 | 836 | pull_request.title = u"Test" |
|
851 | 837 | pull_request.description = u"Description" |
|
852 | pull_request.author = UserModel().get_by_username( | |
|
853 | TEST_USER_ADMIN_LOGIN) | |
|
838 | pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN) | |
|
839 | pull_request.pull_request_state = PullRequest.STATE_CREATED | |
|
854 | 840 | Session().add(pull_request) |
|
855 | 841 | Session().commit() |
|
856 | 842 | pull_request_id = pull_request.pull_request_id |
@@ -863,10 +849,8 b' class TestPullrequestsView(object):' | |||
|
863 | 849 | # update PR |
|
864 | 850 | self.app.post( |
|
865 | 851 | route_path('pullrequest_update', |
|
866 | repo_name=target.repo_name, | |
|
867 | pull_request_id=pull_request_id), | |
|
868 | params={'update_commits': 'true', | |
|
869 | 'csrf_token': csrf_token}, | |
|
852 | repo_name=target.repo_name, pull_request_id=pull_request_id), | |
|
853 | params={'update_commits': 'true', 'csrf_token': csrf_token}, | |
|
870 | 854 | status=200) |
|
871 | 855 | |
|
872 | 856 | # Expect the target reference to be updated correctly |
@@ -893,13 +877,12 b' class TestPullrequestsView(object):' | |||
|
893 | 877 | pull_request.source_ref = 'branch:{branch}:{commit_id}'.format( |
|
894 | 878 | branch=branch_name, commit_id=commit_ids['new-feature']) |
|
895 | 879 | pull_request.target_ref = 'branch:{branch}:{commit_id}'.format( |
|
896 | branch=backend_git.default_branch_name, | |
|
897 | commit_id=commit_ids['old-feature']) | |
|
880 | branch=backend_git.default_branch_name, commit_id=commit_ids['old-feature']) | |
|
898 | 881 | pull_request.revisions = [commit_ids['new-feature']] |
|
899 | 882 | pull_request.title = u"Test" |
|
900 | 883 | pull_request.description = u"Description" |
|
901 | pull_request.author = UserModel().get_by_username( | |
|
902 | TEST_USER_ADMIN_LOGIN) | |
|
884 | pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN) | |
|
885 | pull_request.pull_request_state = PullRequest.STATE_CREATED | |
|
903 | 886 | Session().add(pull_request) |
|
904 | 887 | Session().commit() |
|
905 | 888 |
@@ -273,9 +273,22 b' class RepoPullRequestsView(RepoAppView, ' | |||
|
273 | 273 | route_name='pullrequest_show', request_method='GET', |
|
274 | 274 | renderer='rhodecode:templates/pullrequests/pullrequest_show.mako') |
|
275 | 275 | def pull_request_show(self): |
|
276 | pull_request_id = self.request.matchdict['pull_request_id'] | |
|
276 | _ = self.request.translate | |
|
277 | c = self.load_default_context() | |
|
278 | ||
|
279 | pull_request = PullRequest.get_or_404( | |
|
280 | self.request.matchdict['pull_request_id']) | |
|
281 | pull_request_id = pull_request.pull_request_id | |
|
277 | 282 | |
|
278 | c = self.load_default_context() | |
|
283 | if pull_request.pull_request_state != PullRequest.STATE_CREATED: | |
|
284 | log.debug('show: forbidden because pull request is in state %s', | |
|
285 | pull_request.pull_request_state) | |
|
286 | msg = _(u'Cannot show pull requests in state other than `{}`. ' | |
|
287 | u'Current state is: `{}`').format(PullRequest.STATE_CREATED, | |
|
288 | pull_request.pull_request_state) | |
|
289 | h.flash(msg, category='error') | |
|
290 | raise HTTPFound(h.route_path('pullrequest_show_all', | |
|
291 | repo_name=self.db_repo_name)) | |
|
279 | 292 | |
|
280 | 293 | version = self.request.GET.get('version') |
|
281 | 294 | from_version = self.request.GET.get('from_version') or version |
@@ -919,12 +932,17 b' class RepoPullRequestsView(RepoAppView, ' | |||
|
919 | 932 | source_db_repo = Repository.get_by_repo_name(_form['source_repo']) |
|
920 | 933 | target_db_repo = Repository.get_by_repo_name(_form['target_repo']) |
|
921 | 934 | |
|
935 | if not (source_db_repo or target_db_repo): | |
|
936 | h.flash(_('source_repo or target repo not found'), category='error') | |
|
937 | raise HTTPFound( | |
|
938 | h.route_path('pullrequest_new', repo_name=self.db_repo_name)) | |
|
939 | ||
|
922 | 940 | # re-check permissions again here |
|
923 | 941 | # source_repo we must have read permissions |
|
924 | 942 | |
|
925 | 943 | source_perm = HasRepoPermissionAny( |
|
926 | 'repository.read', | |
|
927 |
|
|
|
944 | 'repository.read', 'repository.write', 'repository.admin')( | |
|
945 | source_db_repo.repo_name) | |
|
928 | 946 | if not source_perm: |
|
929 | 947 | msg = _('Not Enough permissions to source repo `{}`.'.format( |
|
930 | 948 | source_db_repo.repo_name)) |
@@ -938,8 +956,8 b' class RepoPullRequestsView(RepoAppView, ' | |||
|
938 | 956 | # target repo we must have read permissions, and also later on |
|
939 | 957 | # we want to check branch permissions here |
|
940 | 958 | target_perm = HasRepoPermissionAny( |
|
941 | 'repository.read', | |
|
942 |
|
|
|
959 | 'repository.read', 'repository.write', 'repository.admin')( | |
|
960 | target_db_repo.repo_name) | |
|
943 | 961 | if not target_perm: |
|
944 | 962 | msg = _('Not Enough permissions to target repo `{}`.'.format( |
|
945 | 963 | target_db_repo.repo_name)) |
@@ -1042,6 +1060,15 b' class RepoPullRequestsView(RepoAppView, ' | |||
|
1042 | 1060 | h.flash(msg, category='error') |
|
1043 | 1061 | return True |
|
1044 | 1062 | |
|
1063 | if pull_request.pull_request_state != PullRequest.STATE_CREATED: | |
|
1064 | log.debug('update: forbidden because pull request is in state %s', | |
|
1065 | pull_request.pull_request_state) | |
|
1066 | msg = _(u'Cannot update pull requests in state other than `{}`. ' | |
|
1067 | u'Current state is: `{}`').format(PullRequest.STATE_CREATED, | |
|
1068 | pull_request.pull_request_state) | |
|
1069 | h.flash(msg, category='error') | |
|
1070 | return True | |
|
1071 | ||
|
1045 | 1072 | # only owner or admin can update it |
|
1046 | 1073 | allowed_to_update = PullRequestModel().check_user_update( |
|
1047 | 1074 | pull_request, self._rhodecode_user) |
@@ -1084,6 +1111,8 b' class RepoPullRequestsView(RepoAppView, ' | |||
|
1084 | 1111 | |
|
1085 | 1112 | def _update_commits(self, pull_request): |
|
1086 | 1113 | _ = self.request.translate |
|
1114 | ||
|
1115 | with pull_request.set_state(PullRequest.STATE_UPDATING): | |
|
1087 | 1116 | resp = PullRequestModel().update_commits(pull_request) |
|
1088 | 1117 | |
|
1089 | 1118 | if resp.executed: |
@@ -1097,8 +1126,7 b' class RepoPullRequestsView(RepoAppView, ' | |||
|
1097 | 1126 | else: |
|
1098 | 1127 | changed = 'nothing' |
|
1099 | 1128 | |
|
1100 | msg = _( | |
|
1101 | u'Pull request updated to "{source_commit_id}" with ' | |
|
1129 | msg = _(u'Pull request updated to "{source_commit_id}" with ' | |
|
1102 | 1130 | u'{count_added} added, {count_removed} removed commits. ' |
|
1103 | 1131 | u'Source of changes: {change_source}') |
|
1104 | 1132 | msg = msg.format( |
@@ -1109,8 +1137,7 b' class RepoPullRequestsView(RepoAppView, ' | |||
|
1109 | 1137 | h.flash(msg, category='success') |
|
1110 | 1138 | |
|
1111 | 1139 | channel = '/repo${}$/pr/{}'.format( |
|
1112 | pull_request.target_repo.repo_name, | |
|
1113 | pull_request.pull_request_id) | |
|
1140 | pull_request.target_repo.repo_name, pull_request.pull_request_id) | |
|
1114 | 1141 | message = msg + ( |
|
1115 | 1142 | ' - <a onclick="window.location.reload()">' |
|
1116 | 1143 | '<strong>{}</strong></a>'.format(_('Reload page'))) |
@@ -1143,8 +1170,23 b' class RepoPullRequestsView(RepoAppView, ' | |||
|
1143 | 1170 | """ |
|
1144 | 1171 | pull_request = PullRequest.get_or_404( |
|
1145 | 1172 | self.request.matchdict['pull_request_id']) |
|
1173 | _ = self.request.translate | |
|
1174 | ||
|
1175 | if pull_request.pull_request_state != PullRequest.STATE_CREATED: | |
|
1176 | log.debug('show: forbidden because pull request is in state %s', | |
|
1177 | pull_request.pull_request_state) | |
|
1178 | msg = _(u'Cannot merge pull requests in state other than `{}`. ' | |
|
1179 | u'Current state is: `{}`').format(PullRequest.STATE_CREATED, | |
|
1180 | pull_request.pull_request_state) | |
|
1181 | h.flash(msg, category='error') | |
|
1182 | raise HTTPFound( | |
|
1183 | h.route_path('pullrequest_show', | |
|
1184 | repo_name=pull_request.target_repo.repo_name, | |
|
1185 | pull_request_id=pull_request.pull_request_id)) | |
|
1146 | 1186 | |
|
1147 | 1187 | self.load_default_context() |
|
1188 | ||
|
1189 | with pull_request.set_state(PullRequest.STATE_UPDATING): | |
|
1148 | 1190 | check = MergeCheck.validate( |
|
1149 | 1191 | pull_request, auth_user=self._rhodecode_user, |
|
1150 | 1192 | translator=self.request.translate) |
@@ -1159,6 +1201,7 b' class RepoPullRequestsView(RepoAppView, ' | |||
|
1159 | 1201 | self.request.environ, repo_name=pull_request.target_repo.repo_name, |
|
1160 | 1202 | username=self._rhodecode_db_user.username, action='push', |
|
1161 | 1203 | scm=pull_request.target_repo.repo_type) |
|
1204 | with pull_request.set_state(PullRequest.STATE_UPDATING): | |
|
1162 | 1205 | self._merge_pull_request( |
|
1163 | 1206 | pull_request, self._rhodecode_db_user, extras) |
|
1164 | 1207 | else: |
@@ -3538,6 +3538,32 b' class ChangesetStatus(Base, BaseModel):' | |||
|
3538 | 3538 | return data |
|
3539 | 3539 | |
|
3540 | 3540 | |
|
3541 | class _SetState(object): | |
|
3542 | """ | |
|
3543 | Context processor allowing changing state for sensitive operation such as | |
|
3544 | pull request update or merge | |
|
3545 | """ | |
|
3546 | ||
|
3547 | def __init__(self, pull_request, pr_state, back_state=None): | |
|
3548 | self._pr = pull_request | |
|
3549 | self._org_state = back_state or pull_request.pull_request_state | |
|
3550 | self._pr_state = pr_state | |
|
3551 | ||
|
3552 | def __enter__(self): | |
|
3553 | log.debug('StateLock: entering set state context, setting state to: `%s`', | |
|
3554 | self._pr_state) | |
|
3555 | self._pr.pull_request_state = self._pr_state | |
|
3556 | Session().add(self._pr) | |
|
3557 | Session().commit() | |
|
3558 | ||
|
3559 | def __exit__(self, exc_type, exc_val, exc_tb): | |
|
3560 | log.debug('StateLock: exiting set state context, setting state to: `%s`', | |
|
3561 | self._org_state) | |
|
3562 | self._pr.pull_request_state = self._org_state | |
|
3563 | Session().add(self._pr) | |
|
3564 | Session().commit() | |
|
3565 | ||
|
3566 | ||
|
3541 | 3567 | class _PullRequestBase(BaseModel): |
|
3542 | 3568 | """ |
|
3543 | 3569 | Common attributes of pull request and version entries. |
@@ -3548,6 +3574,12 b' class _PullRequestBase(BaseModel):' | |||
|
3548 | 3574 | STATUS_OPEN = u'open' |
|
3549 | 3575 | STATUS_CLOSED = u'closed' |
|
3550 | 3576 | |
|
3577 | # available states | |
|
3578 | STATE_CREATING = u'creating' | |
|
3579 | STATE_UPDATING = u'updating' | |
|
3580 | STATE_MERGING = u'merging' | |
|
3581 | STATE_CREATED = u'created' | |
|
3582 | ||
|
3551 | 3583 | title = Column('title', Unicode(255), nullable=True) |
|
3552 | 3584 | description = Column( |
|
3553 | 3585 | 'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), |
@@ -3563,6 +3595,8 b' class _PullRequestBase(BaseModel):' | |||
|
3563 | 3595 | 'updated_on', DateTime(timezone=False), nullable=False, |
|
3564 | 3596 | default=datetime.datetime.now) |
|
3565 | 3597 | |
|
3598 | pull_request_state = Column("pull_request_state", String(255), nullable=True) | |
|
3599 | ||
|
3566 | 3600 | @declared_attr |
|
3567 | 3601 | def user_id(cls): |
|
3568 | 3602 | return Column( |
@@ -3737,6 +3771,7 b' class _PullRequestBase(BaseModel):' | |||
|
3737 | 3771 | 'title': pull_request.title, |
|
3738 | 3772 | 'description': pull_request.description, |
|
3739 | 3773 | 'status': pull_request.status, |
|
3774 | 'state': pull_request.pull_request_state, | |
|
3740 | 3775 | 'created_on': pull_request.created_on, |
|
3741 | 3776 | 'updated_on': pull_request.updated_on, |
|
3742 | 3777 | 'commit_ids': pull_request.revisions, |
@@ -3777,6 +3812,20 b' class _PullRequestBase(BaseModel):' | |||
|
3777 | 3812 | |
|
3778 | 3813 | return data |
|
3779 | 3814 | |
|
3815 | def set_state(self, pull_request_state, final_state=None): | |
|
3816 | """ | |
|
3817 | # goes from initial state to updating to initial state. | |
|
3818 | # initial state can be changed by specifying back_state= | |
|
3819 | with pull_request_obj.set_state(PullRequest.STATE_UPDATING): | |
|
3820 | pull_request.merge() | |
|
3821 | ||
|
3822 | :param pull_request_state: | |
|
3823 | :param final_state: | |
|
3824 | ||
|
3825 | """ | |
|
3826 | ||
|
3827 | return _SetState(self, pull_request_state, back_state=final_state) | |
|
3828 | ||
|
3780 | 3829 | |
|
3781 | 3830 | class PullRequest(Base, _PullRequestBase): |
|
3782 | 3831 | __tablename__ = 'pull_requests' |
@@ -138,7 +138,7 b' class PullRequestModel(BaseModel):' | |||
|
138 | 138 | |
|
139 | 139 | def _prepare_get_all_query(self, repo_name, source=False, statuses=None, |
|
140 | 140 | opened_by=None, order_by=None, |
|
141 | order_dir='desc'): | |
|
141 | order_dir='desc', only_created=True): | |
|
142 | 142 | repo = None |
|
143 | 143 | if repo_name: |
|
144 | 144 | repo = self._get_repo(repo_name) |
@@ -159,6 +159,10 b' class PullRequestModel(BaseModel):' | |||
|
159 | 159 | if opened_by: |
|
160 | 160 | q = q.filter(PullRequest.user_id.in_(opened_by)) |
|
161 | 161 | |
|
162 | # only get those that are in "created" state | |
|
163 | if only_created: | |
|
164 | q = q.filter(PullRequest.pull_request_state == PullRequest.STATE_CREATED) | |
|
165 | ||
|
162 | 166 | if order_by: |
|
163 | 167 | order_map = { |
|
164 | 168 | 'name_raw': PullRequest.pull_request_id, |
@@ -429,7 +433,7 b' class PullRequestModel(BaseModel):' | |||
|
429 | 433 | pull_request.description_renderer = description_renderer |
|
430 | 434 | pull_request.author = created_by_user |
|
431 | 435 | pull_request.reviewer_data = reviewer_data |
|
432 | ||
|
436 | pull_request.pull_request_state = pull_request.STATE_CREATING | |
|
433 | 437 | Session().add(pull_request) |
|
434 | 438 | Session().flush() |
|
435 | 439 | |
@@ -497,7 +501,14 b' class PullRequestModel(BaseModel):' | |||
|
497 | 501 | # that for large repos could be long resulting in long row locks |
|
498 | 502 | Session().commit() |
|
499 | 503 | |
|
500 | # prepare workspace, and run initial merge simulation | |
|
504 | # prepare workspace, and run initial merge simulation. Set state during that | |
|
505 | # operation | |
|
506 | pull_request = PullRequest.get(pull_request.pull_request_id) | |
|
507 | ||
|
508 | # set as merging, for simulation, and if finished to created so we mark | |
|
509 | # simulation is working fine | |
|
510 | with pull_request.set_state(PullRequest.STATE_MERGING, | |
|
511 | final_state=PullRequest.STATE_CREATED): | |
|
501 | 512 | MergeCheck.validate( |
|
502 | 513 | pull_request, auth_user=auth_user, translator=translator) |
|
503 | 514 | |
@@ -653,8 +664,7 b' class PullRequestModel(BaseModel):' | |||
|
653 | 664 | target_ref_id = pull_request.target_ref_parts.commit_id |
|
654 | 665 | |
|
655 | 666 | if not self.has_valid_update_type(pull_request): |
|
656 | log.debug( | |
|
657 | "Skipping update of pull request %s due to ref type: %s", | |
|
667 | log.debug("Skipping update of pull request %s due to ref type: %s", | |
|
658 | 668 | pull_request, source_ref_type) |
|
659 | 669 | return UpdateResponse( |
|
660 | 670 | executed=False, |
@@ -801,8 +811,7 b' class PullRequestModel(BaseModel):' | |||
|
801 | 811 | pull_request.source_ref_parts.commit_id, |
|
802 | 812 | pull_request_version.pull_request_version_id) |
|
803 | 813 | Session().commit() |
|
804 | self._trigger_pull_request_hook( | |
|
805 | pull_request, pull_request.author, 'update') | |
|
814 | self._trigger_pull_request_hook(pull_request, pull_request.author, 'update') | |
|
806 | 815 | |
|
807 | 816 | return UpdateResponse( |
|
808 | 817 | executed=True, reason=UpdateFailureReason.NONE, |
@@ -814,6 +823,7 b' class PullRequestModel(BaseModel):' | |||
|
814 | 823 | version.title = pull_request.title |
|
815 | 824 | version.description = pull_request.description |
|
816 | 825 | version.status = pull_request.status |
|
826 | version.pull_request_state = pull_request.pull_request_state | |
|
817 | 827 | version.created_on = datetime.datetime.now() |
|
818 | 828 | version.updated_on = pull_request.updated_on |
|
819 | 829 | version.user_id = pull_request.user_id |
@@ -1614,8 +1624,7 b' class MergeCheck(object):' | |||
|
1614 | 1624 | |
|
1615 | 1625 | msg = _('Pull request reviewer approval is pending.') |
|
1616 | 1626 | |
|
1617 | merge_check.push_error( | |
|
1618 | 'warning', msg, cls.REVIEW_CHECK, review_status) | |
|
1627 | merge_check.push_error('warning', msg, cls.REVIEW_CHECK, review_status) | |
|
1619 | 1628 | |
|
1620 | 1629 | if fail_early: |
|
1621 | 1630 | return merge_check |
@@ -1624,7 +1633,7 b' class MergeCheck(object):' | |||
|
1624 | 1633 | todos = CommentsModel().get_unresolved_todos(pull_request) |
|
1625 | 1634 | if todos: |
|
1626 | 1635 | log.debug("MergeCheck: cannot merge, {} " |
|
1627 |
"unresolved |
|
|
1636 | "unresolved TODOs left.".format(len(todos))) | |
|
1628 | 1637 | |
|
1629 | 1638 | if len(todos) == 1: |
|
1630 | 1639 | msg = _('Cannot merge, {} TODO still not resolved.').format( |
@@ -1645,8 +1654,7 b' class MergeCheck(object):' | |||
|
1645 | 1654 | merge_check.merge_possible = merge_status |
|
1646 | 1655 | merge_check.merge_msg = msg |
|
1647 | 1656 | if not merge_status: |
|
1648 | log.debug( | |
|
1649 | "MergeCheck: cannot merge, pull request merge not possible.") | |
|
1657 | log.debug("MergeCheck: cannot merge, pull request merge not possible.") | |
|
1650 | 1658 | merge_check.push_error('warning', msg, cls.MERGE_CHECK, None) |
|
1651 | 1659 | |
|
1652 | 1660 | if fail_early: |
@@ -1677,6 +1685,7 b' class MergeCheck(object):' | |||
|
1677 | 1685 | close_branch = model._close_branch_before_merging(pull_request) |
|
1678 | 1686 | if close_branch: |
|
1679 | 1687 | repo_type = pull_request.target_repo.repo_type |
|
1688 | close_msg = '' | |
|
1680 | 1689 | if repo_type == 'hg': |
|
1681 | 1690 | close_msg = _('Source branch will be closed after merge.') |
|
1682 | 1691 | elif repo_type == 'git': |
@@ -1689,6 +1698,7 b' class MergeCheck(object):' | |||
|
1689 | 1698 | |
|
1690 | 1699 | return merge_details |
|
1691 | 1700 | |
|
1701 | ||
|
1692 | 1702 | ChangeTuple = collections.namedtuple( |
|
1693 | 1703 | 'ChangeTuple', ['added', 'common', 'removed', 'total']) |
|
1694 | 1704 |
@@ -257,8 +257,7 b' class TestPullRequestModel(object):' | |||
|
257 | 257 | def has_largefiles(self, repo): |
|
258 | 258 | return repo == pull_request.source_repo |
|
259 | 259 | |
|
260 | patcher = mock.patch.object( | |
|
261 | PullRequestModel, '_has_largefiles', has_largefiles) | |
|
260 | patcher = mock.patch.object(PullRequestModel, '_has_largefiles', has_largefiles) | |
|
262 | 261 | with patcher: |
|
263 | 262 | status, msg = PullRequestModel().merge_status(pull_request) |
|
264 | 263 | |
@@ -270,8 +269,7 b' class TestPullRequestModel(object):' | |||
|
270 | 269 | def has_largefiles(self, repo): |
|
271 | 270 | return repo == pull_request.target_repo |
|
272 | 271 | |
|
273 | patcher = mock.patch.object( | |
|
274 | PullRequestModel, '_has_largefiles', has_largefiles) | |
|
272 | patcher = mock.patch.object(PullRequestModel, '_has_largefiles', has_largefiles) | |
|
275 | 273 | with patcher: |
|
276 | 274 | status, msg = PullRequestModel().merge_status(pull_request) |
|
277 | 275 | |
@@ -314,9 +312,50 b' class TestPullRequestModel(object):' | |||
|
314 | 312 | self.pull_request, self.pull_request.author, 'merge') |
|
315 | 313 | |
|
316 | 314 | pull_request = PullRequest.get(pull_request.pull_request_id) |
|
317 | assert ( | |
|
318 | pull_request.merge_rev == | |
|
319 | '6126b7bfcc82ad2d3deaee22af926b082ce54cc6') | |
|
315 | assert pull_request.merge_rev == '6126b7bfcc82ad2d3deaee22af926b082ce54cc6' | |
|
316 | ||
|
317 | def test_merge_with_status_lock(self, pull_request, merge_extras): | |
|
318 | user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN) | |
|
319 | merge_ref = Reference( | |
|
320 | 'type', 'name', '6126b7bfcc82ad2d3deaee22af926b082ce54cc6') | |
|
321 | self.merge_mock.return_value = MergeResponse( | |
|
322 | True, True, merge_ref, MergeFailureReason.NONE) | |
|
323 | ||
|
324 | merge_extras['repository'] = pull_request.target_repo.repo_name | |
|
325 | ||
|
326 | with pull_request.set_state(PullRequest.STATE_UPDATING): | |
|
327 | assert pull_request.pull_request_state == PullRequest.STATE_UPDATING | |
|
328 | PullRequestModel().merge_repo( | |
|
329 | pull_request, pull_request.author, extras=merge_extras) | |
|
330 | ||
|
331 | assert pull_request.pull_request_state == PullRequest.STATE_CREATED | |
|
332 | ||
|
333 | message = ( | |
|
334 | u'Merge pull request #{pr_id} from {source_repo} {source_ref_name}' | |
|
335 | u'\n\n {pr_title}'.format( | |
|
336 | pr_id=pull_request.pull_request_id, | |
|
337 | source_repo=safe_unicode( | |
|
338 | pull_request.source_repo.scm_instance().name), | |
|
339 | source_ref_name=pull_request.source_ref_parts.name, | |
|
340 | pr_title=safe_unicode(pull_request.title) | |
|
341 | ) | |
|
342 | ) | |
|
343 | self.merge_mock.assert_called_with( | |
|
344 | self.repo_id, self.workspace_id, | |
|
345 | pull_request.target_ref_parts, | |
|
346 | pull_request.source_repo.scm_instance(), | |
|
347 | pull_request.source_ref_parts, | |
|
348 | user_name=user.short_contact, user_email=user.email, message=message, | |
|
349 | use_rebase=False, close_branch=False | |
|
350 | ) | |
|
351 | self.invalidation_mock.assert_called_once_with( | |
|
352 | pull_request.target_repo.repo_name) | |
|
353 | ||
|
354 | self.hook_mock.assert_called_with( | |
|
355 | self.pull_request, self.pull_request.author, 'merge') | |
|
356 | ||
|
357 | pull_request = PullRequest.get(pull_request.pull_request_id) | |
|
358 | assert pull_request.merge_rev == '6126b7bfcc82ad2d3deaee22af926b082ce54cc6' | |
|
320 | 359 | |
|
321 | 360 | def test_merge_failed(self, pull_request, merge_extras): |
|
322 | 361 | user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN) |
General Comments 0
You need to be logged in to leave comments.
Login now