##// END OF EJS Templates
pull-requests: added observers, and fix few problems with versioned comments
marcink -
r4481:d52ab7ab default
parent child Browse files
Show More
This diff has been collapsed as it changes many lines, (5689 lines changed) Show them Hide them
@@ -0,0 +1,5689 b''
1 # -*- coding: utf-8 -*-
2
3 # Copyright (C) 2010-2020 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 string
29 import hashlib
30 import logging
31 import datetime
32 import uuid
33 import warnings
34 import ipaddress
35 import functools
36 import traceback
37 import collections
38
39 from sqlalchemy import (
40 or_, and_, not_, func, cast, TypeDecorator, event,
41 Index, Sequence, UniqueConstraint, ForeignKey, CheckConstraint, Column,
42 Boolean, String, Unicode, UnicodeText, DateTime, Integer, LargeBinary,
43 Text, Float, PickleType, BigInteger)
44 from sqlalchemy.sql.expression import true, false, case
45 from sqlalchemy.sql.functions import coalesce, count # pragma: no cover
46 from sqlalchemy.orm import (
47 relationship, joinedload, class_mapper, validates, aliased)
48 from sqlalchemy.ext.declarative import declared_attr
49 from sqlalchemy.ext.hybrid import hybrid_property
50 from sqlalchemy.exc import IntegrityError # pragma: no cover
51 from sqlalchemy.dialects.mysql import LONGTEXT
52 from zope.cachedescriptors.property import Lazy as LazyProperty
53 from pyramid import compat
54 from pyramid.threadlocal import get_current_request
55 from webhelpers2.text import remove_formatting
56
57 from rhodecode.translation import _
58 from rhodecode.lib.vcs import get_vcs_instance, VCSError
59 from rhodecode.lib.vcs.backends.base import EmptyCommit, Reference
60 from rhodecode.lib.utils2 import (
61 str2bool, safe_str, get_commit_safe, safe_unicode, sha1_safe,
62 time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,
63 glob2re, StrictAttributeDict, cleaned_uri, datetime_to_time, OrderedDefaultDict)
64 from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType, \
65 JsonRaw
66 from rhodecode.lib.ext_json import json
67 from rhodecode.lib.caching_query import FromCache
68 from rhodecode.lib.encrypt import AESCipher, validate_and_get_enc_data
69 from rhodecode.lib.encrypt2 import Encryptor
70 from rhodecode.lib.exceptions import (
71 ArtifactMetadataDuplicate, ArtifactMetadataBadValueType)
72 from rhodecode.model.meta import Base, Session
73
74 URL_SEP = '/'
75 log = logging.getLogger(__name__)
76
77 # =============================================================================
78 # BASE CLASSES
79 # =============================================================================
80
81 # this is propagated from .ini file rhodecode.encrypted_values.secret or
82 # beaker.session.secret if first is not set.
83 # and initialized at environment.py
84 ENCRYPTION_KEY = None
85
86 # used to sort permissions by types, '#' used here is not allowed to be in
87 # usernames, and it's very early in sorted string.printable table.
88 PERMISSION_TYPE_SORT = {
89 'admin': '####',
90 'write': '###',
91 'read': '##',
92 'none': '#',
93 }
94
95
96 def display_user_sort(obj):
97 """
98 Sort function used to sort permissions in .permissions() function of
99 Repository, RepoGroup, UserGroup. Also it put the default user in front
100 of all other resources
101 """
102
103 if obj.username == User.DEFAULT_USER:
104 return '#####'
105 prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
106 extra_sort_num = '1' # default
107
108 # NOTE(dan): inactive duplicates goes last
109 if getattr(obj, 'duplicate_perm', None):
110 extra_sort_num = '9'
111 return prefix + extra_sort_num + obj.username
112
113
114 def display_user_group_sort(obj):
115 """
116 Sort function used to sort permissions in .permissions() function of
117 Repository, RepoGroup, UserGroup. Also it put the default user in front
118 of all other resources
119 """
120
121 prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
122 return prefix + obj.users_group_name
123
124
125 def _hash_key(k):
126 return sha1_safe(k)
127
128
129 def in_filter_generator(qry, items, limit=500):
130 """
131 Splits IN() into multiple with OR
132 e.g.::
133 cnt = Repository.query().filter(
134 or_(
135 *in_filter_generator(Repository.repo_id, range(100000))
136 )).count()
137 """
138 if not items:
139 # empty list will cause empty query which might cause security issues
140 # this can lead to hidden unpleasant results
141 items = [-1]
142
143 parts = []
144 for chunk in xrange(0, len(items), limit):
145 parts.append(
146 qry.in_(items[chunk: chunk + limit])
147 )
148
149 return parts
150
151
152 base_table_args = {
153 'extend_existing': True,
154 'mysql_engine': 'InnoDB',
155 'mysql_charset': 'utf8',
156 'sqlite_autoincrement': True
157 }
158
159
160 class EncryptedTextValue(TypeDecorator):
161 """
162 Special column for encrypted long text data, use like::
163
164 value = Column("encrypted_value", EncryptedValue(), nullable=False)
165
166 This column is intelligent so if value is in unencrypted form it return
167 unencrypted form, but on save it always encrypts
168 """
169 impl = Text
170
171 def process_bind_param(self, value, dialect):
172 """
173 Setter for storing value
174 """
175 import rhodecode
176 if not value:
177 return value
178
179 # protect against double encrypting if values is already encrypted
180 if value.startswith('enc$aes$') \
181 or value.startswith('enc$aes_hmac$') \
182 or value.startswith('enc2$'):
183 raise ValueError('value needs to be in unencrypted format, '
184 'ie. not starting with enc$ or enc2$')
185
186 algo = rhodecode.CONFIG.get('rhodecode.encrypted_values.algorithm') or 'aes'
187 if algo == 'aes':
188 return 'enc$aes_hmac$%s' % AESCipher(ENCRYPTION_KEY, hmac=True).encrypt(value)
189 elif algo == 'fernet':
190 return Encryptor(ENCRYPTION_KEY).encrypt(value)
191 else:
192 ValueError('Bad encryption algorithm, should be fernet or aes, got: {}'.format(algo))
193
194 def process_result_value(self, value, dialect):
195 """
196 Getter for retrieving value
197 """
198
199 import rhodecode
200 if not value:
201 return value
202
203 algo = rhodecode.CONFIG.get('rhodecode.encrypted_values.algorithm') or 'aes'
204 enc_strict_mode = str2bool(rhodecode.CONFIG.get('rhodecode.encrypted_values.strict') or True)
205 if algo == 'aes':
206 decrypted_data = validate_and_get_enc_data(value, ENCRYPTION_KEY, enc_strict_mode)
207 elif algo == 'fernet':
208 return Encryptor(ENCRYPTION_KEY).decrypt(value)
209 else:
210 ValueError('Bad encryption algorithm, should be fernet or aes, got: {}'.format(algo))
211 return decrypted_data
212
213
214 class BaseModel(object):
215 """
216 Base Model for all classes
217 """
218
219 @classmethod
220 def _get_keys(cls):
221 """return column names for this model """
222 return class_mapper(cls).c.keys()
223
224 def get_dict(self):
225 """
226 return dict with keys and values corresponding
227 to this model data """
228
229 d = {}
230 for k in self._get_keys():
231 d[k] = getattr(self, k)
232
233 # also use __json__() if present to get additional fields
234 _json_attr = getattr(self, '__json__', None)
235 if _json_attr:
236 # update with attributes from __json__
237 if callable(_json_attr):
238 _json_attr = _json_attr()
239 for k, val in _json_attr.iteritems():
240 d[k] = val
241 return d
242
243 def get_appstruct(self):
244 """return list with keys and values tuples corresponding
245 to this model data """
246
247 lst = []
248 for k in self._get_keys():
249 lst.append((k, getattr(self, k),))
250 return lst
251
252 def populate_obj(self, populate_dict):
253 """populate model with data from given populate_dict"""
254
255 for k in self._get_keys():
256 if k in populate_dict:
257 setattr(self, k, populate_dict[k])
258
259 @classmethod
260 def query(cls):
261 return Session().query(cls)
262
263 @classmethod
264 def get(cls, id_):
265 if id_:
266 return cls.query().get(id_)
267
268 @classmethod
269 def get_or_404(cls, id_):
270 from pyramid.httpexceptions import HTTPNotFound
271
272 try:
273 id_ = int(id_)
274 except (TypeError, ValueError):
275 raise HTTPNotFound()
276
277 res = cls.query().get(id_)
278 if not res:
279 raise HTTPNotFound()
280 return res
281
282 @classmethod
283 def getAll(cls):
284 # deprecated and left for backward compatibility
285 return cls.get_all()
286
287 @classmethod
288 def get_all(cls):
289 return cls.query().all()
290
291 @classmethod
292 def delete(cls, id_):
293 obj = cls.query().get(id_)
294 Session().delete(obj)
295
296 @classmethod
297 def identity_cache(cls, session, attr_name, value):
298 exist_in_session = []
299 for (item_cls, pkey), instance in session.identity_map.items():
300 if cls == item_cls and getattr(instance, attr_name) == value:
301 exist_in_session.append(instance)
302 if exist_in_session:
303 if len(exist_in_session) == 1:
304 return exist_in_session[0]
305 log.exception(
306 'multiple objects with attr %s and '
307 'value %s found with same name: %r',
308 attr_name, value, exist_in_session)
309
310 def __repr__(self):
311 if hasattr(self, '__unicode__'):
312 # python repr needs to return str
313 try:
314 return safe_str(self.__unicode__())
315 except UnicodeDecodeError:
316 pass
317 return '<DB:%s>' % (self.__class__.__name__)
318
319
320 class RhodeCodeSetting(Base, BaseModel):
321 __tablename__ = 'rhodecode_settings'
322 __table_args__ = (
323 UniqueConstraint('app_settings_name'),
324 base_table_args
325 )
326
327 SETTINGS_TYPES = {
328 'str': safe_str,
329 'int': safe_int,
330 'unicode': safe_unicode,
331 'bool': str2bool,
332 'list': functools.partial(aslist, sep=',')
333 }
334 DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions'
335 GLOBAL_CONF_KEY = 'app_settings'
336
337 app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
338 app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None)
339 _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None)
340 _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None)
341
342 def __init__(self, key='', val='', type='unicode'):
343 self.app_settings_name = key
344 self.app_settings_type = type
345 self.app_settings_value = val
346
347 @validates('_app_settings_value')
348 def validate_settings_value(self, key, val):
349 assert type(val) == unicode
350 return val
351
352 @hybrid_property
353 def app_settings_value(self):
354 v = self._app_settings_value
355 _type = self.app_settings_type
356 if _type:
357 _type = self.app_settings_type.split('.')[0]
358 # decode the encrypted value
359 if 'encrypted' in self.app_settings_type:
360 cipher = EncryptedTextValue()
361 v = safe_unicode(cipher.process_result_value(v, None))
362
363 converter = self.SETTINGS_TYPES.get(_type) or \
364 self.SETTINGS_TYPES['unicode']
365 return converter(v)
366
367 @app_settings_value.setter
368 def app_settings_value(self, val):
369 """
370 Setter that will always make sure we use unicode in app_settings_value
371
372 :param val:
373 """
374 val = safe_unicode(val)
375 # encode the encrypted value
376 if 'encrypted' in self.app_settings_type:
377 cipher = EncryptedTextValue()
378 val = safe_unicode(cipher.process_bind_param(val, None))
379 self._app_settings_value = val
380
381 @hybrid_property
382 def app_settings_type(self):
383 return self._app_settings_type
384
385 @app_settings_type.setter
386 def app_settings_type(self, val):
387 if val.split('.')[0] not in self.SETTINGS_TYPES:
388 raise Exception('type must be one of %s got %s'
389 % (self.SETTINGS_TYPES.keys(), val))
390 self._app_settings_type = val
391
392 @classmethod
393 def get_by_prefix(cls, prefix):
394 return RhodeCodeSetting.query()\
395 .filter(RhodeCodeSetting.app_settings_name.startswith(prefix))\
396 .all()
397
398 def __unicode__(self):
399 return u"<%s('%s:%s[%s]')>" % (
400 self.__class__.__name__,
401 self.app_settings_name, self.app_settings_value,
402 self.app_settings_type
403 )
404
405
406 class RhodeCodeUi(Base, BaseModel):
407 __tablename__ = 'rhodecode_ui'
408 __table_args__ = (
409 UniqueConstraint('ui_key'),
410 base_table_args
411 )
412
413 HOOK_REPO_SIZE = 'changegroup.repo_size'
414 # HG
415 HOOK_PRE_PULL = 'preoutgoing.pre_pull'
416 HOOK_PULL = 'outgoing.pull_logger'
417 HOOK_PRE_PUSH = 'prechangegroup.pre_push'
418 HOOK_PRETX_PUSH = 'pretxnchangegroup.pre_push'
419 HOOK_PUSH = 'changegroup.push_logger'
420 HOOK_PUSH_KEY = 'pushkey.key_push'
421
422 HOOKS_BUILTIN = [
423 HOOK_PRE_PULL,
424 HOOK_PULL,
425 HOOK_PRE_PUSH,
426 HOOK_PRETX_PUSH,
427 HOOK_PUSH,
428 HOOK_PUSH_KEY,
429 ]
430
431 # TODO: johbo: Unify way how hooks are configured for git and hg,
432 # git part is currently hardcoded.
433
434 # SVN PATTERNS
435 SVN_BRANCH_ID = 'vcs_svn_branch'
436 SVN_TAG_ID = 'vcs_svn_tag'
437
438 ui_id = Column(
439 "ui_id", Integer(), nullable=False, unique=True, default=None,
440 primary_key=True)
441 ui_section = Column(
442 "ui_section", String(255), nullable=True, unique=None, default=None)
443 ui_key = Column(
444 "ui_key", String(255), nullable=True, unique=None, default=None)
445 ui_value = Column(
446 "ui_value", String(255), nullable=True, unique=None, default=None)
447 ui_active = Column(
448 "ui_active", Boolean(), nullable=True, unique=None, default=True)
449
450 def __repr__(self):
451 return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section,
452 self.ui_key, self.ui_value)
453
454
455 class RepoRhodeCodeSetting(Base, BaseModel):
456 __tablename__ = 'repo_rhodecode_settings'
457 __table_args__ = (
458 UniqueConstraint(
459 'app_settings_name', 'repository_id',
460 name='uq_repo_rhodecode_setting_name_repo_id'),
461 base_table_args
462 )
463
464 repository_id = Column(
465 "repository_id", Integer(), ForeignKey('repositories.repo_id'),
466 nullable=False)
467 app_settings_id = Column(
468 "app_settings_id", Integer(), nullable=False, unique=True,
469 default=None, primary_key=True)
470 app_settings_name = Column(
471 "app_settings_name", String(255), nullable=True, unique=None,
472 default=None)
473 _app_settings_value = Column(
474 "app_settings_value", String(4096), nullable=True, unique=None,
475 default=None)
476 _app_settings_type = Column(
477 "app_settings_type", String(255), nullable=True, unique=None,
478 default=None)
479
480 repository = relationship('Repository')
481
482 def __init__(self, repository_id, key='', val='', type='unicode'):
483 self.repository_id = repository_id
484 self.app_settings_name = key
485 self.app_settings_type = type
486 self.app_settings_value = val
487
488 @validates('_app_settings_value')
489 def validate_settings_value(self, key, val):
490 assert type(val) == unicode
491 return val
492
493 @hybrid_property
494 def app_settings_value(self):
495 v = self._app_settings_value
496 type_ = self.app_settings_type
497 SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
498 converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode']
499 return converter(v)
500
501 @app_settings_value.setter
502 def app_settings_value(self, val):
503 """
504 Setter that will always make sure we use unicode in app_settings_value
505
506 :param val:
507 """
508 self._app_settings_value = safe_unicode(val)
509
510 @hybrid_property
511 def app_settings_type(self):
512 return self._app_settings_type
513
514 @app_settings_type.setter
515 def app_settings_type(self, val):
516 SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
517 if val not in SETTINGS_TYPES:
518 raise Exception('type must be one of %s got %s'
519 % (SETTINGS_TYPES.keys(), val))
520 self._app_settings_type = val
521
522 def __unicode__(self):
523 return u"<%s('%s:%s:%s[%s]')>" % (
524 self.__class__.__name__, self.repository.repo_name,
525 self.app_settings_name, self.app_settings_value,
526 self.app_settings_type
527 )
528
529
530 class RepoRhodeCodeUi(Base, BaseModel):
531 __tablename__ = 'repo_rhodecode_ui'
532 __table_args__ = (
533 UniqueConstraint(
534 'repository_id', 'ui_section', 'ui_key',
535 name='uq_repo_rhodecode_ui_repository_id_section_key'),
536 base_table_args
537 )
538
539 repository_id = Column(
540 "repository_id", Integer(), ForeignKey('repositories.repo_id'),
541 nullable=False)
542 ui_id = Column(
543 "ui_id", Integer(), nullable=False, unique=True, default=None,
544 primary_key=True)
545 ui_section = Column(
546 "ui_section", String(255), nullable=True, unique=None, default=None)
547 ui_key = Column(
548 "ui_key", String(255), nullable=True, unique=None, default=None)
549 ui_value = Column(
550 "ui_value", String(255), nullable=True, unique=None, default=None)
551 ui_active = Column(
552 "ui_active", Boolean(), nullable=True, unique=None, default=True)
553
554 repository = relationship('Repository')
555
556 def __repr__(self):
557 return '<%s[%s:%s]%s=>%s]>' % (
558 self.__class__.__name__, self.repository.repo_name,
559 self.ui_section, self.ui_key, self.ui_value)
560
561
562 class User(Base, BaseModel):
563 __tablename__ = 'users'
564 __table_args__ = (
565 UniqueConstraint('username'), UniqueConstraint('email'),
566 Index('u_username_idx', 'username'),
567 Index('u_email_idx', 'email'),
568 base_table_args
569 )
570
571 DEFAULT_USER = 'default'
572 DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org'
573 DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}'
574
575 user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
576 username = Column("username", String(255), nullable=True, unique=None, default=None)
577 password = Column("password", String(255), nullable=True, unique=None, default=None)
578 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
579 admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)
580 name = Column("firstname", String(255), nullable=True, unique=None, default=None)
581 lastname = Column("lastname", String(255), nullable=True, unique=None, default=None)
582 _email = Column("email", String(255), nullable=True, unique=None, default=None)
583 last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)
584 last_activity = Column('last_activity', DateTime(timezone=False), nullable=True, unique=None, default=None)
585 description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
586
587 extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None)
588 extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None)
589 _api_key = Column("api_key", String(255), nullable=True, unique=None, default=None)
590 inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
591 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
592 _user_data = Column("user_data", LargeBinary(), nullable=True) # JSON data
593
594 user_log = relationship('UserLog')
595 user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all, delete-orphan')
596
597 repositories = relationship('Repository')
598 repository_groups = relationship('RepoGroup')
599 user_groups = relationship('UserGroup')
600
601 user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')
602 followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all')
603
604 repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all, delete-orphan')
605 repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all, delete-orphan')
606 user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all, delete-orphan')
607
608 group_member = relationship('UserGroupMember', cascade='all')
609
610 notifications = relationship('UserNotification', cascade='all')
611 # notifications assigned to this user
612 user_created_notifications = relationship('Notification', cascade='all')
613 # comments created by this user
614 user_comments = relationship('ChangesetComment', cascade='all')
615 # user profile extra info
616 user_emails = relationship('UserEmailMap', cascade='all')
617 user_ip_map = relationship('UserIpMap', cascade='all')
618 user_auth_tokens = relationship('UserApiKeys', cascade='all')
619 user_ssh_keys = relationship('UserSshKeys', cascade='all')
620
621 # gists
622 user_gists = relationship('Gist', cascade='all')
623 # user pull requests
624 user_pull_requests = relationship('PullRequest', cascade='all')
625
626 # external identities
627 external_identities = relationship(
628 'ExternalIdentity',
629 primaryjoin="User.user_id==ExternalIdentity.local_user_id",
630 cascade='all')
631 # review rules
632 user_review_rules = relationship('RepoReviewRuleUser', cascade='all')
633
634 # artifacts owned
635 artifacts = relationship('FileStore', primaryjoin='FileStore.user_id==User.user_id')
636
637 # no cascade, set NULL
638 scope_artifacts = relationship('FileStore', primaryjoin='FileStore.scope_user_id==User.user_id')
639
640 def __unicode__(self):
641 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
642 self.user_id, self.username)
643
644 @hybrid_property
645 def email(self):
646 return self._email
647
648 @email.setter
649 def email(self, val):
650 self._email = val.lower() if val else None
651
652 @hybrid_property
653 def first_name(self):
654 from rhodecode.lib import helpers as h
655 if self.name:
656 return h.escape(self.name)
657 return self.name
658
659 @hybrid_property
660 def last_name(self):
661 from rhodecode.lib import helpers as h
662 if self.lastname:
663 return h.escape(self.lastname)
664 return self.lastname
665
666 @hybrid_property
667 def api_key(self):
668 """
669 Fetch if exist an auth-token with role ALL connected to this user
670 """
671 user_auth_token = UserApiKeys.query()\
672 .filter(UserApiKeys.user_id == self.user_id)\
673 .filter(or_(UserApiKeys.expires == -1,
674 UserApiKeys.expires >= time.time()))\
675 .filter(UserApiKeys.role == UserApiKeys.ROLE_ALL).first()
676 if user_auth_token:
677 user_auth_token = user_auth_token.api_key
678
679 return user_auth_token
680
681 @api_key.setter
682 def api_key(self, val):
683 # don't allow to set API key this is deprecated for now
684 self._api_key = None
685
686 @property
687 def reviewer_pull_requests(self):
688 return PullRequestReviewers.query() \
689 .options(joinedload(PullRequestReviewers.pull_request)) \
690 .filter(PullRequestReviewers.user_id == self.user_id) \
691 .all()
692
693 @property
694 def firstname(self):
695 # alias for future
696 return self.name
697
698 @property
699 def emails(self):
700 other = UserEmailMap.query()\
701 .filter(UserEmailMap.user == self) \
702 .order_by(UserEmailMap.email_id.asc()) \
703 .all()
704 return [self.email] + [x.email for x in other]
705
706 def emails_cached(self):
707 emails = UserEmailMap.query()\
708 .filter(UserEmailMap.user == self) \
709 .order_by(UserEmailMap.email_id.asc())
710
711 emails = emails.options(
712 FromCache("sql_cache_short", "get_user_{}_emails".format(self.user_id))
713 )
714
715 return [self.email] + [x.email for x in emails]
716
717 @property
718 def auth_tokens(self):
719 auth_tokens = self.get_auth_tokens()
720 return [x.api_key for x in auth_tokens]
721
722 def get_auth_tokens(self):
723 return UserApiKeys.query()\
724 .filter(UserApiKeys.user == self)\
725 .order_by(UserApiKeys.user_api_key_id.asc())\
726 .all()
727
728 @LazyProperty
729 def feed_token(self):
730 return self.get_feed_token()
731
732 def get_feed_token(self, cache=True):
733 feed_tokens = UserApiKeys.query()\
734 .filter(UserApiKeys.user == self)\
735 .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED)
736 if cache:
737 feed_tokens = feed_tokens.options(
738 FromCache("sql_cache_short", "get_user_feed_token_%s" % self.user_id))
739
740 feed_tokens = feed_tokens.all()
741 if feed_tokens:
742 return feed_tokens[0].api_key
743 return 'NO_FEED_TOKEN_AVAILABLE'
744
745 @LazyProperty
746 def artifact_token(self):
747 return self.get_artifact_token()
748
749 def get_artifact_token(self, cache=True):
750 artifacts_tokens = UserApiKeys.query()\
751 .filter(UserApiKeys.user == self)\
752 .filter(UserApiKeys.role == UserApiKeys.ROLE_ARTIFACT_DOWNLOAD)
753 if cache:
754 artifacts_tokens = artifacts_tokens.options(
755 FromCache("sql_cache_short", "get_user_artifact_token_%s" % self.user_id))
756
757 artifacts_tokens = artifacts_tokens.all()
758 if artifacts_tokens:
759 return artifacts_tokens[0].api_key
760 return 'NO_ARTIFACT_TOKEN_AVAILABLE'
761
762 @classmethod
763 def get(cls, user_id, cache=False):
764 if not user_id:
765 return
766
767 user = cls.query()
768 if cache:
769 user = user.options(
770 FromCache("sql_cache_short", "get_users_%s" % user_id))
771 return user.get(user_id)
772
773 @classmethod
774 def extra_valid_auth_tokens(cls, user, role=None):
775 tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\
776 .filter(or_(UserApiKeys.expires == -1,
777 UserApiKeys.expires >= time.time()))
778 if role:
779 tokens = tokens.filter(or_(UserApiKeys.role == role,
780 UserApiKeys.role == UserApiKeys.ROLE_ALL))
781 return tokens.all()
782
783 def authenticate_by_token(self, auth_token, roles=None, scope_repo_id=None):
784 from rhodecode.lib import auth
785
786 log.debug('Trying to authenticate user: %s via auth-token, '
787 'and roles: %s', self, roles)
788
789 if not auth_token:
790 return False
791
792 roles = (roles or []) + [UserApiKeys.ROLE_ALL]
793 tokens_q = UserApiKeys.query()\
794 .filter(UserApiKeys.user_id == self.user_id)\
795 .filter(or_(UserApiKeys.expires == -1,
796 UserApiKeys.expires >= time.time()))
797
798 tokens_q = tokens_q.filter(UserApiKeys.role.in_(roles))
799
800 crypto_backend = auth.crypto_backend()
801 enc_token_map = {}
802 plain_token_map = {}
803 for token in tokens_q:
804 if token.api_key.startswith(crypto_backend.ENC_PREF):
805 enc_token_map[token.api_key] = token
806 else:
807 plain_token_map[token.api_key] = token
808 log.debug(
809 'Found %s plain and %s encrypted tokens to check for authentication for this user',
810 len(plain_token_map), len(enc_token_map))
811
812 # plain token match comes first
813 match = plain_token_map.get(auth_token)
814
815 # check encrypted tokens now
816 if not match:
817 for token_hash, token in enc_token_map.items():
818 # NOTE(marcink): this is expensive to calculate, but most secure
819 if crypto_backend.hash_check(auth_token, token_hash):
820 match = token
821 break
822
823 if match:
824 log.debug('Found matching token %s', match)
825 if match.repo_id:
826 log.debug('Found scope, checking for scope match of token %s', match)
827 if match.repo_id == scope_repo_id:
828 return True
829 else:
830 log.debug(
831 'AUTH_TOKEN: scope mismatch, token has a set repo scope: %s, '
832 'and calling scope is:%s, skipping further checks',
833 match.repo, scope_repo_id)
834 return False
835 else:
836 return True
837
838 return False
839
840 @property
841 def ip_addresses(self):
842 ret = UserIpMap.query().filter(UserIpMap.user == self).all()
843 return [x.ip_addr for x in ret]
844
845 @property
846 def username_and_name(self):
847 return '%s (%s %s)' % (self.username, self.first_name, self.last_name)
848
849 @property
850 def username_or_name_or_email(self):
851 full_name = self.full_name if self.full_name is not ' ' else None
852 return self.username or full_name or self.email
853
854 @property
855 def full_name(self):
856 return '%s %s' % (self.first_name, self.last_name)
857
858 @property
859 def full_name_or_username(self):
860 return ('%s %s' % (self.first_name, self.last_name)
861 if (self.first_name and self.last_name) else self.username)
862
863 @property
864 def full_contact(self):
865 return '%s %s <%s>' % (self.first_name, self.last_name, self.email)
866
867 @property
868 def short_contact(self):
869 return '%s %s' % (self.first_name, self.last_name)
870
871 @property
872 def is_admin(self):
873 return self.admin
874
875 @property
876 def language(self):
877 return self.user_data.get('language')
878
879 def AuthUser(self, **kwargs):
880 """
881 Returns instance of AuthUser for this user
882 """
883 from rhodecode.lib.auth import AuthUser
884 return AuthUser(user_id=self.user_id, username=self.username, **kwargs)
885
886 @hybrid_property
887 def user_data(self):
888 if not self._user_data:
889 return {}
890
891 try:
892 return json.loads(self._user_data)
893 except TypeError:
894 return {}
895
896 @user_data.setter
897 def user_data(self, val):
898 if not isinstance(val, dict):
899 raise Exception('user_data must be dict, got %s' % type(val))
900 try:
901 self._user_data = json.dumps(val)
902 except Exception:
903 log.error(traceback.format_exc())
904
905 @classmethod
906 def get_by_username(cls, username, case_insensitive=False,
907 cache=False, identity_cache=False):
908 session = Session()
909
910 if case_insensitive:
911 q = cls.query().filter(
912 func.lower(cls.username) == func.lower(username))
913 else:
914 q = cls.query().filter(cls.username == username)
915
916 if cache:
917 if identity_cache:
918 val = cls.identity_cache(session, 'username', username)
919 if val:
920 return val
921 else:
922 cache_key = "get_user_by_name_%s" % _hash_key(username)
923 q = q.options(
924 FromCache("sql_cache_short", cache_key))
925
926 return q.scalar()
927
928 @classmethod
929 def get_by_auth_token(cls, auth_token, cache=False):
930 q = UserApiKeys.query()\
931 .filter(UserApiKeys.api_key == auth_token)\
932 .filter(or_(UserApiKeys.expires == -1,
933 UserApiKeys.expires >= time.time()))
934 if cache:
935 q = q.options(
936 FromCache("sql_cache_short", "get_auth_token_%s" % auth_token))
937
938 match = q.first()
939 if match:
940 return match.user
941
942 @classmethod
943 def get_by_email(cls, email, case_insensitive=False, cache=False):
944
945 if case_insensitive:
946 q = cls.query().filter(func.lower(cls.email) == func.lower(email))
947
948 else:
949 q = cls.query().filter(cls.email == email)
950
951 email_key = _hash_key(email)
952 if cache:
953 q = q.options(
954 FromCache("sql_cache_short", "get_email_key_%s" % email_key))
955
956 ret = q.scalar()
957 if ret is None:
958 q = UserEmailMap.query()
959 # try fetching in alternate email map
960 if case_insensitive:
961 q = q.filter(func.lower(UserEmailMap.email) == func.lower(email))
962 else:
963 q = q.filter(UserEmailMap.email == email)
964 q = q.options(joinedload(UserEmailMap.user))
965 if cache:
966 q = q.options(
967 FromCache("sql_cache_short", "get_email_map_key_%s" % email_key))
968 ret = getattr(q.scalar(), 'user', None)
969
970 return ret
971
972 @classmethod
973 def get_from_cs_author(cls, author):
974 """
975 Tries to get User objects out of commit author string
976
977 :param author:
978 """
979 from rhodecode.lib.helpers import email, author_name
980 # Valid email in the attribute passed, see if they're in the system
981 _email = email(author)
982 if _email:
983 user = cls.get_by_email(_email, case_insensitive=True)
984 if user:
985 return user
986 # Maybe we can match by username?
987 _author = author_name(author)
988 user = cls.get_by_username(_author, case_insensitive=True)
989 if user:
990 return user
991
992 def update_userdata(self, **kwargs):
993 usr = self
994 old = usr.user_data
995 old.update(**kwargs)
996 usr.user_data = old
997 Session().add(usr)
998 log.debug('updated userdata with %s', kwargs)
999
1000 def update_lastlogin(self):
1001 """Update user lastlogin"""
1002 self.last_login = datetime.datetime.now()
1003 Session().add(self)
1004 log.debug('updated user %s lastlogin', self.username)
1005
1006 def update_password(self, new_password):
1007 from rhodecode.lib.auth import get_crypt_password
1008
1009 self.password = get_crypt_password(new_password)
1010 Session().add(self)
1011
1012 @classmethod
1013 def get_first_super_admin(cls):
1014 user = User.query()\
1015 .filter(User.admin == true()) \
1016 .order_by(User.user_id.asc()) \
1017 .first()
1018
1019 if user is None:
1020 raise Exception('FATAL: Missing administrative account!')
1021 return user
1022
1023 @classmethod
1024 def get_all_super_admins(cls, only_active=False):
1025 """
1026 Returns all admin accounts sorted by username
1027 """
1028 qry = User.query().filter(User.admin == true()).order_by(User.username.asc())
1029 if only_active:
1030 qry = qry.filter(User.active == true())
1031 return qry.all()
1032
1033 @classmethod
1034 def get_all_user_ids(cls, only_active=True):
1035 """
1036 Returns all users IDs
1037 """
1038 qry = Session().query(User.user_id)
1039
1040 if only_active:
1041 qry = qry.filter(User.active == true())
1042 return [x.user_id for x in qry]
1043
1044 @classmethod
1045 def get_default_user(cls, cache=False, refresh=False):
1046 user = User.get_by_username(User.DEFAULT_USER, cache=cache)
1047 if user is None:
1048 raise Exception('FATAL: Missing default account!')
1049 if refresh:
1050 # The default user might be based on outdated state which
1051 # has been loaded from the cache.
1052 # A call to refresh() ensures that the
1053 # latest state from the database is used.
1054 Session().refresh(user)
1055 return user
1056
1057 @classmethod
1058 def get_default_user_id(cls):
1059 import rhodecode
1060 return rhodecode.CONFIG['default_user_id']
1061
1062 def _get_default_perms(self, user, suffix=''):
1063 from rhodecode.model.permission import PermissionModel
1064 return PermissionModel().get_default_perms(user.user_perms, suffix)
1065
1066 def get_default_perms(self, suffix=''):
1067 return self._get_default_perms(self, suffix)
1068
1069 def get_api_data(self, include_secrets=False, details='full'):
1070 """
1071 Common function for generating user related data for API
1072
1073 :param include_secrets: By default secrets in the API data will be replaced
1074 by a placeholder value to prevent exposing this data by accident. In case
1075 this data shall be exposed, set this flag to ``True``.
1076
1077 :param details: details can be 'basic|full' basic gives only a subset of
1078 the available user information that includes user_id, name and emails.
1079 """
1080 user = self
1081 user_data = self.user_data
1082 data = {
1083 'user_id': user.user_id,
1084 'username': user.username,
1085 'firstname': user.name,
1086 'lastname': user.lastname,
1087 'description': user.description,
1088 'email': user.email,
1089 'emails': user.emails,
1090 }
1091 if details == 'basic':
1092 return data
1093
1094 auth_token_length = 40
1095 auth_token_replacement = '*' * auth_token_length
1096
1097 extras = {
1098 'auth_tokens': [auth_token_replacement],
1099 'active': user.active,
1100 'admin': user.admin,
1101 'extern_type': user.extern_type,
1102 'extern_name': user.extern_name,
1103 'last_login': user.last_login,
1104 'last_activity': user.last_activity,
1105 'ip_addresses': user.ip_addresses,
1106 'language': user_data.get('language')
1107 }
1108 data.update(extras)
1109
1110 if include_secrets:
1111 data['auth_tokens'] = user.auth_tokens
1112 return data
1113
1114 def __json__(self):
1115 data = {
1116 'full_name': self.full_name,
1117 'full_name_or_username': self.full_name_or_username,
1118 'short_contact': self.short_contact,
1119 'full_contact': self.full_contact,
1120 }
1121 data.update(self.get_api_data())
1122 return data
1123
1124
1125 class UserApiKeys(Base, BaseModel):
1126 __tablename__ = 'user_api_keys'
1127 __table_args__ = (
1128 Index('uak_api_key_idx', 'api_key'),
1129 Index('uak_api_key_expires_idx', 'api_key', 'expires'),
1130 base_table_args
1131 )
1132 __mapper_args__ = {}
1133
1134 # ApiKey role
1135 ROLE_ALL = 'token_role_all'
1136 ROLE_VCS = 'token_role_vcs'
1137 ROLE_API = 'token_role_api'
1138 ROLE_HTTP = 'token_role_http'
1139 ROLE_FEED = 'token_role_feed'
1140 ROLE_ARTIFACT_DOWNLOAD = 'role_artifact_download'
1141 # The last one is ignored in the list as we only
1142 # use it for one action, and cannot be created by users
1143 ROLE_PASSWORD_RESET = 'token_password_reset'
1144
1145 ROLES = [ROLE_ALL, ROLE_VCS, ROLE_API, ROLE_HTTP, ROLE_FEED, ROLE_ARTIFACT_DOWNLOAD]
1146
1147 user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1148 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1149 api_key = Column("api_key", String(255), nullable=False, unique=True)
1150 description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
1151 expires = Column('expires', Float(53), nullable=False)
1152 role = Column('role', String(255), nullable=True)
1153 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1154
1155 # scope columns
1156 repo_id = Column(
1157 'repo_id', Integer(), ForeignKey('repositories.repo_id'),
1158 nullable=True, unique=None, default=None)
1159 repo = relationship('Repository', lazy='joined')
1160
1161 repo_group_id = Column(
1162 'repo_group_id', Integer(), ForeignKey('groups.group_id'),
1163 nullable=True, unique=None, default=None)
1164 repo_group = relationship('RepoGroup', lazy='joined')
1165
1166 user = relationship('User', lazy='joined')
1167
1168 def __unicode__(self):
1169 return u"<%s('%s')>" % (self.__class__.__name__, self.role)
1170
1171 def __json__(self):
1172 data = {
1173 'auth_token': self.api_key,
1174 'role': self.role,
1175 'scope': self.scope_humanized,
1176 'expired': self.expired
1177 }
1178 return data
1179
1180 def get_api_data(self, include_secrets=False):
1181 data = self.__json__()
1182 if include_secrets:
1183 return data
1184 else:
1185 data['auth_token'] = self.token_obfuscated
1186 return data
1187
1188 @hybrid_property
1189 def description_safe(self):
1190 from rhodecode.lib import helpers as h
1191 return h.escape(self.description)
1192
1193 @property
1194 def expired(self):
1195 if self.expires == -1:
1196 return False
1197 return time.time() > self.expires
1198
1199 @classmethod
1200 def _get_role_name(cls, role):
1201 return {
1202 cls.ROLE_ALL: _('all'),
1203 cls.ROLE_HTTP: _('http/web interface'),
1204 cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'),
1205 cls.ROLE_API: _('api calls'),
1206 cls.ROLE_FEED: _('feed access'),
1207 cls.ROLE_ARTIFACT_DOWNLOAD: _('artifacts downloads'),
1208 }.get(role, role)
1209
1210 @classmethod
1211 def _get_role_description(cls, role):
1212 return {
1213 cls.ROLE_ALL: _('Token for all actions.'),
1214 cls.ROLE_HTTP: _('Token to access RhodeCode pages via web interface without '
1215 'login using `api_access_controllers_whitelist` functionality.'),
1216 cls.ROLE_VCS: _('Token to interact over git/hg/svn protocols. '
1217 'Requires auth_token authentication plugin to be active. <br/>'
1218 'Such Token should be used then instead of a password to '
1219 'interact with a repository, and additionally can be '
1220 'limited to single repository using repo scope.'),
1221 cls.ROLE_API: _('Token limited to api calls.'),
1222 cls.ROLE_FEED: _('Token to read RSS/ATOM feed.'),
1223 cls.ROLE_ARTIFACT_DOWNLOAD: _('Token for artifacts downloads.'),
1224 }.get(role, role)
1225
1226 @property
1227 def role_humanized(self):
1228 return self._get_role_name(self.role)
1229
1230 def _get_scope(self):
1231 if self.repo:
1232 return 'Repository: {}'.format(self.repo.repo_name)
1233 if self.repo_group:
1234 return 'RepositoryGroup: {} (recursive)'.format(self.repo_group.group_name)
1235 return 'Global'
1236
1237 @property
1238 def scope_humanized(self):
1239 return self._get_scope()
1240
1241 @property
1242 def token_obfuscated(self):
1243 if self.api_key:
1244 return self.api_key[:4] + "****"
1245
1246
1247 class UserEmailMap(Base, BaseModel):
1248 __tablename__ = 'user_email_map'
1249 __table_args__ = (
1250 Index('uem_email_idx', 'email'),
1251 UniqueConstraint('email'),
1252 base_table_args
1253 )
1254 __mapper_args__ = {}
1255
1256 email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1257 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1258 _email = Column("email", String(255), nullable=True, unique=False, default=None)
1259 user = relationship('User', lazy='joined')
1260
1261 @validates('_email')
1262 def validate_email(self, key, email):
1263 # check if this email is not main one
1264 main_email = Session().query(User).filter(User.email == email).scalar()
1265 if main_email is not None:
1266 raise AttributeError('email %s is present is user table' % email)
1267 return email
1268
1269 @hybrid_property
1270 def email(self):
1271 return self._email
1272
1273 @email.setter
1274 def email(self, val):
1275 self._email = val.lower() if val else None
1276
1277
1278 class UserIpMap(Base, BaseModel):
1279 __tablename__ = 'user_ip_map'
1280 __table_args__ = (
1281 UniqueConstraint('user_id', 'ip_addr'),
1282 base_table_args
1283 )
1284 __mapper_args__ = {}
1285
1286 ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1287 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1288 ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None)
1289 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
1290 description = Column("description", String(10000), nullable=True, unique=None, default=None)
1291 user = relationship('User', lazy='joined')
1292
1293 @hybrid_property
1294 def description_safe(self):
1295 from rhodecode.lib import helpers as h
1296 return h.escape(self.description)
1297
1298 @classmethod
1299 def _get_ip_range(cls, ip_addr):
1300 net = ipaddress.ip_network(safe_unicode(ip_addr), strict=False)
1301 return [str(net.network_address), str(net.broadcast_address)]
1302
1303 def __json__(self):
1304 return {
1305 'ip_addr': self.ip_addr,
1306 'ip_range': self._get_ip_range(self.ip_addr),
1307 }
1308
1309 def __unicode__(self):
1310 return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,
1311 self.user_id, self.ip_addr)
1312
1313
1314 class UserSshKeys(Base, BaseModel):
1315 __tablename__ = 'user_ssh_keys'
1316 __table_args__ = (
1317 Index('usk_ssh_key_fingerprint_idx', 'ssh_key_fingerprint'),
1318
1319 UniqueConstraint('ssh_key_fingerprint'),
1320
1321 base_table_args
1322 )
1323 __mapper_args__ = {}
1324
1325 ssh_key_id = Column('ssh_key_id', Integer(), nullable=False, unique=True, default=None, primary_key=True)
1326 ssh_key_data = Column('ssh_key_data', String(10240), nullable=False, unique=None, default=None)
1327 ssh_key_fingerprint = Column('ssh_key_fingerprint', String(255), nullable=False, unique=None, default=None)
1328
1329 description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
1330
1331 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1332 accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True, default=None)
1333 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1334
1335 user = relationship('User', lazy='joined')
1336
1337 def __json__(self):
1338 data = {
1339 'ssh_fingerprint': self.ssh_key_fingerprint,
1340 'description': self.description,
1341 'created_on': self.created_on
1342 }
1343 return data
1344
1345 def get_api_data(self):
1346 data = self.__json__()
1347 return data
1348
1349
1350 class UserLog(Base, BaseModel):
1351 __tablename__ = 'user_logs'
1352 __table_args__ = (
1353 base_table_args,
1354 )
1355
1356 VERSION_1 = 'v1'
1357 VERSION_2 = 'v2'
1358 VERSIONS = [VERSION_1, VERSION_2]
1359
1360 user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1361 user_id = Column("user_id", Integer(), ForeignKey('users.user_id',ondelete='SET NULL'), nullable=True, unique=None, default=None)
1362 username = Column("username", String(255), nullable=True, unique=None, default=None)
1363 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id', ondelete='SET NULL'), nullable=True, unique=None, default=None)
1364 repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None)
1365 user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None)
1366 action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None)
1367 action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)
1368
1369 version = Column("version", String(255), nullable=True, default=VERSION_1)
1370 user_data = Column('user_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))
1371 action_data = Column('action_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))
1372
1373 def __unicode__(self):
1374 return u"<%s('id:%s:%s')>" % (
1375 self.__class__.__name__, self.repository_name, self.action)
1376
1377 def __json__(self):
1378 return {
1379 'user_id': self.user_id,
1380 'username': self.username,
1381 'repository_id': self.repository_id,
1382 'repository_name': self.repository_name,
1383 'user_ip': self.user_ip,
1384 'action_date': self.action_date,
1385 'action': self.action,
1386 }
1387
1388 @hybrid_property
1389 def entry_id(self):
1390 return self.user_log_id
1391
1392 @property
1393 def action_as_day(self):
1394 return datetime.date(*self.action_date.timetuple()[:3])
1395
1396 user = relationship('User')
1397 repository = relationship('Repository', cascade='')
1398
1399
1400 class UserGroup(Base, BaseModel):
1401 __tablename__ = 'users_groups'
1402 __table_args__ = (
1403 base_table_args,
1404 )
1405
1406 users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1407 users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None)
1408 user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None)
1409 users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
1410 inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
1411 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
1412 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1413 _group_data = Column("group_data", LargeBinary(), nullable=True) # JSON data
1414
1415 members = relationship('UserGroupMember', cascade="all, delete-orphan", lazy="joined")
1416 users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
1417 users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
1418 users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
1419 user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all')
1420 user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all')
1421
1422 user_group_review_rules = relationship('RepoReviewRuleUserGroup', cascade='all')
1423 user = relationship('User', primaryjoin="User.user_id==UserGroup.user_id")
1424
1425 @classmethod
1426 def _load_group_data(cls, column):
1427 if not column:
1428 return {}
1429
1430 try:
1431 return json.loads(column) or {}
1432 except TypeError:
1433 return {}
1434
1435 @hybrid_property
1436 def description_safe(self):
1437 from rhodecode.lib import helpers as h
1438 return h.escape(self.user_group_description)
1439
1440 @hybrid_property
1441 def group_data(self):
1442 return self._load_group_data(self._group_data)
1443
1444 @group_data.expression
1445 def group_data(self, **kwargs):
1446 return self._group_data
1447
1448 @group_data.setter
1449 def group_data(self, val):
1450 try:
1451 self._group_data = json.dumps(val)
1452 except Exception:
1453 log.error(traceback.format_exc())
1454
1455 @classmethod
1456 def _load_sync(cls, group_data):
1457 if group_data:
1458 return group_data.get('extern_type')
1459
1460 @property
1461 def sync(self):
1462 return self._load_sync(self.group_data)
1463
1464 def __unicode__(self):
1465 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
1466 self.users_group_id,
1467 self.users_group_name)
1468
1469 @classmethod
1470 def get_by_group_name(cls, group_name, cache=False,
1471 case_insensitive=False):
1472 if case_insensitive:
1473 q = cls.query().filter(func.lower(cls.users_group_name) ==
1474 func.lower(group_name))
1475
1476 else:
1477 q = cls.query().filter(cls.users_group_name == group_name)
1478 if cache:
1479 q = q.options(
1480 FromCache("sql_cache_short", "get_group_%s" % _hash_key(group_name)))
1481 return q.scalar()
1482
1483 @classmethod
1484 def get(cls, user_group_id, cache=False):
1485 if not user_group_id:
1486 return
1487
1488 user_group = cls.query()
1489 if cache:
1490 user_group = user_group.options(
1491 FromCache("sql_cache_short", "get_users_group_%s" % user_group_id))
1492 return user_group.get(user_group_id)
1493
1494 def permissions(self, with_admins=True, with_owner=True,
1495 expand_from_user_groups=False):
1496 """
1497 Permissions for user groups
1498 """
1499 _admin_perm = 'usergroup.admin'
1500
1501 owner_row = []
1502 if with_owner:
1503 usr = AttributeDict(self.user.get_dict())
1504 usr.owner_row = True
1505 usr.permission = _admin_perm
1506 owner_row.append(usr)
1507
1508 super_admin_ids = []
1509 super_admin_rows = []
1510 if with_admins:
1511 for usr in User.get_all_super_admins():
1512 super_admin_ids.append(usr.user_id)
1513 # if this admin is also owner, don't double the record
1514 if usr.user_id == owner_row[0].user_id:
1515 owner_row[0].admin_row = True
1516 else:
1517 usr = AttributeDict(usr.get_dict())
1518 usr.admin_row = True
1519 usr.permission = _admin_perm
1520 super_admin_rows.append(usr)
1521
1522 q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self)
1523 q = q.options(joinedload(UserUserGroupToPerm.user_group),
1524 joinedload(UserUserGroupToPerm.user),
1525 joinedload(UserUserGroupToPerm.permission),)
1526
1527 # get owners and admins and permissions. We do a trick of re-writing
1528 # objects from sqlalchemy to named-tuples due to sqlalchemy session
1529 # has a global reference and changing one object propagates to all
1530 # others. This means if admin is also an owner admin_row that change
1531 # would propagate to both objects
1532 perm_rows = []
1533 for _usr in q.all():
1534 usr = AttributeDict(_usr.user.get_dict())
1535 # if this user is also owner/admin, mark as duplicate record
1536 if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids:
1537 usr.duplicate_perm = True
1538 usr.permission = _usr.permission.permission_name
1539 perm_rows.append(usr)
1540
1541 # filter the perm rows by 'default' first and then sort them by
1542 # admin,write,read,none permissions sorted again alphabetically in
1543 # each group
1544 perm_rows = sorted(perm_rows, key=display_user_sort)
1545
1546 user_groups_rows = []
1547 if expand_from_user_groups:
1548 for ug in self.permission_user_groups(with_members=True):
1549 for user_data in ug.members:
1550 user_groups_rows.append(user_data)
1551
1552 return super_admin_rows + owner_row + perm_rows + user_groups_rows
1553
1554 def permission_user_groups(self, with_members=False):
1555 q = UserGroupUserGroupToPerm.query()\
1556 .filter(UserGroupUserGroupToPerm.target_user_group == self)
1557 q = q.options(joinedload(UserGroupUserGroupToPerm.user_group),
1558 joinedload(UserGroupUserGroupToPerm.target_user_group),
1559 joinedload(UserGroupUserGroupToPerm.permission),)
1560
1561 perm_rows = []
1562 for _user_group in q.all():
1563 entry = AttributeDict(_user_group.user_group.get_dict())
1564 entry.permission = _user_group.permission.permission_name
1565 if with_members:
1566 entry.members = [x.user.get_dict()
1567 for x in _user_group.user_group.members]
1568 perm_rows.append(entry)
1569
1570 perm_rows = sorted(perm_rows, key=display_user_group_sort)
1571 return perm_rows
1572
1573 def _get_default_perms(self, user_group, suffix=''):
1574 from rhodecode.model.permission import PermissionModel
1575 return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix)
1576
1577 def get_default_perms(self, suffix=''):
1578 return self._get_default_perms(self, suffix)
1579
1580 def get_api_data(self, with_group_members=True, include_secrets=False):
1581 """
1582 :param include_secrets: See :meth:`User.get_api_data`, this parameter is
1583 basically forwarded.
1584
1585 """
1586 user_group = self
1587 data = {
1588 'users_group_id': user_group.users_group_id,
1589 'group_name': user_group.users_group_name,
1590 'group_description': user_group.user_group_description,
1591 'active': user_group.users_group_active,
1592 'owner': user_group.user.username,
1593 'sync': user_group.sync,
1594 'owner_email': user_group.user.email,
1595 }
1596
1597 if with_group_members:
1598 users = []
1599 for user in user_group.members:
1600 user = user.user
1601 users.append(user.get_api_data(include_secrets=include_secrets))
1602 data['users'] = users
1603
1604 return data
1605
1606
1607 class UserGroupMember(Base, BaseModel):
1608 __tablename__ = 'users_groups_members'
1609 __table_args__ = (
1610 base_table_args,
1611 )
1612
1613 users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1614 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
1615 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
1616
1617 user = relationship('User', lazy='joined')
1618 users_group = relationship('UserGroup')
1619
1620 def __init__(self, gr_id='', u_id=''):
1621 self.users_group_id = gr_id
1622 self.user_id = u_id
1623
1624
1625 class RepositoryField(Base, BaseModel):
1626 __tablename__ = 'repositories_fields'
1627 __table_args__ = (
1628 UniqueConstraint('repository_id', 'field_key'), # no-multi field
1629 base_table_args,
1630 )
1631
1632 PREFIX = 'ex_' # prefix used in form to not conflict with already existing fields
1633
1634 repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1635 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
1636 field_key = Column("field_key", String(250))
1637 field_label = Column("field_label", String(1024), nullable=False)
1638 field_value = Column("field_value", String(10000), nullable=False)
1639 field_desc = Column("field_desc", String(1024), nullable=False)
1640 field_type = Column("field_type", String(255), nullable=False, unique=None)
1641 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1642
1643 repository = relationship('Repository')
1644
1645 @property
1646 def field_key_prefixed(self):
1647 return 'ex_%s' % self.field_key
1648
1649 @classmethod
1650 def un_prefix_key(cls, key):
1651 if key.startswith(cls.PREFIX):
1652 return key[len(cls.PREFIX):]
1653 return key
1654
1655 @classmethod
1656 def get_by_key_name(cls, key, repo):
1657 row = cls.query()\
1658 .filter(cls.repository == repo)\
1659 .filter(cls.field_key == key).scalar()
1660 return row
1661
1662
1663 class Repository(Base, BaseModel):
1664 __tablename__ = 'repositories'
1665 __table_args__ = (
1666 Index('r_repo_name_idx', 'repo_name', mysql_length=255),
1667 base_table_args,
1668 )
1669 DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'
1670 DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'
1671 DEFAULT_CLONE_URI_SSH = 'ssh://{sys_user}@{hostname}/{repo}'
1672
1673 STATE_CREATED = 'repo_state_created'
1674 STATE_PENDING = 'repo_state_pending'
1675 STATE_ERROR = 'repo_state_error'
1676
1677 LOCK_AUTOMATIC = 'lock_auto'
1678 LOCK_API = 'lock_api'
1679 LOCK_WEB = 'lock_web'
1680 LOCK_PULL = 'lock_pull'
1681
1682 NAME_SEP = URL_SEP
1683
1684 repo_id = Column(
1685 "repo_id", Integer(), nullable=False, unique=True, default=None,
1686 primary_key=True)
1687 _repo_name = Column(
1688 "repo_name", Text(), nullable=False, default=None)
1689 repo_name_hash = Column(
1690 "repo_name_hash", String(255), nullable=False, unique=True)
1691 repo_state = Column("repo_state", String(255), nullable=True)
1692
1693 clone_uri = Column(
1694 "clone_uri", EncryptedTextValue(), nullable=True, unique=False,
1695 default=None)
1696 push_uri = Column(
1697 "push_uri", EncryptedTextValue(), nullable=True, unique=False,
1698 default=None)
1699 repo_type = Column(
1700 "repo_type", String(255), nullable=False, unique=False, default=None)
1701 user_id = Column(
1702 "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
1703 unique=False, default=None)
1704 private = Column(
1705 "private", Boolean(), nullable=True, unique=None, default=None)
1706 archived = Column(
1707 "archived", Boolean(), nullable=True, unique=None, default=None)
1708 enable_statistics = Column(
1709 "statistics", Boolean(), nullable=True, unique=None, default=True)
1710 enable_downloads = Column(
1711 "downloads", Boolean(), nullable=True, unique=None, default=True)
1712 description = Column(
1713 "description", String(10000), nullable=True, unique=None, default=None)
1714 created_on = Column(
1715 'created_on', DateTime(timezone=False), nullable=True, unique=None,
1716 default=datetime.datetime.now)
1717 updated_on = Column(
1718 'updated_on', DateTime(timezone=False), nullable=True, unique=None,
1719 default=datetime.datetime.now)
1720 _landing_revision = Column(
1721 "landing_revision", String(255), nullable=False, unique=False,
1722 default=None)
1723 enable_locking = Column(
1724 "enable_locking", Boolean(), nullable=False, unique=None,
1725 default=False)
1726 _locked = Column(
1727 "locked", String(255), nullable=True, unique=False, default=None)
1728 _changeset_cache = Column(
1729 "changeset_cache", LargeBinary(), nullable=True) # JSON data
1730
1731 fork_id = Column(
1732 "fork_id", Integer(), ForeignKey('repositories.repo_id'),
1733 nullable=True, unique=False, default=None)
1734 group_id = Column(
1735 "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True,
1736 unique=False, default=None)
1737
1738 user = relationship('User', lazy='joined')
1739 fork = relationship('Repository', remote_side=repo_id, lazy='joined')
1740 group = relationship('RepoGroup', lazy='joined')
1741 repo_to_perm = relationship(
1742 'UserRepoToPerm', cascade='all',
1743 order_by='UserRepoToPerm.repo_to_perm_id')
1744 users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
1745 stats = relationship('Statistics', cascade='all', uselist=False)
1746
1747 followers = relationship(
1748 'UserFollowing',
1749 primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id',
1750 cascade='all')
1751 extra_fields = relationship(
1752 'RepositoryField', cascade="all, delete-orphan")
1753 logs = relationship('UserLog')
1754 comments = relationship(
1755 'ChangesetComment', cascade="all, delete-orphan")
1756 pull_requests_source = relationship(
1757 'PullRequest',
1758 primaryjoin='PullRequest.source_repo_id==Repository.repo_id',
1759 cascade="all, delete-orphan")
1760 pull_requests_target = relationship(
1761 'PullRequest',
1762 primaryjoin='PullRequest.target_repo_id==Repository.repo_id',
1763 cascade="all, delete-orphan")
1764 ui = relationship('RepoRhodeCodeUi', cascade="all")
1765 settings = relationship('RepoRhodeCodeSetting', cascade="all")
1766 integrations = relationship('Integration', cascade="all, delete-orphan")
1767
1768 scoped_tokens = relationship('UserApiKeys', cascade="all")
1769
1770 # no cascade, set NULL
1771 artifacts = relationship('FileStore', primaryjoin='FileStore.scope_repo_id==Repository.repo_id')
1772
1773 def __unicode__(self):
1774 return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,
1775 safe_unicode(self.repo_name))
1776
1777 @hybrid_property
1778 def description_safe(self):
1779 from rhodecode.lib import helpers as h
1780 return h.escape(self.description)
1781
1782 @hybrid_property
1783 def landing_rev(self):
1784 # always should return [rev_type, rev], e.g ['branch', 'master']
1785 if self._landing_revision:
1786 _rev_info = self._landing_revision.split(':')
1787 if len(_rev_info) < 2:
1788 _rev_info.insert(0, 'rev')
1789 return [_rev_info[0], _rev_info[1]]
1790 return [None, None]
1791
1792 @property
1793 def landing_ref_type(self):
1794 return self.landing_rev[0]
1795
1796 @property
1797 def landing_ref_name(self):
1798 return self.landing_rev[1]
1799
1800 @landing_rev.setter
1801 def landing_rev(self, val):
1802 if ':' not in val:
1803 raise ValueError('value must be delimited with `:` and consist '
1804 'of <rev_type>:<rev>, got %s instead' % val)
1805 self._landing_revision = val
1806
1807 @hybrid_property
1808 def locked(self):
1809 if self._locked:
1810 user_id, timelocked, reason = self._locked.split(':')
1811 lock_values = int(user_id), timelocked, reason
1812 else:
1813 lock_values = [None, None, None]
1814 return lock_values
1815
1816 @locked.setter
1817 def locked(self, val):
1818 if val and isinstance(val, (list, tuple)):
1819 self._locked = ':'.join(map(str, val))
1820 else:
1821 self._locked = None
1822
1823 @classmethod
1824 def _load_changeset_cache(cls, repo_id, changeset_cache_raw):
1825 from rhodecode.lib.vcs.backends.base import EmptyCommit
1826 dummy = EmptyCommit().__json__()
1827 if not changeset_cache_raw:
1828 dummy['source_repo_id'] = repo_id
1829 return json.loads(json.dumps(dummy))
1830
1831 try:
1832 return json.loads(changeset_cache_raw)
1833 except TypeError:
1834 return dummy
1835 except Exception:
1836 log.error(traceback.format_exc())
1837 return dummy
1838
1839 @hybrid_property
1840 def changeset_cache(self):
1841 return self._load_changeset_cache(self.repo_id, self._changeset_cache)
1842
1843 @changeset_cache.setter
1844 def changeset_cache(self, val):
1845 try:
1846 self._changeset_cache = json.dumps(val)
1847 except Exception:
1848 log.error(traceback.format_exc())
1849
1850 @hybrid_property
1851 def repo_name(self):
1852 return self._repo_name
1853
1854 @repo_name.setter
1855 def repo_name(self, value):
1856 self._repo_name = value
1857 self.repo_name_hash = hashlib.sha1(safe_str(value)).hexdigest()
1858
1859 @classmethod
1860 def normalize_repo_name(cls, repo_name):
1861 """
1862 Normalizes os specific repo_name to the format internally stored inside
1863 database using URL_SEP
1864
1865 :param cls:
1866 :param repo_name:
1867 """
1868 return cls.NAME_SEP.join(repo_name.split(os.sep))
1869
1870 @classmethod
1871 def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False):
1872 session = Session()
1873 q = session.query(cls).filter(cls.repo_name == repo_name)
1874
1875 if cache:
1876 if identity_cache:
1877 val = cls.identity_cache(session, 'repo_name', repo_name)
1878 if val:
1879 return val
1880 else:
1881 cache_key = "get_repo_by_name_%s" % _hash_key(repo_name)
1882 q = q.options(
1883 FromCache("sql_cache_short", cache_key))
1884
1885 return q.scalar()
1886
1887 @classmethod
1888 def get_by_id_or_repo_name(cls, repoid):
1889 if isinstance(repoid, (int, long)):
1890 try:
1891 repo = cls.get(repoid)
1892 except ValueError:
1893 repo = None
1894 else:
1895 repo = cls.get_by_repo_name(repoid)
1896 return repo
1897
1898 @classmethod
1899 def get_by_full_path(cls, repo_full_path):
1900 repo_name = repo_full_path.split(cls.base_path(), 1)[-1]
1901 repo_name = cls.normalize_repo_name(repo_name)
1902 return cls.get_by_repo_name(repo_name.strip(URL_SEP))
1903
1904 @classmethod
1905 def get_repo_forks(cls, repo_id):
1906 return cls.query().filter(Repository.fork_id == repo_id)
1907
1908 @classmethod
1909 def base_path(cls):
1910 """
1911 Returns base path when all repos are stored
1912
1913 :param cls:
1914 """
1915 q = Session().query(RhodeCodeUi)\
1916 .filter(RhodeCodeUi.ui_key == cls.NAME_SEP)
1917 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
1918 return q.one().ui_value
1919
1920 @classmethod
1921 def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None),
1922 case_insensitive=True, archived=False):
1923 q = Repository.query()
1924
1925 if not archived:
1926 q = q.filter(Repository.archived.isnot(true()))
1927
1928 if not isinstance(user_id, Optional):
1929 q = q.filter(Repository.user_id == user_id)
1930
1931 if not isinstance(group_id, Optional):
1932 q = q.filter(Repository.group_id == group_id)
1933
1934 if case_insensitive:
1935 q = q.order_by(func.lower(Repository.repo_name))
1936 else:
1937 q = q.order_by(Repository.repo_name)
1938
1939 return q.all()
1940
1941 @property
1942 def repo_uid(self):
1943 return '_{}'.format(self.repo_id)
1944
1945 @property
1946 def forks(self):
1947 """
1948 Return forks of this repo
1949 """
1950 return Repository.get_repo_forks(self.repo_id)
1951
1952 @property
1953 def parent(self):
1954 """
1955 Returns fork parent
1956 """
1957 return self.fork
1958
1959 @property
1960 def just_name(self):
1961 return self.repo_name.split(self.NAME_SEP)[-1]
1962
1963 @property
1964 def groups_with_parents(self):
1965 groups = []
1966 if self.group is None:
1967 return groups
1968
1969 cur_gr = self.group
1970 groups.insert(0, cur_gr)
1971 while 1:
1972 gr = getattr(cur_gr, 'parent_group', None)
1973 cur_gr = cur_gr.parent_group
1974 if gr is None:
1975 break
1976 groups.insert(0, gr)
1977
1978 return groups
1979
1980 @property
1981 def groups_and_repo(self):
1982 return self.groups_with_parents, self
1983
1984 @LazyProperty
1985 def repo_path(self):
1986 """
1987 Returns base full path for that repository means where it actually
1988 exists on a filesystem
1989 """
1990 q = Session().query(RhodeCodeUi).filter(
1991 RhodeCodeUi.ui_key == self.NAME_SEP)
1992 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
1993 return q.one().ui_value
1994
1995 @property
1996 def repo_full_path(self):
1997 p = [self.repo_path]
1998 # we need to split the name by / since this is how we store the
1999 # names in the database, but that eventually needs to be converted
2000 # into a valid system path
2001 p += self.repo_name.split(self.NAME_SEP)
2002 return os.path.join(*map(safe_unicode, p))
2003
2004 @property
2005 def cache_keys(self):
2006 """
2007 Returns associated cache keys for that repo
2008 """
2009 invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
2010 repo_id=self.repo_id)
2011 return CacheKey.query()\
2012 .filter(CacheKey.cache_args == invalidation_namespace)\
2013 .order_by(CacheKey.cache_key)\
2014 .all()
2015
2016 @property
2017 def cached_diffs_relative_dir(self):
2018 """
2019 Return a relative to the repository store path of cached diffs
2020 used for safe display for users, who shouldn't know the absolute store
2021 path
2022 """
2023 return os.path.join(
2024 os.path.dirname(self.repo_name),
2025 self.cached_diffs_dir.split(os.path.sep)[-1])
2026
2027 @property
2028 def cached_diffs_dir(self):
2029 path = self.repo_full_path
2030 return os.path.join(
2031 os.path.dirname(path),
2032 '.__shadow_diff_cache_repo_{}'.format(self.repo_id))
2033
2034 def cached_diffs(self):
2035 diff_cache_dir = self.cached_diffs_dir
2036 if os.path.isdir(diff_cache_dir):
2037 return os.listdir(diff_cache_dir)
2038 return []
2039
2040 def shadow_repos(self):
2041 shadow_repos_pattern = '.__shadow_repo_{}'.format(self.repo_id)
2042 return [
2043 x for x in os.listdir(os.path.dirname(self.repo_full_path))
2044 if x.startswith(shadow_repos_pattern)]
2045
2046 def get_new_name(self, repo_name):
2047 """
2048 returns new full repository name based on assigned group and new new
2049
2050 :param group_name:
2051 """
2052 path_prefix = self.group.full_path_splitted if self.group else []
2053 return self.NAME_SEP.join(path_prefix + [repo_name])
2054
2055 @property
2056 def _config(self):
2057 """
2058 Returns db based config object.
2059 """
2060 from rhodecode.lib.utils import make_db_config
2061 return make_db_config(clear_session=False, repo=self)
2062
2063 def permissions(self, with_admins=True, with_owner=True,
2064 expand_from_user_groups=False):
2065 """
2066 Permissions for repositories
2067 """
2068 _admin_perm = 'repository.admin'
2069
2070 owner_row = []
2071 if with_owner:
2072 usr = AttributeDict(self.user.get_dict())
2073 usr.owner_row = True
2074 usr.permission = _admin_perm
2075 usr.permission_id = None
2076 owner_row.append(usr)
2077
2078 super_admin_ids = []
2079 super_admin_rows = []
2080 if with_admins:
2081 for usr in User.get_all_super_admins():
2082 super_admin_ids.append(usr.user_id)
2083 # if this admin is also owner, don't double the record
2084 if usr.user_id == owner_row[0].user_id:
2085 owner_row[0].admin_row = True
2086 else:
2087 usr = AttributeDict(usr.get_dict())
2088 usr.admin_row = True
2089 usr.permission = _admin_perm
2090 usr.permission_id = None
2091 super_admin_rows.append(usr)
2092
2093 q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self)
2094 q = q.options(joinedload(UserRepoToPerm.repository),
2095 joinedload(UserRepoToPerm.user),
2096 joinedload(UserRepoToPerm.permission),)
2097
2098 # get owners and admins and permissions. We do a trick of re-writing
2099 # objects from sqlalchemy to named-tuples due to sqlalchemy session
2100 # has a global reference and changing one object propagates to all
2101 # others. This means if admin is also an owner admin_row that change
2102 # would propagate to both objects
2103 perm_rows = []
2104 for _usr in q.all():
2105 usr = AttributeDict(_usr.user.get_dict())
2106 # if this user is also owner/admin, mark as duplicate record
2107 if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids:
2108 usr.duplicate_perm = True
2109 # also check if this permission is maybe used by branch_permissions
2110 if _usr.branch_perm_entry:
2111 usr.branch_rules = [x.branch_rule_id for x in _usr.branch_perm_entry]
2112
2113 usr.permission = _usr.permission.permission_name
2114 usr.permission_id = _usr.repo_to_perm_id
2115 perm_rows.append(usr)
2116
2117 # filter the perm rows by 'default' first and then sort them by
2118 # admin,write,read,none permissions sorted again alphabetically in
2119 # each group
2120 perm_rows = sorted(perm_rows, key=display_user_sort)
2121
2122 user_groups_rows = []
2123 if expand_from_user_groups:
2124 for ug in self.permission_user_groups(with_members=True):
2125 for user_data in ug.members:
2126 user_groups_rows.append(user_data)
2127
2128 return super_admin_rows + owner_row + perm_rows + user_groups_rows
2129
2130 def permission_user_groups(self, with_members=True):
2131 q = UserGroupRepoToPerm.query()\
2132 .filter(UserGroupRepoToPerm.repository == self)
2133 q = q.options(joinedload(UserGroupRepoToPerm.repository),
2134 joinedload(UserGroupRepoToPerm.users_group),
2135 joinedload(UserGroupRepoToPerm.permission),)
2136
2137 perm_rows = []
2138 for _user_group in q.all():
2139 entry = AttributeDict(_user_group.users_group.get_dict())
2140 entry.permission = _user_group.permission.permission_name
2141 if with_members:
2142 entry.members = [x.user.get_dict()
2143 for x in _user_group.users_group.members]
2144 perm_rows.append(entry)
2145
2146 perm_rows = sorted(perm_rows, key=display_user_group_sort)
2147 return perm_rows
2148
2149 def get_api_data(self, include_secrets=False):
2150 """
2151 Common function for generating repo api data
2152
2153 :param include_secrets: See :meth:`User.get_api_data`.
2154
2155 """
2156 # TODO: mikhail: Here there is an anti-pattern, we probably need to
2157 # move this methods on models level.
2158 from rhodecode.model.settings import SettingsModel
2159 from rhodecode.model.repo import RepoModel
2160
2161 repo = self
2162 _user_id, _time, _reason = self.locked
2163
2164 data = {
2165 'repo_id': repo.repo_id,
2166 'repo_name': repo.repo_name,
2167 'repo_type': repo.repo_type,
2168 'clone_uri': repo.clone_uri or '',
2169 'push_uri': repo.push_uri or '',
2170 'url': RepoModel().get_url(self),
2171 'private': repo.private,
2172 'created_on': repo.created_on,
2173 'description': repo.description_safe,
2174 'landing_rev': repo.landing_rev,
2175 'owner': repo.user.username,
2176 'fork_of': repo.fork.repo_name if repo.fork else None,
2177 'fork_of_id': repo.fork.repo_id if repo.fork else None,
2178 'enable_statistics': repo.enable_statistics,
2179 'enable_locking': repo.enable_locking,
2180 'enable_downloads': repo.enable_downloads,
2181 'last_changeset': repo.changeset_cache,
2182 'locked_by': User.get(_user_id).get_api_data(
2183 include_secrets=include_secrets) if _user_id else None,
2184 'locked_date': time_to_datetime(_time) if _time else None,
2185 'lock_reason': _reason if _reason else None,
2186 }
2187
2188 # TODO: mikhail: should be per-repo settings here
2189 rc_config = SettingsModel().get_all_settings()
2190 repository_fields = str2bool(
2191 rc_config.get('rhodecode_repository_fields'))
2192 if repository_fields:
2193 for f in self.extra_fields:
2194 data[f.field_key_prefixed] = f.field_value
2195
2196 return data
2197
2198 @classmethod
2199 def lock(cls, repo, user_id, lock_time=None, lock_reason=None):
2200 if not lock_time:
2201 lock_time = time.time()
2202 if not lock_reason:
2203 lock_reason = cls.LOCK_AUTOMATIC
2204 repo.locked = [user_id, lock_time, lock_reason]
2205 Session().add(repo)
2206 Session().commit()
2207
2208 @classmethod
2209 def unlock(cls, repo):
2210 repo.locked = None
2211 Session().add(repo)
2212 Session().commit()
2213
2214 @classmethod
2215 def getlock(cls, repo):
2216 return repo.locked
2217
2218 def is_user_lock(self, user_id):
2219 if self.lock[0]:
2220 lock_user_id = safe_int(self.lock[0])
2221 user_id = safe_int(user_id)
2222 # both are ints, and they are equal
2223 return all([lock_user_id, user_id]) and lock_user_id == user_id
2224
2225 return False
2226
2227 def get_locking_state(self, action, user_id, only_when_enabled=True):
2228 """
2229 Checks locking on this repository, if locking is enabled and lock is
2230 present returns a tuple of make_lock, locked, locked_by.
2231 make_lock can have 3 states None (do nothing) True, make lock
2232 False release lock, This value is later propagated to hooks, which
2233 do the locking. Think about this as signals passed to hooks what to do.
2234
2235 """
2236 # TODO: johbo: This is part of the business logic and should be moved
2237 # into the RepositoryModel.
2238
2239 if action not in ('push', 'pull'):
2240 raise ValueError("Invalid action value: %s" % repr(action))
2241
2242 # defines if locked error should be thrown to user
2243 currently_locked = False
2244 # defines if new lock should be made, tri-state
2245 make_lock = None
2246 repo = self
2247 user = User.get(user_id)
2248
2249 lock_info = repo.locked
2250
2251 if repo and (repo.enable_locking or not only_when_enabled):
2252 if action == 'push':
2253 # check if it's already locked !, if it is compare users
2254 locked_by_user_id = lock_info[0]
2255 if user.user_id == locked_by_user_id:
2256 log.debug(
2257 'Got `push` action from user %s, now unlocking', user)
2258 # unlock if we have push from user who locked
2259 make_lock = False
2260 else:
2261 # we're not the same user who locked, ban with
2262 # code defined in settings (default is 423 HTTP Locked) !
2263 log.debug('Repo %s is currently locked by %s', repo, user)
2264 currently_locked = True
2265 elif action == 'pull':
2266 # [0] user [1] date
2267 if lock_info[0] and lock_info[1]:
2268 log.debug('Repo %s is currently locked by %s', repo, user)
2269 currently_locked = True
2270 else:
2271 log.debug('Setting lock on repo %s by %s', repo, user)
2272 make_lock = True
2273
2274 else:
2275 log.debug('Repository %s do not have locking enabled', repo)
2276
2277 log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s',
2278 make_lock, currently_locked, lock_info)
2279
2280 from rhodecode.lib.auth import HasRepoPermissionAny
2281 perm_check = HasRepoPermissionAny('repository.write', 'repository.admin')
2282 if make_lock and not perm_check(repo_name=repo.repo_name, user=user):
2283 # if we don't have at least write permission we cannot make a lock
2284 log.debug('lock state reset back to FALSE due to lack '
2285 'of at least read permission')
2286 make_lock = False
2287
2288 return make_lock, currently_locked, lock_info
2289
2290 @property
2291 def last_commit_cache_update_diff(self):
2292 return time.time() - (safe_int(self.changeset_cache.get('updated_on')) or 0)
2293
2294 @classmethod
2295 def _load_commit_change(cls, last_commit_cache):
2296 from rhodecode.lib.vcs.utils.helpers import parse_datetime
2297 empty_date = datetime.datetime.fromtimestamp(0)
2298 date_latest = last_commit_cache.get('date', empty_date)
2299 try:
2300 return parse_datetime(date_latest)
2301 except Exception:
2302 return empty_date
2303
2304 @property
2305 def last_commit_change(self):
2306 return self._load_commit_change(self.changeset_cache)
2307
2308 @property
2309 def last_db_change(self):
2310 return self.updated_on
2311
2312 @property
2313 def clone_uri_hidden(self):
2314 clone_uri = self.clone_uri
2315 if clone_uri:
2316 import urlobject
2317 url_obj = urlobject.URLObject(cleaned_uri(clone_uri))
2318 if url_obj.password:
2319 clone_uri = url_obj.with_password('*****')
2320 return clone_uri
2321
2322 @property
2323 def push_uri_hidden(self):
2324 push_uri = self.push_uri
2325 if push_uri:
2326 import urlobject
2327 url_obj = urlobject.URLObject(cleaned_uri(push_uri))
2328 if url_obj.password:
2329 push_uri = url_obj.with_password('*****')
2330 return push_uri
2331
2332 def clone_url(self, **override):
2333 from rhodecode.model.settings import SettingsModel
2334
2335 uri_tmpl = None
2336 if 'with_id' in override:
2337 uri_tmpl = self.DEFAULT_CLONE_URI_ID
2338 del override['with_id']
2339
2340 if 'uri_tmpl' in override:
2341 uri_tmpl = override['uri_tmpl']
2342 del override['uri_tmpl']
2343
2344 ssh = False
2345 if 'ssh' in override:
2346 ssh = True
2347 del override['ssh']
2348
2349 # we didn't override our tmpl from **overrides
2350 request = get_current_request()
2351 if not uri_tmpl:
2352 if hasattr(request, 'call_context') and hasattr(request.call_context, 'rc_config'):
2353 rc_config = request.call_context.rc_config
2354 else:
2355 rc_config = SettingsModel().get_all_settings(cache=True)
2356
2357 if ssh:
2358 uri_tmpl = rc_config.get(
2359 'rhodecode_clone_uri_ssh_tmpl') or self.DEFAULT_CLONE_URI_SSH
2360
2361 else:
2362 uri_tmpl = rc_config.get(
2363 'rhodecode_clone_uri_tmpl') or self.DEFAULT_CLONE_URI
2364
2365 return get_clone_url(request=request,
2366 uri_tmpl=uri_tmpl,
2367 repo_name=self.repo_name,
2368 repo_id=self.repo_id,
2369 repo_type=self.repo_type,
2370 **override)
2371
2372 def set_state(self, state):
2373 self.repo_state = state
2374 Session().add(self)
2375 #==========================================================================
2376 # SCM PROPERTIES
2377 #==========================================================================
2378
2379 def get_commit(self, commit_id=None, commit_idx=None, pre_load=None, maybe_unreachable=False):
2380 return get_commit_safe(
2381 self.scm_instance(), commit_id, commit_idx, pre_load=pre_load,
2382 maybe_unreachable=maybe_unreachable)
2383
2384 def get_changeset(self, rev=None, pre_load=None):
2385 warnings.warn("Use get_commit", DeprecationWarning)
2386 commit_id = None
2387 commit_idx = None
2388 if isinstance(rev, compat.string_types):
2389 commit_id = rev
2390 else:
2391 commit_idx = rev
2392 return self.get_commit(commit_id=commit_id, commit_idx=commit_idx,
2393 pre_load=pre_load)
2394
2395 def get_landing_commit(self):
2396 """
2397 Returns landing commit, or if that doesn't exist returns the tip
2398 """
2399 _rev_type, _rev = self.landing_rev
2400 commit = self.get_commit(_rev)
2401 if isinstance(commit, EmptyCommit):
2402 return self.get_commit()
2403 return commit
2404
2405 def flush_commit_cache(self):
2406 self.update_commit_cache(cs_cache={'raw_id':'0'})
2407 self.update_commit_cache()
2408
2409 def update_commit_cache(self, cs_cache=None, config=None):
2410 """
2411 Update cache of last commit for repository
2412 cache_keys should be::
2413
2414 source_repo_id
2415 short_id
2416 raw_id
2417 revision
2418 parents
2419 message
2420 date
2421 author
2422 updated_on
2423
2424 """
2425 from rhodecode.lib.vcs.backends.base import BaseChangeset
2426 from rhodecode.lib.vcs.utils.helpers import parse_datetime
2427 empty_date = datetime.datetime.fromtimestamp(0)
2428
2429 if cs_cache is None:
2430 # use no-cache version here
2431 try:
2432 scm_repo = self.scm_instance(cache=False, config=config)
2433 except VCSError:
2434 scm_repo = None
2435 empty = scm_repo is None or scm_repo.is_empty()
2436
2437 if not empty:
2438 cs_cache = scm_repo.get_commit(
2439 pre_load=["author", "date", "message", "parents", "branch"])
2440 else:
2441 cs_cache = EmptyCommit()
2442
2443 if isinstance(cs_cache, BaseChangeset):
2444 cs_cache = cs_cache.__json__()
2445
2446 def is_outdated(new_cs_cache):
2447 if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or
2448 new_cs_cache['revision'] != self.changeset_cache['revision']):
2449 return True
2450 return False
2451
2452 # check if we have maybe already latest cached revision
2453 if is_outdated(cs_cache) or not self.changeset_cache:
2454 _current_datetime = datetime.datetime.utcnow()
2455 last_change = cs_cache.get('date') or _current_datetime
2456 # we check if last update is newer than the new value
2457 # if yes, we use the current timestamp instead. Imagine you get
2458 # old commit pushed 1y ago, we'd set last update 1y to ago.
2459 last_change_timestamp = datetime_to_time(last_change)
2460 current_timestamp = datetime_to_time(last_change)
2461 if last_change_timestamp > current_timestamp and not empty:
2462 cs_cache['date'] = _current_datetime
2463
2464 _date_latest = parse_datetime(cs_cache.get('date') or empty_date)
2465 cs_cache['updated_on'] = time.time()
2466 self.changeset_cache = cs_cache
2467 self.updated_on = last_change
2468 Session().add(self)
2469 Session().commit()
2470
2471 else:
2472 if empty:
2473 cs_cache = EmptyCommit().__json__()
2474 else:
2475 cs_cache = self.changeset_cache
2476
2477 _date_latest = parse_datetime(cs_cache.get('date') or empty_date)
2478
2479 cs_cache['updated_on'] = time.time()
2480 self.changeset_cache = cs_cache
2481 self.updated_on = _date_latest
2482 Session().add(self)
2483 Session().commit()
2484
2485 log.debug('updated repo `%s` with new commit cache %s, and last update_date: %s',
2486 self.repo_name, cs_cache, _date_latest)
2487
2488 @property
2489 def tip(self):
2490 return self.get_commit('tip')
2491
2492 @property
2493 def author(self):
2494 return self.tip.author
2495
2496 @property
2497 def last_change(self):
2498 return self.scm_instance().last_change
2499
2500 def get_comments(self, revisions=None):
2501 """
2502 Returns comments for this repository grouped by revisions
2503
2504 :param revisions: filter query by revisions only
2505 """
2506 cmts = ChangesetComment.query()\
2507 .filter(ChangesetComment.repo == self)
2508 if revisions:
2509 cmts = cmts.filter(ChangesetComment.revision.in_(revisions))
2510 grouped = collections.defaultdict(list)
2511 for cmt in cmts.all():
2512 grouped[cmt.revision].append(cmt)
2513 return grouped
2514
2515 def statuses(self, revisions=None):
2516 """
2517 Returns statuses for this repository
2518
2519 :param revisions: list of revisions to get statuses for
2520 """
2521 statuses = ChangesetStatus.query()\
2522 .filter(ChangesetStatus.repo == self)\
2523 .filter(ChangesetStatus.version == 0)
2524
2525 if revisions:
2526 # Try doing the filtering in chunks to avoid hitting limits
2527 size = 500
2528 status_results = []
2529 for chunk in xrange(0, len(revisions), size):
2530 status_results += statuses.filter(
2531 ChangesetStatus.revision.in_(
2532 revisions[chunk: chunk+size])
2533 ).all()
2534 else:
2535 status_results = statuses.all()
2536
2537 grouped = {}
2538
2539 # maybe we have open new pullrequest without a status?
2540 stat = ChangesetStatus.STATUS_UNDER_REVIEW
2541 status_lbl = ChangesetStatus.get_status_lbl(stat)
2542 for pr in PullRequest.query().filter(PullRequest.source_repo == self).all():
2543 for rev in pr.revisions:
2544 pr_id = pr.pull_request_id
2545 pr_repo = pr.target_repo.repo_name
2546 grouped[rev] = [stat, status_lbl, pr_id, pr_repo]
2547
2548 for stat in status_results:
2549 pr_id = pr_repo = None
2550 if stat.pull_request:
2551 pr_id = stat.pull_request.pull_request_id
2552 pr_repo = stat.pull_request.target_repo.repo_name
2553 grouped[stat.revision] = [str(stat.status), stat.status_lbl,
2554 pr_id, pr_repo]
2555 return grouped
2556
2557 # ==========================================================================
2558 # SCM CACHE INSTANCE
2559 # ==========================================================================
2560
2561 def scm_instance(self, **kwargs):
2562 import rhodecode
2563
2564 # Passing a config will not hit the cache currently only used
2565 # for repo2dbmapper
2566 config = kwargs.pop('config', None)
2567 cache = kwargs.pop('cache', None)
2568 vcs_full_cache = kwargs.pop('vcs_full_cache', None)
2569 if vcs_full_cache is not None:
2570 # allows override global config
2571 full_cache = vcs_full_cache
2572 else:
2573 full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))
2574 # if cache is NOT defined use default global, else we have a full
2575 # control over cache behaviour
2576 if cache is None and full_cache and not config:
2577 log.debug('Initializing pure cached instance for %s', self.repo_path)
2578 return self._get_instance_cached()
2579
2580 # cache here is sent to the "vcs server"
2581 return self._get_instance(cache=bool(cache), config=config)
2582
2583 def _get_instance_cached(self):
2584 from rhodecode.lib import rc_cache
2585
2586 cache_namespace_uid = 'cache_repo_instance.{}'.format(self.repo_id)
2587 invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
2588 repo_id=self.repo_id)
2589 region = rc_cache.get_or_create_region('cache_repo_longterm', cache_namespace_uid)
2590
2591 @region.conditional_cache_on_arguments(namespace=cache_namespace_uid)
2592 def get_instance_cached(repo_id, context_id, _cache_state_uid):
2593 return self._get_instance(repo_state_uid=_cache_state_uid)
2594
2595 # we must use thread scoped cache here,
2596 # because each thread of gevent needs it's own not shared connection and cache
2597 # we also alter `args` so the cache key is individual for every green thread.
2598 inv_context_manager = rc_cache.InvalidationContext(
2599 uid=cache_namespace_uid, invalidation_namespace=invalidation_namespace,
2600 thread_scoped=True)
2601 with inv_context_manager as invalidation_context:
2602 cache_state_uid = invalidation_context.cache_data['cache_state_uid']
2603 args = (self.repo_id, inv_context_manager.cache_key, cache_state_uid)
2604
2605 # re-compute and store cache if we get invalidate signal
2606 if invalidation_context.should_invalidate():
2607 instance = get_instance_cached.refresh(*args)
2608 else:
2609 instance = get_instance_cached(*args)
2610
2611 log.debug('Repo instance fetched in %.4fs', inv_context_manager.compute_time)
2612 return instance
2613
2614 def _get_instance(self, cache=True, config=None, repo_state_uid=None):
2615 log.debug('Initializing %s instance `%s` with cache flag set to: %s',
2616 self.repo_type, self.repo_path, cache)
2617 config = config or self._config
2618 custom_wire = {
2619 'cache': cache, # controls the vcs.remote cache
2620 'repo_state_uid': repo_state_uid
2621 }
2622 repo = get_vcs_instance(
2623 repo_path=safe_str(self.repo_full_path),
2624 config=config,
2625 with_wire=custom_wire,
2626 create=False,
2627 _vcs_alias=self.repo_type)
2628 if repo is not None:
2629 repo.count() # cache rebuild
2630 return repo
2631
2632 def get_shadow_repository_path(self, workspace_id):
2633 from rhodecode.lib.vcs.backends.base import BaseRepository
2634 shadow_repo_path = BaseRepository._get_shadow_repository_path(
2635 self.repo_full_path, self.repo_id, workspace_id)
2636 return shadow_repo_path
2637
2638 def __json__(self):
2639 return {'landing_rev': self.landing_rev}
2640
2641 def get_dict(self):
2642
2643 # Since we transformed `repo_name` to a hybrid property, we need to
2644 # keep compatibility with the code which uses `repo_name` field.
2645
2646 result = super(Repository, self).get_dict()
2647 result['repo_name'] = result.pop('_repo_name', None)
2648 return result
2649
2650
2651 class RepoGroup(Base, BaseModel):
2652 __tablename__ = 'groups'
2653 __table_args__ = (
2654 UniqueConstraint('group_name', 'group_parent_id'),
2655 base_table_args,
2656 )
2657 __mapper_args__ = {'order_by': 'group_name'}
2658
2659 CHOICES_SEPARATOR = '/' # used to generate select2 choices for nested groups
2660
2661 group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2662 _group_name = Column("group_name", String(255), nullable=False, unique=True, default=None)
2663 group_name_hash = Column("repo_group_name_hash", String(1024), nullable=False, unique=False)
2664 group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)
2665 group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None)
2666 enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
2667 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
2668 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
2669 updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
2670 personal = Column('personal', Boolean(), nullable=True, unique=None, default=None)
2671 _changeset_cache = Column("changeset_cache", LargeBinary(), nullable=True) # JSON data
2672
2673 repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
2674 users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
2675 parent_group = relationship('RepoGroup', remote_side=group_id)
2676 user = relationship('User')
2677 integrations = relationship('Integration', cascade="all, delete-orphan")
2678
2679 # no cascade, set NULL
2680 scope_artifacts = relationship('FileStore', primaryjoin='FileStore.scope_repo_group_id==RepoGroup.group_id')
2681
2682 def __init__(self, group_name='', parent_group=None):
2683 self.group_name = group_name
2684 self.parent_group = parent_group
2685
2686 def __unicode__(self):
2687 return u"<%s('id:%s:%s')>" % (
2688 self.__class__.__name__, self.group_id, self.group_name)
2689
2690 @hybrid_property
2691 def group_name(self):
2692 return self._group_name
2693
2694 @group_name.setter
2695 def group_name(self, value):
2696 self._group_name = value
2697 self.group_name_hash = self.hash_repo_group_name(value)
2698
2699 @classmethod
2700 def _load_changeset_cache(cls, repo_id, changeset_cache_raw):
2701 from rhodecode.lib.vcs.backends.base import EmptyCommit
2702 dummy = EmptyCommit().__json__()
2703 if not changeset_cache_raw:
2704 dummy['source_repo_id'] = repo_id
2705 return json.loads(json.dumps(dummy))
2706
2707 try:
2708 return json.loads(changeset_cache_raw)
2709 except TypeError:
2710 return dummy
2711 except Exception:
2712 log.error(traceback.format_exc())
2713 return dummy
2714
2715 @hybrid_property
2716 def changeset_cache(self):
2717 return self._load_changeset_cache('', self._changeset_cache)
2718
2719 @changeset_cache.setter
2720 def changeset_cache(self, val):
2721 try:
2722 self._changeset_cache = json.dumps(val)
2723 except Exception:
2724 log.error(traceback.format_exc())
2725
2726 @validates('group_parent_id')
2727 def validate_group_parent_id(self, key, val):
2728 """
2729 Check cycle references for a parent group to self
2730 """
2731 if self.group_id and val:
2732 assert val != self.group_id
2733
2734 return val
2735
2736 @hybrid_property
2737 def description_safe(self):
2738 from rhodecode.lib import helpers as h
2739 return h.escape(self.group_description)
2740
2741 @classmethod
2742 def hash_repo_group_name(cls, repo_group_name):
2743 val = remove_formatting(repo_group_name)
2744 val = safe_str(val).lower()
2745 chars = []
2746 for c in val:
2747 if c not in string.ascii_letters:
2748 c = str(ord(c))
2749 chars.append(c)
2750
2751 return ''.join(chars)
2752
2753 @classmethod
2754 def _generate_choice(cls, repo_group):
2755 from webhelpers2.html import literal as _literal
2756 _name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k))
2757 return repo_group.group_id, _name(repo_group.full_path_splitted)
2758
2759 @classmethod
2760 def groups_choices(cls, groups=None, show_empty_group=True):
2761 if not groups:
2762 groups = cls.query().all()
2763
2764 repo_groups = []
2765 if show_empty_group:
2766 repo_groups = [(-1, u'-- %s --' % _('No parent'))]
2767
2768 repo_groups.extend([cls._generate_choice(x) for x in groups])
2769
2770 repo_groups = sorted(
2771 repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0])
2772 return repo_groups
2773
2774 @classmethod
2775 def url_sep(cls):
2776 return URL_SEP
2777
2778 @classmethod
2779 def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
2780 if case_insensitive:
2781 gr = cls.query().filter(func.lower(cls.group_name)
2782 == func.lower(group_name))
2783 else:
2784 gr = cls.query().filter(cls.group_name == group_name)
2785 if cache:
2786 name_key = _hash_key(group_name)
2787 gr = gr.options(
2788 FromCache("sql_cache_short", "get_group_%s" % name_key))
2789 return gr.scalar()
2790
2791 @classmethod
2792 def get_user_personal_repo_group(cls, user_id):
2793 user = User.get(user_id)
2794 if user.username == User.DEFAULT_USER:
2795 return None
2796
2797 return cls.query()\
2798 .filter(cls.personal == true()) \
2799 .filter(cls.user == user) \
2800 .order_by(cls.group_id.asc()) \
2801 .first()
2802
2803 @classmethod
2804 def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),
2805 case_insensitive=True):
2806 q = RepoGroup.query()
2807
2808 if not isinstance(user_id, Optional):
2809 q = q.filter(RepoGroup.user_id == user_id)
2810
2811 if not isinstance(group_id, Optional):
2812 q = q.filter(RepoGroup.group_parent_id == group_id)
2813
2814 if case_insensitive:
2815 q = q.order_by(func.lower(RepoGroup.group_name))
2816 else:
2817 q = q.order_by(RepoGroup.group_name)
2818 return q.all()
2819
2820 @property
2821 def parents(self, parents_recursion_limit=10):
2822 groups = []
2823 if self.parent_group is None:
2824 return groups
2825 cur_gr = self.parent_group
2826 groups.insert(0, cur_gr)
2827 cnt = 0
2828 while 1:
2829 cnt += 1
2830 gr = getattr(cur_gr, 'parent_group', None)
2831 cur_gr = cur_gr.parent_group
2832 if gr is None:
2833 break
2834 if cnt == parents_recursion_limit:
2835 # this will prevent accidental infinit loops
2836 log.error('more than %s parents found for group %s, stopping '
2837 'recursive parent fetching', parents_recursion_limit, self)
2838 break
2839
2840 groups.insert(0, gr)
2841 return groups
2842
2843 @property
2844 def last_commit_cache_update_diff(self):
2845 return time.time() - (safe_int(self.changeset_cache.get('updated_on')) or 0)
2846
2847 @classmethod
2848 def _load_commit_change(cls, last_commit_cache):
2849 from rhodecode.lib.vcs.utils.helpers import parse_datetime
2850 empty_date = datetime.datetime.fromtimestamp(0)
2851 date_latest = last_commit_cache.get('date', empty_date)
2852 try:
2853 return parse_datetime(date_latest)
2854 except Exception:
2855 return empty_date
2856
2857 @property
2858 def last_commit_change(self):
2859 return self._load_commit_change(self.changeset_cache)
2860
2861 @property
2862 def last_db_change(self):
2863 return self.updated_on
2864
2865 @property
2866 def children(self):
2867 return RepoGroup.query().filter(RepoGroup.parent_group == self)
2868
2869 @property
2870 def name(self):
2871 return self.group_name.split(RepoGroup.url_sep())[-1]
2872
2873 @property
2874 def full_path(self):
2875 return self.group_name
2876
2877 @property
2878 def full_path_splitted(self):
2879 return self.group_name.split(RepoGroup.url_sep())
2880
2881 @property
2882 def repositories(self):
2883 return Repository.query()\
2884 .filter(Repository.group == self)\
2885 .order_by(Repository.repo_name)
2886
2887 @property
2888 def repositories_recursive_count(self):
2889 cnt = self.repositories.count()
2890
2891 def children_count(group):
2892 cnt = 0
2893 for child in group.children:
2894 cnt += child.repositories.count()
2895 cnt += children_count(child)
2896 return cnt
2897
2898 return cnt + children_count(self)
2899
2900 def _recursive_objects(self, include_repos=True, include_groups=True):
2901 all_ = []
2902
2903 def _get_members(root_gr):
2904 if include_repos:
2905 for r in root_gr.repositories:
2906 all_.append(r)
2907 childs = root_gr.children.all()
2908 if childs:
2909 for gr in childs:
2910 if include_groups:
2911 all_.append(gr)
2912 _get_members(gr)
2913
2914 root_group = []
2915 if include_groups:
2916 root_group = [self]
2917
2918 _get_members(self)
2919 return root_group + all_
2920
2921 def recursive_groups_and_repos(self):
2922 """
2923 Recursive return all groups, with repositories in those groups
2924 """
2925 return self._recursive_objects()
2926
2927 def recursive_groups(self):
2928 """
2929 Returns all children groups for this group including children of children
2930 """
2931 return self._recursive_objects(include_repos=False)
2932
2933 def recursive_repos(self):
2934 """
2935 Returns all children repositories for this group
2936 """
2937 return self._recursive_objects(include_groups=False)
2938
2939 def get_new_name(self, group_name):
2940 """
2941 returns new full group name based on parent and new name
2942
2943 :param group_name:
2944 """
2945 path_prefix = (self.parent_group.full_path_splitted if
2946 self.parent_group else [])
2947 return RepoGroup.url_sep().join(path_prefix + [group_name])
2948
2949 def update_commit_cache(self, config=None):
2950 """
2951 Update cache of last commit for newest repository inside this repository group.
2952 cache_keys should be::
2953
2954 source_repo_id
2955 short_id
2956 raw_id
2957 revision
2958 parents
2959 message
2960 date
2961 author
2962
2963 """
2964 from rhodecode.lib.vcs.utils.helpers import parse_datetime
2965 empty_date = datetime.datetime.fromtimestamp(0)
2966
2967 def repo_groups_and_repos(root_gr):
2968 for _repo in root_gr.repositories:
2969 yield _repo
2970 for child_group in root_gr.children.all():
2971 yield child_group
2972
2973 latest_repo_cs_cache = {}
2974 for obj in repo_groups_and_repos(self):
2975 repo_cs_cache = obj.changeset_cache
2976 date_latest = latest_repo_cs_cache.get('date', empty_date)
2977 date_current = repo_cs_cache.get('date', empty_date)
2978 current_timestamp = datetime_to_time(parse_datetime(date_latest))
2979 if current_timestamp < datetime_to_time(parse_datetime(date_current)):
2980 latest_repo_cs_cache = repo_cs_cache
2981 if hasattr(obj, 'repo_id'):
2982 latest_repo_cs_cache['source_repo_id'] = obj.repo_id
2983 else:
2984 latest_repo_cs_cache['source_repo_id'] = repo_cs_cache.get('source_repo_id')
2985
2986 _date_latest = parse_datetime(latest_repo_cs_cache.get('date') or empty_date)
2987
2988 latest_repo_cs_cache['updated_on'] = time.time()
2989 self.changeset_cache = latest_repo_cs_cache
2990 self.updated_on = _date_latest
2991 Session().add(self)
2992 Session().commit()
2993
2994 log.debug('updated repo group `%s` with new commit cache %s, and last update_date: %s',
2995 self.group_name, latest_repo_cs_cache, _date_latest)
2996
2997 def permissions(self, with_admins=True, with_owner=True,
2998 expand_from_user_groups=False):
2999 """
3000 Permissions for repository groups
3001 """
3002 _admin_perm = 'group.admin'
3003
3004 owner_row = []
3005 if with_owner:
3006 usr = AttributeDict(self.user.get_dict())
3007 usr.owner_row = True
3008 usr.permission = _admin_perm
3009 owner_row.append(usr)
3010
3011 super_admin_ids = []
3012 super_admin_rows = []
3013 if with_admins:
3014 for usr in User.get_all_super_admins():
3015 super_admin_ids.append(usr.user_id)
3016 # if this admin is also owner, don't double the record
3017 if usr.user_id == owner_row[0].user_id:
3018 owner_row[0].admin_row = True
3019 else:
3020 usr = AttributeDict(usr.get_dict())
3021 usr.admin_row = True
3022 usr.permission = _admin_perm
3023 super_admin_rows.append(usr)
3024
3025 q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self)
3026 q = q.options(joinedload(UserRepoGroupToPerm.group),
3027 joinedload(UserRepoGroupToPerm.user),
3028 joinedload(UserRepoGroupToPerm.permission),)
3029
3030 # get owners and admins and permissions. We do a trick of re-writing
3031 # objects from sqlalchemy to named-tuples due to sqlalchemy session
3032 # has a global reference and changing one object propagates to all
3033 # others. This means if admin is also an owner admin_row that change
3034 # would propagate to both objects
3035 perm_rows = []
3036 for _usr in q.all():
3037 usr = AttributeDict(_usr.user.get_dict())
3038 # if this user is also owner/admin, mark as duplicate record
3039 if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids:
3040 usr.duplicate_perm = True
3041 usr.permission = _usr.permission.permission_name
3042 perm_rows.append(usr)
3043
3044 # filter the perm rows by 'default' first and then sort them by
3045 # admin,write,read,none permissions sorted again alphabetically in
3046 # each group
3047 perm_rows = sorted(perm_rows, key=display_user_sort)
3048
3049 user_groups_rows = []
3050 if expand_from_user_groups:
3051 for ug in self.permission_user_groups(with_members=True):
3052 for user_data in ug.members:
3053 user_groups_rows.append(user_data)
3054
3055 return super_admin_rows + owner_row + perm_rows + user_groups_rows
3056
3057 def permission_user_groups(self, with_members=False):
3058 q = UserGroupRepoGroupToPerm.query()\
3059 .filter(UserGroupRepoGroupToPerm.group == self)
3060 q = q.options(joinedload(UserGroupRepoGroupToPerm.group),
3061 joinedload(UserGroupRepoGroupToPerm.users_group),
3062 joinedload(UserGroupRepoGroupToPerm.permission),)
3063
3064 perm_rows = []
3065 for _user_group in q.all():
3066 entry = AttributeDict(_user_group.users_group.get_dict())
3067 entry.permission = _user_group.permission.permission_name
3068 if with_members:
3069 entry.members = [x.user.get_dict()
3070 for x in _user_group.users_group.members]
3071 perm_rows.append(entry)
3072
3073 perm_rows = sorted(perm_rows, key=display_user_group_sort)
3074 return perm_rows
3075
3076 def get_api_data(self):
3077 """
3078 Common function for generating api data
3079
3080 """
3081 group = self
3082 data = {
3083 'group_id': group.group_id,
3084 'group_name': group.group_name,
3085 'group_description': group.description_safe,
3086 'parent_group': group.parent_group.group_name if group.parent_group else None,
3087 'repositories': [x.repo_name for x in group.repositories],
3088 'owner': group.user.username,
3089 }
3090 return data
3091
3092 def get_dict(self):
3093 # Since we transformed `group_name` to a hybrid property, we need to
3094 # keep compatibility with the code which uses `group_name` field.
3095 result = super(RepoGroup, self).get_dict()
3096 result['group_name'] = result.pop('_group_name', None)
3097 return result
3098
3099
3100 class Permission(Base, BaseModel):
3101 __tablename__ = 'permissions'
3102 __table_args__ = (
3103 Index('p_perm_name_idx', 'permission_name'),
3104 base_table_args,
3105 )
3106
3107 PERMS = [
3108 ('hg.admin', _('RhodeCode Super Administrator')),
3109
3110 ('repository.none', _('Repository no access')),
3111 ('repository.read', _('Repository read access')),
3112 ('repository.write', _('Repository write access')),
3113 ('repository.admin', _('Repository admin access')),
3114
3115 ('group.none', _('Repository group no access')),
3116 ('group.read', _('Repository group read access')),
3117 ('group.write', _('Repository group write access')),
3118 ('group.admin', _('Repository group admin access')),
3119
3120 ('usergroup.none', _('User group no access')),
3121 ('usergroup.read', _('User group read access')),
3122 ('usergroup.write', _('User group write access')),
3123 ('usergroup.admin', _('User group admin access')),
3124
3125 ('branch.none', _('Branch no permissions')),
3126 ('branch.merge', _('Branch access by web merge')),
3127 ('branch.push', _('Branch access by push')),
3128 ('branch.push_force', _('Branch access by push with force')),
3129
3130 ('hg.repogroup.create.false', _('Repository Group creation disabled')),
3131 ('hg.repogroup.create.true', _('Repository Group creation enabled')),
3132
3133 ('hg.usergroup.create.false', _('User Group creation disabled')),
3134 ('hg.usergroup.create.true', _('User Group creation enabled')),
3135
3136 ('hg.create.none', _('Repository creation disabled')),
3137 ('hg.create.repository', _('Repository creation enabled')),
3138 ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')),
3139 ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')),
3140
3141 ('hg.fork.none', _('Repository forking disabled')),
3142 ('hg.fork.repository', _('Repository forking enabled')),
3143
3144 ('hg.register.none', _('Registration disabled')),
3145 ('hg.register.manual_activate', _('User Registration with manual account activation')),
3146 ('hg.register.auto_activate', _('User Registration with automatic account activation')),
3147
3148 ('hg.password_reset.enabled', _('Password reset enabled')),
3149 ('hg.password_reset.hidden', _('Password reset hidden')),
3150 ('hg.password_reset.disabled', _('Password reset disabled')),
3151
3152 ('hg.extern_activate.manual', _('Manual activation of external account')),
3153 ('hg.extern_activate.auto', _('Automatic activation of external account')),
3154
3155 ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')),
3156 ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')),
3157 ]
3158
3159 # definition of system default permissions for DEFAULT user, created on
3160 # system setup
3161 DEFAULT_USER_PERMISSIONS = [
3162 # object perms
3163 'repository.read',
3164 'group.read',
3165 'usergroup.read',
3166 # branch, for backward compat we need same value as before so forced pushed
3167 'branch.push_force',
3168 # global
3169 'hg.create.repository',
3170 'hg.repogroup.create.false',
3171 'hg.usergroup.create.false',
3172 'hg.create.write_on_repogroup.true',
3173 'hg.fork.repository',
3174 'hg.register.manual_activate',
3175 'hg.password_reset.enabled',
3176 'hg.extern_activate.auto',
3177 'hg.inherit_default_perms.true',
3178 ]
3179
3180 # defines which permissions are more important higher the more important
3181 # Weight defines which permissions are more important.
3182 # The higher number the more important.
3183 PERM_WEIGHTS = {
3184 'repository.none': 0,
3185 'repository.read': 1,
3186 'repository.write': 3,
3187 'repository.admin': 4,
3188
3189 'group.none': 0,
3190 'group.read': 1,
3191 'group.write': 3,
3192 'group.admin': 4,
3193
3194 'usergroup.none': 0,
3195 'usergroup.read': 1,
3196 'usergroup.write': 3,
3197 'usergroup.admin': 4,
3198
3199 'branch.none': 0,
3200 'branch.merge': 1,
3201 'branch.push': 3,
3202 'branch.push_force': 4,
3203
3204 'hg.repogroup.create.false': 0,
3205 'hg.repogroup.create.true': 1,
3206
3207 'hg.usergroup.create.false': 0,
3208 'hg.usergroup.create.true': 1,
3209
3210 'hg.fork.none': 0,
3211 'hg.fork.repository': 1,
3212 'hg.create.none': 0,
3213 'hg.create.repository': 1
3214 }
3215
3216 permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3217 permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)
3218 permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)
3219
3220 def __unicode__(self):
3221 return u"<%s('%s:%s')>" % (
3222 self.__class__.__name__, self.permission_id, self.permission_name
3223 )
3224
3225 @classmethod
3226 def get_by_key(cls, key):
3227 return cls.query().filter(cls.permission_name == key).scalar()
3228
3229 @classmethod
3230 def get_default_repo_perms(cls, user_id, repo_id=None):
3231 q = Session().query(UserRepoToPerm, Repository, Permission)\
3232 .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\
3233 .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\
3234 .filter(UserRepoToPerm.user_id == user_id)
3235 if repo_id:
3236 q = q.filter(UserRepoToPerm.repository_id == repo_id)
3237 return q.all()
3238
3239 @classmethod
3240 def get_default_repo_branch_perms(cls, user_id, repo_id=None):
3241 q = Session().query(UserToRepoBranchPermission, UserRepoToPerm, Permission) \
3242 .join(
3243 Permission,
3244 UserToRepoBranchPermission.permission_id == Permission.permission_id) \
3245 .join(
3246 UserRepoToPerm,
3247 UserToRepoBranchPermission.rule_to_perm_id == UserRepoToPerm.repo_to_perm_id) \
3248 .filter(UserRepoToPerm.user_id == user_id)
3249
3250 if repo_id:
3251 q = q.filter(UserToRepoBranchPermission.repository_id == repo_id)
3252 return q.order_by(UserToRepoBranchPermission.rule_order).all()
3253
3254 @classmethod
3255 def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None):
3256 q = Session().query(UserGroupRepoToPerm, Repository, Permission)\
3257 .join(
3258 Permission,
3259 UserGroupRepoToPerm.permission_id == Permission.permission_id)\
3260 .join(
3261 Repository,
3262 UserGroupRepoToPerm.repository_id == Repository.repo_id)\
3263 .join(
3264 UserGroup,
3265 UserGroupRepoToPerm.users_group_id ==
3266 UserGroup.users_group_id)\
3267 .join(
3268 UserGroupMember,
3269 UserGroupRepoToPerm.users_group_id ==
3270 UserGroupMember.users_group_id)\
3271 .filter(
3272 UserGroupMember.user_id == user_id,
3273 UserGroup.users_group_active == true())
3274 if repo_id:
3275 q = q.filter(UserGroupRepoToPerm.repository_id == repo_id)
3276 return q.all()
3277
3278 @classmethod
3279 def get_default_repo_branch_perms_from_user_group(cls, user_id, repo_id=None):
3280 q = Session().query(UserGroupToRepoBranchPermission, UserGroupRepoToPerm, Permission) \
3281 .join(
3282 Permission,
3283 UserGroupToRepoBranchPermission.permission_id == Permission.permission_id) \
3284 .join(
3285 UserGroupRepoToPerm,
3286 UserGroupToRepoBranchPermission.rule_to_perm_id == UserGroupRepoToPerm.users_group_to_perm_id) \
3287 .join(
3288 UserGroup,
3289 UserGroupRepoToPerm.users_group_id == UserGroup.users_group_id) \
3290 .join(
3291 UserGroupMember,
3292 UserGroupRepoToPerm.users_group_id == UserGroupMember.users_group_id) \
3293 .filter(
3294 UserGroupMember.user_id == user_id,
3295 UserGroup.users_group_active == true())
3296
3297 if repo_id:
3298 q = q.filter(UserGroupToRepoBranchPermission.repository_id == repo_id)
3299 return q.order_by(UserGroupToRepoBranchPermission.rule_order).all()
3300
3301 @classmethod
3302 def get_default_group_perms(cls, user_id, repo_group_id=None):
3303 q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\
3304 .join(
3305 Permission,
3306 UserRepoGroupToPerm.permission_id == Permission.permission_id)\
3307 .join(
3308 RepoGroup,
3309 UserRepoGroupToPerm.group_id == RepoGroup.group_id)\
3310 .filter(UserRepoGroupToPerm.user_id == user_id)
3311 if repo_group_id:
3312 q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id)
3313 return q.all()
3314
3315 @classmethod
3316 def get_default_group_perms_from_user_group(
3317 cls, user_id, repo_group_id=None):
3318 q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\
3319 .join(
3320 Permission,
3321 UserGroupRepoGroupToPerm.permission_id ==
3322 Permission.permission_id)\
3323 .join(
3324 RepoGroup,
3325 UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\
3326 .join(
3327 UserGroup,
3328 UserGroupRepoGroupToPerm.users_group_id ==
3329 UserGroup.users_group_id)\
3330 .join(
3331 UserGroupMember,
3332 UserGroupRepoGroupToPerm.users_group_id ==
3333 UserGroupMember.users_group_id)\
3334 .filter(
3335 UserGroupMember.user_id == user_id,
3336 UserGroup.users_group_active == true())
3337 if repo_group_id:
3338 q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id)
3339 return q.all()
3340
3341 @classmethod
3342 def get_default_user_group_perms(cls, user_id, user_group_id=None):
3343 q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\
3344 .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\
3345 .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\
3346 .filter(UserUserGroupToPerm.user_id == user_id)
3347 if user_group_id:
3348 q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id)
3349 return q.all()
3350
3351 @classmethod
3352 def get_default_user_group_perms_from_user_group(
3353 cls, user_id, user_group_id=None):
3354 TargetUserGroup = aliased(UserGroup, name='target_user_group')
3355 q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\
3356 .join(
3357 Permission,
3358 UserGroupUserGroupToPerm.permission_id ==
3359 Permission.permission_id)\
3360 .join(
3361 TargetUserGroup,
3362 UserGroupUserGroupToPerm.target_user_group_id ==
3363 TargetUserGroup.users_group_id)\
3364 .join(
3365 UserGroup,
3366 UserGroupUserGroupToPerm.user_group_id ==
3367 UserGroup.users_group_id)\
3368 .join(
3369 UserGroupMember,
3370 UserGroupUserGroupToPerm.user_group_id ==
3371 UserGroupMember.users_group_id)\
3372 .filter(
3373 UserGroupMember.user_id == user_id,
3374 UserGroup.users_group_active == true())
3375 if user_group_id:
3376 q = q.filter(
3377 UserGroupUserGroupToPerm.user_group_id == user_group_id)
3378
3379 return q.all()
3380
3381
3382 class UserRepoToPerm(Base, BaseModel):
3383 __tablename__ = 'repo_to_perm'
3384 __table_args__ = (
3385 UniqueConstraint('user_id', 'repository_id', 'permission_id'),
3386 base_table_args
3387 )
3388
3389 repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3390 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3391 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3392 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
3393
3394 user = relationship('User')
3395 repository = relationship('Repository')
3396 permission = relationship('Permission')
3397
3398 branch_perm_entry = relationship('UserToRepoBranchPermission', cascade="all, delete-orphan", lazy='joined')
3399
3400 @classmethod
3401 def create(cls, user, repository, permission):
3402 n = cls()
3403 n.user = user
3404 n.repository = repository
3405 n.permission = permission
3406 Session().add(n)
3407 return n
3408
3409 def __unicode__(self):
3410 return u'<%s => %s >' % (self.user, self.repository)
3411
3412
3413 class UserUserGroupToPerm(Base, BaseModel):
3414 __tablename__ = 'user_user_group_to_perm'
3415 __table_args__ = (
3416 UniqueConstraint('user_id', 'user_group_id', 'permission_id'),
3417 base_table_args
3418 )
3419
3420 user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3421 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3422 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3423 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3424
3425 user = relationship('User')
3426 user_group = relationship('UserGroup')
3427 permission = relationship('Permission')
3428
3429 @classmethod
3430 def create(cls, user, user_group, permission):
3431 n = cls()
3432 n.user = user
3433 n.user_group = user_group
3434 n.permission = permission
3435 Session().add(n)
3436 return n
3437
3438 def __unicode__(self):
3439 return u'<%s => %s >' % (self.user, self.user_group)
3440
3441
3442 class UserToPerm(Base, BaseModel):
3443 __tablename__ = 'user_to_perm'
3444 __table_args__ = (
3445 UniqueConstraint('user_id', 'permission_id'),
3446 base_table_args
3447 )
3448
3449 user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3450 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3451 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3452
3453 user = relationship('User')
3454 permission = relationship('Permission', lazy='joined')
3455
3456 def __unicode__(self):
3457 return u'<%s => %s >' % (self.user, self.permission)
3458
3459
3460 class UserGroupRepoToPerm(Base, BaseModel):
3461 __tablename__ = 'users_group_repo_to_perm'
3462 __table_args__ = (
3463 UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
3464 base_table_args
3465 )
3466
3467 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3468 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3469 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3470 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
3471
3472 users_group = relationship('UserGroup')
3473 permission = relationship('Permission')
3474 repository = relationship('Repository')
3475 user_group_branch_perms = relationship('UserGroupToRepoBranchPermission', cascade='all')
3476
3477 @classmethod
3478 def create(cls, users_group, repository, permission):
3479 n = cls()
3480 n.users_group = users_group
3481 n.repository = repository
3482 n.permission = permission
3483 Session().add(n)
3484 return n
3485
3486 def __unicode__(self):
3487 return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)
3488
3489
3490 class UserGroupUserGroupToPerm(Base, BaseModel):
3491 __tablename__ = 'user_group_user_group_to_perm'
3492 __table_args__ = (
3493 UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),
3494 CheckConstraint('target_user_group_id != user_group_id'),
3495 base_table_args
3496 )
3497
3498 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)
3499 target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3500 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3501 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3502
3503 target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')
3504 user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')
3505 permission = relationship('Permission')
3506
3507 @classmethod
3508 def create(cls, target_user_group, user_group, permission):
3509 n = cls()
3510 n.target_user_group = target_user_group
3511 n.user_group = user_group
3512 n.permission = permission
3513 Session().add(n)
3514 return n
3515
3516 def __unicode__(self):
3517 return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)
3518
3519
3520 class UserGroupToPerm(Base, BaseModel):
3521 __tablename__ = 'users_group_to_perm'
3522 __table_args__ = (
3523 UniqueConstraint('users_group_id', 'permission_id',),
3524 base_table_args
3525 )
3526
3527 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3528 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3529 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3530
3531 users_group = relationship('UserGroup')
3532 permission = relationship('Permission')
3533
3534
3535 class UserRepoGroupToPerm(Base, BaseModel):
3536 __tablename__ = 'user_repo_group_to_perm'
3537 __table_args__ = (
3538 UniqueConstraint('user_id', 'group_id', 'permission_id'),
3539 base_table_args
3540 )
3541
3542 group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3543 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3544 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
3545 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3546
3547 user = relationship('User')
3548 group = relationship('RepoGroup')
3549 permission = relationship('Permission')
3550
3551 @classmethod
3552 def create(cls, user, repository_group, permission):
3553 n = cls()
3554 n.user = user
3555 n.group = repository_group
3556 n.permission = permission
3557 Session().add(n)
3558 return n
3559
3560
3561 class UserGroupRepoGroupToPerm(Base, BaseModel):
3562 __tablename__ = 'users_group_repo_group_to_perm'
3563 __table_args__ = (
3564 UniqueConstraint('users_group_id', 'group_id'),
3565 base_table_args
3566 )
3567
3568 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)
3569 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3570 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
3571 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3572
3573 users_group = relationship('UserGroup')
3574 permission = relationship('Permission')
3575 group = relationship('RepoGroup')
3576
3577 @classmethod
3578 def create(cls, user_group, repository_group, permission):
3579 n = cls()
3580 n.users_group = user_group
3581 n.group = repository_group
3582 n.permission = permission
3583 Session().add(n)
3584 return n
3585
3586 def __unicode__(self):
3587 return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)
3588
3589
3590 class Statistics(Base, BaseModel):
3591 __tablename__ = 'statistics'
3592 __table_args__ = (
3593 base_table_args
3594 )
3595
3596 stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3597 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)
3598 stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)
3599 commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data
3600 commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data
3601 languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data
3602
3603 repository = relationship('Repository', single_parent=True)
3604
3605
3606 class UserFollowing(Base, BaseModel):
3607 __tablename__ = 'user_followings'
3608 __table_args__ = (
3609 UniqueConstraint('user_id', 'follows_repository_id'),
3610 UniqueConstraint('user_id', 'follows_user_id'),
3611 base_table_args
3612 )
3613
3614 user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3615 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3616 follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)
3617 follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
3618 follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
3619
3620 user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')
3621
3622 follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')
3623 follows_repository = relationship('Repository', order_by='Repository.repo_name')
3624
3625 @classmethod
3626 def get_repo_followers(cls, repo_id):
3627 return cls.query().filter(cls.follows_repo_id == repo_id)
3628
3629
3630 class CacheKey(Base, BaseModel):
3631 __tablename__ = 'cache_invalidation'
3632 __table_args__ = (
3633 UniqueConstraint('cache_key'),
3634 Index('key_idx', 'cache_key'),
3635 base_table_args,
3636 )
3637
3638 CACHE_TYPE_FEED = 'FEED'
3639
3640 # namespaces used to register process/thread aware caches
3641 REPO_INVALIDATION_NAMESPACE = 'repo_cache:{repo_id}'
3642 SETTINGS_INVALIDATION_NAMESPACE = 'system_settings'
3643
3644 cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3645 cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None)
3646 cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None)
3647 cache_state_uid = Column("cache_state_uid", String(255), nullable=True, unique=None, default=None)
3648 cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)
3649
3650 def __init__(self, cache_key, cache_args='', cache_state_uid=None):
3651 self.cache_key = cache_key
3652 self.cache_args = cache_args
3653 self.cache_active = False
3654 # first key should be same for all entries, since all workers should share it
3655 self.cache_state_uid = cache_state_uid or self.generate_new_state_uid()
3656
3657 def __unicode__(self):
3658 return u"<%s('%s:%s[%s]')>" % (
3659 self.__class__.__name__,
3660 self.cache_id, self.cache_key, self.cache_active)
3661
3662 def _cache_key_partition(self):
3663 prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)
3664 return prefix, repo_name, suffix
3665
3666 def get_prefix(self):
3667 """
3668 Try to extract prefix from existing cache key. The key could consist
3669 of prefix, repo_name, suffix
3670 """
3671 # this returns prefix, repo_name, suffix
3672 return self._cache_key_partition()[0]
3673
3674 def get_suffix(self):
3675 """
3676 get suffix that might have been used in _get_cache_key to
3677 generate self.cache_key. Only used for informational purposes
3678 in repo_edit.mako.
3679 """
3680 # prefix, repo_name, suffix
3681 return self._cache_key_partition()[2]
3682
3683 @classmethod
3684 def generate_new_state_uid(cls, based_on=None):
3685 if based_on:
3686 return str(uuid.uuid5(uuid.NAMESPACE_URL, safe_str(based_on)))
3687 else:
3688 return str(uuid.uuid4())
3689
3690 @classmethod
3691 def delete_all_cache(cls):
3692 """
3693 Delete all cache keys from database.
3694 Should only be run when all instances are down and all entries
3695 thus stale.
3696 """
3697 cls.query().delete()
3698 Session().commit()
3699
3700 @classmethod
3701 def set_invalidate(cls, cache_uid, delete=False):
3702 """
3703 Mark all caches of a repo as invalid in the database.
3704 """
3705
3706 try:
3707 qry = Session().query(cls).filter(cls.cache_args == cache_uid)
3708 if delete:
3709 qry.delete()
3710 log.debug('cache objects deleted for cache args %s',
3711 safe_str(cache_uid))
3712 else:
3713 qry.update({"cache_active": False,
3714 "cache_state_uid": cls.generate_new_state_uid()})
3715 log.debug('cache objects marked as invalid for cache args %s',
3716 safe_str(cache_uid))
3717
3718 Session().commit()
3719 except Exception:
3720 log.exception(
3721 'Cache key invalidation failed for cache args %s',
3722 safe_str(cache_uid))
3723 Session().rollback()
3724
3725 @classmethod
3726 def get_active_cache(cls, cache_key):
3727 inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()
3728 if inv_obj:
3729 return inv_obj
3730 return None
3731
3732 @classmethod
3733 def get_namespace_map(cls, namespace):
3734 return {
3735 x.cache_key: x
3736 for x in cls.query().filter(cls.cache_args == namespace)}
3737
3738
3739 class ChangesetComment(Base, BaseModel):
3740 __tablename__ = 'changeset_comments'
3741 __table_args__ = (
3742 Index('cc_revision_idx', 'revision'),
3743 base_table_args,
3744 )
3745
3746 COMMENT_OUTDATED = u'comment_outdated'
3747 COMMENT_TYPE_NOTE = u'note'
3748 COMMENT_TYPE_TODO = u'todo'
3749 COMMENT_TYPES = [COMMENT_TYPE_NOTE, COMMENT_TYPE_TODO]
3750
3751 OP_IMMUTABLE = u'immutable'
3752 OP_CHANGEABLE = u'changeable'
3753
3754 comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)
3755 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
3756 revision = Column('revision', String(40), nullable=True)
3757 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
3758 pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True)
3759 line_no = Column('line_no', Unicode(10), nullable=True)
3760 hl_lines = Column('hl_lines', Unicode(512), nullable=True)
3761 f_path = Column('f_path', Unicode(1000), nullable=True)
3762 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
3763 text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)
3764 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3765 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3766 renderer = Column('renderer', Unicode(64), nullable=True)
3767 display_state = Column('display_state', Unicode(128), nullable=True)
3768 immutable_state = Column('immutable_state', Unicode(128), nullable=True, default=OP_CHANGEABLE)
3769
3770 comment_type = Column('comment_type', Unicode(128), nullable=True, default=COMMENT_TYPE_NOTE)
3771 resolved_comment_id = Column('resolved_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=True)
3772
3773 resolved_comment = relationship('ChangesetComment', remote_side=comment_id, back_populates='resolved_by')
3774 resolved_by = relationship('ChangesetComment', back_populates='resolved_comment')
3775
3776 author = relationship('User', lazy='joined')
3777 repo = relationship('Repository')
3778 status_change = relationship('ChangesetStatus', cascade="all, delete-orphan", lazy='joined')
3779 pull_request = relationship('PullRequest', lazy='joined')
3780 pull_request_version = relationship('PullRequestVersion')
3781 history = relationship('ChangesetCommentHistory', cascade='all, delete-orphan', lazy='joined', order_by='ChangesetCommentHistory.version')
3782
3783 @classmethod
3784 def get_users(cls, revision=None, pull_request_id=None):
3785 """
3786 Returns user associated with this ChangesetComment. ie those
3787 who actually commented
3788
3789 :param cls:
3790 :param revision:
3791 """
3792 q = Session().query(User)\
3793 .join(ChangesetComment.author)
3794 if revision:
3795 q = q.filter(cls.revision == revision)
3796 elif pull_request_id:
3797 q = q.filter(cls.pull_request_id == pull_request_id)
3798 return q.all()
3799
3800 @classmethod
3801 def get_index_from_version(cls, pr_version, versions):
3802 num_versions = [x.pull_request_version_id for x in versions]
3803 try:
3804 return num_versions.index(pr_version) + 1
3805 except (IndexError, ValueError):
3806 return
3807
3808 @property
3809 def outdated(self):
3810 return self.display_state == self.COMMENT_OUTDATED
3811
3812 @property
3813 def immutable(self):
3814 return self.immutable_state == self.OP_IMMUTABLE
3815
3816 def outdated_at_version(self, version):
3817 """
3818 Checks if comment is outdated for given pull request version
3819 """
3820 return self.outdated and self.pull_request_version_id != version
3821
3822 def older_than_version(self, version):
3823 """
3824 Checks if comment is made from previous version than given
3825 """
3826 if version is None:
3827 return self.pull_request_version_id is not None
3828
3829 return self.pull_request_version_id < version
3830
3831 @property
3832 def commit_id(self):
3833 """New style naming to stop using .revision"""
3834 return self.revision
3835
3836 @property
3837 def resolved(self):
3838 return self.resolved_by[0] if self.resolved_by else None
3839
3840 @property
3841 def is_todo(self):
3842 return self.comment_type == self.COMMENT_TYPE_TODO
3843
3844 @property
3845 def is_inline(self):
3846 return self.line_no and self.f_path
3847
3848 @property
3849 def last_version(self):
3850 version = 0
3851 if self.history:
3852 version = self.history[-1].version
3853 return version
3854
3855 def get_index_version(self, versions):
3856 return self.get_index_from_version(
3857 self.pull_request_version_id, versions)
3858
3859 def __repr__(self):
3860 if self.comment_id:
3861 return '<DB:Comment #%s>' % self.comment_id
3862 else:
3863 return '<DB:Comment at %#x>' % id(self)
3864
3865 def get_api_data(self):
3866 comment = self
3867
3868 data = {
3869 'comment_id': comment.comment_id,
3870 'comment_type': comment.comment_type,
3871 'comment_text': comment.text,
3872 'comment_status': comment.status_change,
3873 'comment_f_path': comment.f_path,
3874 'comment_lineno': comment.line_no,
3875 'comment_author': comment.author,
3876 'comment_created_on': comment.created_on,
3877 'comment_resolved_by': self.resolved,
3878 'comment_commit_id': comment.revision,
3879 'comment_pull_request_id': comment.pull_request_id,
3880 'comment_last_version': self.last_version
3881 }
3882 return data
3883
3884 def __json__(self):
3885 data = dict()
3886 data.update(self.get_api_data())
3887 return data
3888
3889
3890 class ChangesetCommentHistory(Base, BaseModel):
3891 __tablename__ = 'changeset_comments_history'
3892 __table_args__ = (
3893 Index('cch_comment_id_idx', 'comment_id'),
3894 base_table_args,
3895 )
3896
3897 comment_history_id = Column('comment_history_id', Integer(), nullable=False, primary_key=True)
3898 comment_id = Column('comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=False)
3899 version = Column("version", Integer(), nullable=False, default=0)
3900 created_by_user_id = Column('created_by_user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
3901 text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)
3902 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3903 deleted = Column('deleted', Boolean(), default=False)
3904
3905 author = relationship('User', lazy='joined')
3906 comment = relationship('ChangesetComment', cascade="all, delete")
3907
3908 @classmethod
3909 def get_version(cls, comment_id):
3910 q = Session().query(ChangesetCommentHistory).filter(
3911 ChangesetCommentHistory.comment_id == comment_id).order_by(ChangesetCommentHistory.version.desc())
3912 if q.count() == 0:
3913 return 1
3914 elif q.count() >= q[0].version:
3915 return q.count() + 1
3916 else:
3917 return q[0].version + 1
3918
3919
3920 class ChangesetStatus(Base, BaseModel):
3921 __tablename__ = 'changeset_statuses'
3922 __table_args__ = (
3923 Index('cs_revision_idx', 'revision'),
3924 Index('cs_version_idx', 'version'),
3925 UniqueConstraint('repo_id', 'revision', 'version'),
3926 base_table_args
3927 )
3928
3929 STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'
3930 STATUS_APPROVED = 'approved'
3931 STATUS_REJECTED = 'rejected'
3932 STATUS_UNDER_REVIEW = 'under_review'
3933
3934 STATUSES = [
3935 (STATUS_NOT_REVIEWED, _("Not Reviewed")), # (no icon) and default
3936 (STATUS_APPROVED, _("Approved")),
3937 (STATUS_REJECTED, _("Rejected")),
3938 (STATUS_UNDER_REVIEW, _("Under Review")),
3939 ]
3940
3941 changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)
3942 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
3943 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)
3944 revision = Column('revision', String(40), nullable=False)
3945 status = Column('status', String(128), nullable=False, default=DEFAULT)
3946 changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))
3947 modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)
3948 version = Column('version', Integer(), nullable=False, default=0)
3949 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
3950
3951 author = relationship('User', lazy='joined')
3952 repo = relationship('Repository')
3953 comment = relationship('ChangesetComment', lazy='joined')
3954 pull_request = relationship('PullRequest', lazy='joined')
3955
3956 def __unicode__(self):
3957 return u"<%s('%s[v%s]:%s')>" % (
3958 self.__class__.__name__,
3959 self.status, self.version, self.author
3960 )
3961
3962 @classmethod
3963 def get_status_lbl(cls, value):
3964 return dict(cls.STATUSES).get(value)
3965
3966 @property
3967 def status_lbl(self):
3968 return ChangesetStatus.get_status_lbl(self.status)
3969
3970 def get_api_data(self):
3971 status = self
3972 data = {
3973 'status_id': status.changeset_status_id,
3974 'status': status.status,
3975 }
3976 return data
3977
3978 def __json__(self):
3979 data = dict()
3980 data.update(self.get_api_data())
3981 return data
3982
3983
3984 class _SetState(object):
3985 """
3986 Context processor allowing changing state for sensitive operation such as
3987 pull request update or merge
3988 """
3989
3990 def __init__(self, pull_request, pr_state, back_state=None):
3991 self._pr = pull_request
3992 self._org_state = back_state or pull_request.pull_request_state
3993 self._pr_state = pr_state
3994 self._current_state = None
3995
3996 def __enter__(self):
3997 log.debug('StateLock: entering set state context of pr %s, setting state to: `%s`',
3998 self._pr, self._pr_state)
3999 self.set_pr_state(self._pr_state)
4000 return self
4001
4002 def __exit__(self, exc_type, exc_val, exc_tb):
4003 if exc_val is not None:
4004 log.error(traceback.format_exc(exc_tb))
4005 return None
4006
4007 self.set_pr_state(self._org_state)
4008 log.debug('StateLock: exiting set state context of pr %s, setting state to: `%s`',
4009 self._pr, self._org_state)
4010
4011 @property
4012 def state(self):
4013 return self._current_state
4014
4015 def set_pr_state(self, pr_state):
4016 try:
4017 self._pr.pull_request_state = pr_state
4018 Session().add(self._pr)
4019 Session().commit()
4020 self._current_state = pr_state
4021 except Exception:
4022 log.exception('Failed to set PullRequest %s state to %s', self._pr, pr_state)
4023 raise
4024
4025
4026 class _PullRequestBase(BaseModel):
4027 """
4028 Common attributes of pull request and version entries.
4029 """
4030
4031 # .status values
4032 STATUS_NEW = u'new'
4033 STATUS_OPEN = u'open'
4034 STATUS_CLOSED = u'closed'
4035
4036 # available states
4037 STATE_CREATING = u'creating'
4038 STATE_UPDATING = u'updating'
4039 STATE_MERGING = u'merging'
4040 STATE_CREATED = u'created'
4041
4042 title = Column('title', Unicode(255), nullable=True)
4043 description = Column(
4044 'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),
4045 nullable=True)
4046 description_renderer = Column('description_renderer', Unicode(64), nullable=True)
4047
4048 # new/open/closed status of pull request (not approve/reject/etc)
4049 status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW)
4050 created_on = Column(
4051 'created_on', DateTime(timezone=False), nullable=False,
4052 default=datetime.datetime.now)
4053 updated_on = Column(
4054 'updated_on', DateTime(timezone=False), nullable=False,
4055 default=datetime.datetime.now)
4056
4057 pull_request_state = Column("pull_request_state", String(255), nullable=True)
4058
4059 @declared_attr
4060 def user_id(cls):
4061 return Column(
4062 "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
4063 unique=None)
4064
4065 # 500 revisions max
4066 _revisions = Column(
4067 'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql'))
4068
4069 common_ancestor_id = Column('common_ancestor_id', Unicode(255), nullable=True)
4070
4071 @declared_attr
4072 def source_repo_id(cls):
4073 # TODO: dan: rename column to source_repo_id
4074 return Column(
4075 'org_repo_id', Integer(), ForeignKey('repositories.repo_id'),
4076 nullable=False)
4077
4078 _source_ref = Column('org_ref', Unicode(255), nullable=False)
4079
4080 @hybrid_property
4081 def source_ref(self):
4082 return self._source_ref
4083
4084 @source_ref.setter
4085 def source_ref(self, val):
4086 parts = (val or '').split(':')
4087 if len(parts) != 3:
4088 raise ValueError(
4089 'Invalid reference format given: {}, expected X:Y:Z'.format(val))
4090 self._source_ref = safe_unicode(val)
4091
4092 _target_ref = Column('other_ref', Unicode(255), nullable=False)
4093
4094 @hybrid_property
4095 def target_ref(self):
4096 return self._target_ref
4097
4098 @target_ref.setter
4099 def target_ref(self, val):
4100 parts = (val or '').split(':')
4101 if len(parts) != 3:
4102 raise ValueError(
4103 'Invalid reference format given: {}, expected X:Y:Z'.format(val))
4104 self._target_ref = safe_unicode(val)
4105
4106 @declared_attr
4107 def target_repo_id(cls):
4108 # TODO: dan: rename column to target_repo_id
4109 return Column(
4110 'other_repo_id', Integer(), ForeignKey('repositories.repo_id'),
4111 nullable=False)
4112
4113 _shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True)
4114
4115 # TODO: dan: rename column to last_merge_source_rev
4116 _last_merge_source_rev = Column(
4117 'last_merge_org_rev', String(40), nullable=True)
4118 # TODO: dan: rename column to last_merge_target_rev
4119 _last_merge_target_rev = Column(
4120 'last_merge_other_rev', String(40), nullable=True)
4121 _last_merge_status = Column('merge_status', Integer(), nullable=True)
4122 last_merge_metadata = Column(
4123 'last_merge_metadata', MutationObj.as_mutable(
4124 JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
4125
4126 merge_rev = Column('merge_rev', String(40), nullable=True)
4127
4128 reviewer_data = Column(
4129 'reviewer_data_json', MutationObj.as_mutable(
4130 JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
4131
4132 @property
4133 def reviewer_data_json(self):
4134 return json.dumps(self.reviewer_data)
4135
4136 @property
4137 def last_merge_metadata_parsed(self):
4138 metadata = {}
4139 if not self.last_merge_metadata:
4140 return metadata
4141
4142 if hasattr(self.last_merge_metadata, 'de_coerce'):
4143 for k, v in self.last_merge_metadata.de_coerce().items():
4144 if k in ['target_ref', 'source_ref']:
4145 metadata[k] = Reference(v['type'], v['name'], v['commit_id'])
4146 else:
4147 if hasattr(v, 'de_coerce'):
4148 metadata[k] = v.de_coerce()
4149 else:
4150 metadata[k] = v
4151 return metadata
4152
4153 @property
4154 def work_in_progress(self):
4155 """checks if pull request is work in progress by checking the title"""
4156 title = self.title.upper()
4157 if re.match(r'^(\[WIP\]\s*|WIP:\s*|WIP\s+)', title):
4158 return True
4159 return False
4160
4161 @hybrid_property
4162 def description_safe(self):
4163 from rhodecode.lib import helpers as h
4164 return h.escape(self.description)
4165
4166 @hybrid_property
4167 def revisions(self):
4168 return self._revisions.split(':') if self._revisions else []
4169
4170 @revisions.setter
4171 def revisions(self, val):
4172 self._revisions = u':'.join(val)
4173
4174 @hybrid_property
4175 def last_merge_status(self):
4176 return safe_int(self._last_merge_status)
4177
4178 @last_merge_status.setter
4179 def last_merge_status(self, val):
4180 self._last_merge_status = val
4181
4182 @declared_attr
4183 def author(cls):
4184 return relationship('User', lazy='joined')
4185
4186 @declared_attr
4187 def source_repo(cls):
4188 return relationship(
4189 'Repository',
4190 primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__)
4191
4192 @property
4193 def source_ref_parts(self):
4194 return self.unicode_to_reference(self.source_ref)
4195
4196 @declared_attr
4197 def target_repo(cls):
4198 return relationship(
4199 'Repository',
4200 primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__)
4201
4202 @property
4203 def target_ref_parts(self):
4204 return self.unicode_to_reference(self.target_ref)
4205
4206 @property
4207 def shadow_merge_ref(self):
4208 return self.unicode_to_reference(self._shadow_merge_ref)
4209
4210 @shadow_merge_ref.setter
4211 def shadow_merge_ref(self, ref):
4212 self._shadow_merge_ref = self.reference_to_unicode(ref)
4213
4214 @staticmethod
4215 def unicode_to_reference(raw):
4216 """
4217 Convert a unicode (or string) to a reference object.
4218 If unicode evaluates to False it returns None.
4219 """
4220 if raw:
4221 refs = raw.split(':')
4222 return Reference(*refs)
4223 else:
4224 return None
4225
4226 @staticmethod
4227 def reference_to_unicode(ref):
4228 """
4229 Convert a reference object to unicode.
4230 If reference is None it returns None.
4231 """
4232 if ref:
4233 return u':'.join(ref)
4234 else:
4235 return None
4236
4237 def get_api_data(self, with_merge_state=True):
4238 from rhodecode.model.pull_request import PullRequestModel
4239
4240 pull_request = self
4241 if with_merge_state:
4242 merge_response, merge_status, msg = \
4243 PullRequestModel().merge_status(pull_request)
4244 merge_state = {
4245 'status': merge_status,
4246 'message': safe_unicode(msg),
4247 }
4248 else:
4249 merge_state = {'status': 'not_available',
4250 'message': 'not_available'}
4251
4252 merge_data = {
4253 'clone_url': PullRequestModel().get_shadow_clone_url(pull_request),
4254 'reference': (
4255 pull_request.shadow_merge_ref._asdict()
4256 if pull_request.shadow_merge_ref else None),
4257 }
4258
4259 data = {
4260 'pull_request_id': pull_request.pull_request_id,
4261 'url': PullRequestModel().get_url(pull_request),
4262 'title': pull_request.title,
4263 'description': pull_request.description,
4264 'status': pull_request.status,
4265 'state': pull_request.pull_request_state,
4266 'created_on': pull_request.created_on,
4267 'updated_on': pull_request.updated_on,
4268 'commit_ids': pull_request.revisions,
4269 'review_status': pull_request.calculated_review_status(),
4270 'mergeable': merge_state,
4271 'source': {
4272 'clone_url': pull_request.source_repo.clone_url(),
4273 'repository': pull_request.source_repo.repo_name,
4274 'reference': {
4275 'name': pull_request.source_ref_parts.name,
4276 'type': pull_request.source_ref_parts.type,
4277 'commit_id': pull_request.source_ref_parts.commit_id,
4278 },
4279 },
4280 'target': {
4281 'clone_url': pull_request.target_repo.clone_url(),
4282 'repository': pull_request.target_repo.repo_name,
4283 'reference': {
4284 'name': pull_request.target_ref_parts.name,
4285 'type': pull_request.target_ref_parts.type,
4286 'commit_id': pull_request.target_ref_parts.commit_id,
4287 },
4288 },
4289 'merge': merge_data,
4290 'author': pull_request.author.get_api_data(include_secrets=False,
4291 details='basic'),
4292 'reviewers': [
4293 {
4294 'user': reviewer.get_api_data(include_secrets=False,
4295 details='basic'),
4296 'reasons': reasons,
4297 'review_status': st[0][1].status if st else 'not_reviewed',
4298 }
4299 for obj, reviewer, reasons, mandatory, st in
4300 pull_request.reviewers_statuses()
4301 ]
4302 }
4303
4304 return data
4305
4306 def set_state(self, pull_request_state, final_state=None):
4307 """
4308 # goes from initial state to updating to initial state.
4309 # initial state can be changed by specifying back_state=
4310 with pull_request_obj.set_state(PullRequest.STATE_UPDATING):
4311 pull_request.merge()
4312
4313 :param pull_request_state:
4314 :param final_state:
4315
4316 """
4317
4318 return _SetState(self, pull_request_state, back_state=final_state)
4319
4320
4321 class PullRequest(Base, _PullRequestBase):
4322 __tablename__ = 'pull_requests'
4323 __table_args__ = (
4324 base_table_args,
4325 )
4326
4327 pull_request_id = Column(
4328 'pull_request_id', Integer(), nullable=False, primary_key=True)
4329
4330 def __repr__(self):
4331 if self.pull_request_id:
4332 return '<DB:PullRequest #%s>' % self.pull_request_id
4333 else:
4334 return '<DB:PullRequest at %#x>' % id(self)
4335
4336 reviewers = relationship('PullRequestReviewers', cascade="all, delete-orphan")
4337 statuses = relationship('ChangesetStatus', cascade="all, delete-orphan")
4338 comments = relationship('ChangesetComment', cascade="all, delete-orphan")
4339 versions = relationship('PullRequestVersion', cascade="all, delete-orphan",
4340 lazy='dynamic')
4341
4342 @classmethod
4343 def get_pr_display_object(cls, pull_request_obj, org_pull_request_obj,
4344 internal_methods=None):
4345
4346 class PullRequestDisplay(object):
4347 """
4348 Special object wrapper for showing PullRequest data via Versions
4349 It mimics PR object as close as possible. This is read only object
4350 just for display
4351 """
4352
4353 def __init__(self, attrs, internal=None):
4354 self.attrs = attrs
4355 # internal have priority over the given ones via attrs
4356 self.internal = internal or ['versions']
4357
4358 def __getattr__(self, item):
4359 if item in self.internal:
4360 return getattr(self, item)
4361 try:
4362 return self.attrs[item]
4363 except KeyError:
4364 raise AttributeError(
4365 '%s object has no attribute %s' % (self, item))
4366
4367 def __repr__(self):
4368 return '<DB:PullRequestDisplay #%s>' % self.attrs.get('pull_request_id')
4369
4370 def versions(self):
4371 return pull_request_obj.versions.order_by(
4372 PullRequestVersion.pull_request_version_id).all()
4373
4374 def is_closed(self):
4375 return pull_request_obj.is_closed()
4376
4377 def is_state_changing(self):
4378 return pull_request_obj.is_state_changing()
4379
4380 @property
4381 def pull_request_version_id(self):
4382 return getattr(pull_request_obj, 'pull_request_version_id', None)
4383
4384 attrs = StrictAttributeDict(pull_request_obj.get_api_data(with_merge_state=False))
4385
4386 attrs.author = StrictAttributeDict(
4387 pull_request_obj.author.get_api_data())
4388 if pull_request_obj.target_repo:
4389 attrs.target_repo = StrictAttributeDict(
4390 pull_request_obj.target_repo.get_api_data())
4391 attrs.target_repo.clone_url = pull_request_obj.target_repo.clone_url
4392
4393 if pull_request_obj.source_repo:
4394 attrs.source_repo = StrictAttributeDict(
4395 pull_request_obj.source_repo.get_api_data())
4396 attrs.source_repo.clone_url = pull_request_obj.source_repo.clone_url
4397
4398 attrs.source_ref_parts = pull_request_obj.source_ref_parts
4399 attrs.target_ref_parts = pull_request_obj.target_ref_parts
4400 attrs.revisions = pull_request_obj.revisions
4401 attrs.common_ancestor_id = pull_request_obj.common_ancestor_id
4402 attrs.shadow_merge_ref = org_pull_request_obj.shadow_merge_ref
4403 attrs.reviewer_data = org_pull_request_obj.reviewer_data
4404 attrs.reviewer_data_json = org_pull_request_obj.reviewer_data_json
4405
4406 return PullRequestDisplay(attrs, internal=internal_methods)
4407
4408 def is_closed(self):
4409 return self.status == self.STATUS_CLOSED
4410
4411 def is_state_changing(self):
4412 return self.pull_request_state != PullRequest.STATE_CREATED
4413
4414 def __json__(self):
4415 return {
4416 'revisions': self.revisions,
4417 'versions': self.versions_count
4418 }
4419
4420 def calculated_review_status(self):
4421 from rhodecode.model.changeset_status import ChangesetStatusModel
4422 return ChangesetStatusModel().calculated_review_status(self)
4423
4424 def reviewers_statuses(self):
4425 from rhodecode.model.changeset_status import ChangesetStatusModel
4426 return ChangesetStatusModel().reviewers_statuses(self)
4427
4428 @property
4429 def workspace_id(self):
4430 from rhodecode.model.pull_request import PullRequestModel
4431 return PullRequestModel()._workspace_id(self)
4432
4433 def get_shadow_repo(self):
4434 workspace_id = self.workspace_id
4435 shadow_repository_path = self.target_repo.get_shadow_repository_path(workspace_id)
4436 if os.path.isdir(shadow_repository_path):
4437 vcs_obj = self.target_repo.scm_instance()
4438 return vcs_obj.get_shadow_instance(shadow_repository_path)
4439
4440 @property
4441 def versions_count(self):
4442 """
4443 return number of versions this PR have, e.g a PR that once been
4444 updated will have 2 versions
4445 """
4446 return self.versions.count() + 1
4447
4448
4449 class PullRequestVersion(Base, _PullRequestBase):
4450 __tablename__ = 'pull_request_versions'
4451 __table_args__ = (
4452 base_table_args,
4453 )
4454
4455 pull_request_version_id = Column(
4456 'pull_request_version_id', Integer(), nullable=False, primary_key=True)
4457 pull_request_id = Column(
4458 'pull_request_id', Integer(),
4459 ForeignKey('pull_requests.pull_request_id'), nullable=False)
4460 pull_request = relationship('PullRequest')
4461
4462 def __repr__(self):
4463 if self.pull_request_version_id:
4464 return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id
4465 else:
4466 return '<DB:PullRequestVersion at %#x>' % id(self)
4467
4468 @property
4469 def reviewers(self):
4470 return self.pull_request.reviewers
4471
4472 @property
4473 def versions(self):
4474 return self.pull_request.versions
4475
4476 def is_closed(self):
4477 # calculate from original
4478 return self.pull_request.status == self.STATUS_CLOSED
4479
4480 def is_state_changing(self):
4481 return self.pull_request.pull_request_state != PullRequest.STATE_CREATED
4482
4483 def calculated_review_status(self):
4484 return self.pull_request.calculated_review_status()
4485
4486 def reviewers_statuses(self):
4487 return self.pull_request.reviewers_statuses()
4488
4489
4490 class PullRequestReviewers(Base, BaseModel):
4491 __tablename__ = 'pull_request_reviewers'
4492 __table_args__ = (
4493 base_table_args,
4494 )
4495
4496 @hybrid_property
4497 def reasons(self):
4498 if not self._reasons:
4499 return []
4500 return self._reasons
4501
4502 @reasons.setter
4503 def reasons(self, val):
4504 val = val or []
4505 if any(not isinstance(x, compat.string_types) for x in val):
4506 raise Exception('invalid reasons type, must be list of strings')
4507 self._reasons = val
4508
4509 pull_requests_reviewers_id = Column(
4510 'pull_requests_reviewers_id', Integer(), nullable=False,
4511 primary_key=True)
4512 pull_request_id = Column(
4513 "pull_request_id", Integer(),
4514 ForeignKey('pull_requests.pull_request_id'), nullable=False)
4515 user_id = Column(
4516 "user_id", Integer(), ForeignKey('users.user_id'), nullable=True)
4517 _reasons = Column(
4518 'reason', MutationList.as_mutable(
4519 JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))
4520
4521 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
4522 user = relationship('User')
4523 pull_request = relationship('PullRequest')
4524
4525 rule_data = Column(
4526 'rule_data_json',
4527 JsonType(dialect_map=dict(mysql=UnicodeText(16384))))
4528
4529 def rule_user_group_data(self):
4530 """
4531 Returns the voting user group rule data for this reviewer
4532 """
4533
4534 if self.rule_data and 'vote_rule' in self.rule_data:
4535 user_group_data = {}
4536 if 'rule_user_group_entry_id' in self.rule_data:
4537 # means a group with voting rules !
4538 user_group_data['id'] = self.rule_data['rule_user_group_entry_id']
4539 user_group_data['name'] = self.rule_data['rule_name']
4540 user_group_data['vote_rule'] = self.rule_data['vote_rule']
4541
4542 return user_group_data
4543
4544 def __unicode__(self):
4545 return u"<%s('id:%s')>" % (self.__class__.__name__,
4546 self.pull_requests_reviewers_id)
4547
4548
4549 class Notification(Base, BaseModel):
4550 __tablename__ = 'notifications'
4551 __table_args__ = (
4552 Index('notification_type_idx', 'type'),
4553 base_table_args,
4554 )
4555
4556 TYPE_CHANGESET_COMMENT = u'cs_comment'
4557 TYPE_MESSAGE = u'message'
4558 TYPE_MENTION = u'mention'
4559 TYPE_REGISTRATION = u'registration'
4560 TYPE_PULL_REQUEST = u'pull_request'
4561 TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'
4562 TYPE_PULL_REQUEST_UPDATE = u'pull_request_update'
4563
4564 notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)
4565 subject = Column('subject', Unicode(512), nullable=True)
4566 body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)
4567 created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)
4568 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
4569 type_ = Column('type', Unicode(255))
4570
4571 created_by_user = relationship('User')
4572 notifications_to_users = relationship('UserNotification', lazy='joined',
4573 cascade="all, delete-orphan")
4574
4575 @property
4576 def recipients(self):
4577 return [x.user for x in UserNotification.query()\
4578 .filter(UserNotification.notification == self)\
4579 .order_by(UserNotification.user_id.asc()).all()]
4580
4581 @classmethod
4582 def create(cls, created_by, subject, body, recipients, type_=None):
4583 if type_ is None:
4584 type_ = Notification.TYPE_MESSAGE
4585
4586 notification = cls()
4587 notification.created_by_user = created_by
4588 notification.subject = subject
4589 notification.body = body
4590 notification.type_ = type_
4591 notification.created_on = datetime.datetime.now()
4592
4593 # For each recipient link the created notification to his account
4594 for u in recipients:
4595 assoc = UserNotification()
4596 assoc.user_id = u.user_id
4597 assoc.notification = notification
4598
4599 # if created_by is inside recipients mark his notification
4600 # as read
4601 if u.user_id == created_by.user_id:
4602 assoc.read = True
4603 Session().add(assoc)
4604
4605 Session().add(notification)
4606
4607 return notification
4608
4609
4610 class UserNotification(Base, BaseModel):
4611 __tablename__ = 'user_to_notification'
4612 __table_args__ = (
4613 UniqueConstraint('user_id', 'notification_id'),
4614 base_table_args
4615 )
4616
4617 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
4618 notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)
4619 read = Column('read', Boolean, default=False)
4620 sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)
4621
4622 user = relationship('User', lazy="joined")
4623 notification = relationship('Notification', lazy="joined",
4624 order_by=lambda: Notification.created_on.desc(),)
4625
4626 def mark_as_read(self):
4627 self.read = True
4628 Session().add(self)
4629
4630
4631 class UserNotice(Base, BaseModel):
4632 __tablename__ = 'user_notices'
4633 __table_args__ = (
4634 base_table_args
4635 )
4636
4637 NOTIFICATION_TYPE_MESSAGE = 'message'
4638 NOTIFICATION_TYPE_NOTICE = 'notice'
4639
4640 NOTIFICATION_LEVEL_INFO = 'info'
4641 NOTIFICATION_LEVEL_WARNING = 'warning'
4642 NOTIFICATION_LEVEL_ERROR = 'error'
4643
4644 user_notice_id = Column('gist_id', Integer(), primary_key=True)
4645
4646 notice_subject = Column('notice_subject', Unicode(512), nullable=True)
4647 notice_body = Column('notice_body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)
4648
4649 notice_read = Column('notice_read', Boolean, default=False)
4650
4651 notification_level = Column('notification_level', String(1024), default=NOTIFICATION_LEVEL_INFO)
4652 notification_type = Column('notification_type', String(1024), default=NOTIFICATION_TYPE_NOTICE)
4653
4654 notice_created_by = Column('notice_created_by', Integer(), ForeignKey('users.user_id'), nullable=True)
4655 notice_created_on = Column('notice_created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
4656
4657 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'))
4658 user = relationship('User', lazy="joined", primaryjoin='User.user_id==UserNotice.user_id')
4659
4660 @classmethod
4661 def create_for_user(cls, user, subject, body, notice_level=NOTIFICATION_LEVEL_INFO, allow_duplicate=False):
4662
4663 if notice_level not in [cls.NOTIFICATION_LEVEL_ERROR,
4664 cls.NOTIFICATION_LEVEL_WARNING,
4665 cls.NOTIFICATION_LEVEL_INFO]:
4666 return
4667
4668 from rhodecode.model.user import UserModel
4669 user = UserModel().get_user(user)
4670
4671 new_notice = UserNotice()
4672 if not allow_duplicate:
4673 existing_msg = UserNotice().query() \
4674 .filter(UserNotice.user == user) \
4675 .filter(UserNotice.notice_body == body) \
4676 .filter(UserNotice.notice_read == false()) \
4677 .scalar()
4678 if existing_msg:
4679 log.warning('Ignoring duplicate notice for user %s', user)
4680 return
4681
4682 new_notice.user = user
4683 new_notice.notice_subject = subject
4684 new_notice.notice_body = body
4685 new_notice.notification_level = notice_level
4686 Session().add(new_notice)
4687 Session().commit()
4688
4689
4690 class Gist(Base, BaseModel):
4691 __tablename__ = 'gists'
4692 __table_args__ = (
4693 Index('g_gist_access_id_idx', 'gist_access_id'),
4694 Index('g_created_on_idx', 'created_on'),
4695 base_table_args
4696 )
4697
4698 GIST_PUBLIC = u'public'
4699 GIST_PRIVATE = u'private'
4700 DEFAULT_FILENAME = u'gistfile1.txt'
4701
4702 ACL_LEVEL_PUBLIC = u'acl_public'
4703 ACL_LEVEL_PRIVATE = u'acl_private'
4704
4705 gist_id = Column('gist_id', Integer(), primary_key=True)
4706 gist_access_id = Column('gist_access_id', Unicode(250))
4707 gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
4708 gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True)
4709 gist_expires = Column('gist_expires', Float(53), nullable=False)
4710 gist_type = Column('gist_type', Unicode(128), nullable=False)
4711 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
4712 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
4713 acl_level = Column('acl_level', Unicode(128), nullable=True)
4714
4715 owner = relationship('User')
4716
4717 def __repr__(self):
4718 return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)
4719
4720 @hybrid_property
4721 def description_safe(self):
4722 from rhodecode.lib import helpers as h
4723 return h.escape(self.gist_description)
4724
4725 @classmethod
4726 def get_or_404(cls, id_):
4727 from pyramid.httpexceptions import HTTPNotFound
4728
4729 res = cls.query().filter(cls.gist_access_id == id_).scalar()
4730 if not res:
4731 raise HTTPNotFound()
4732 return res
4733
4734 @classmethod
4735 def get_by_access_id(cls, gist_access_id):
4736 return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()
4737
4738 def gist_url(self):
4739 from rhodecode.model.gist import GistModel
4740 return GistModel().get_url(self)
4741
4742 @classmethod
4743 def base_path(cls):
4744 """
4745 Returns base path when all gists are stored
4746
4747 :param cls:
4748 """
4749 from rhodecode.model.gist import GIST_STORE_LOC
4750 q = Session().query(RhodeCodeUi)\
4751 .filter(RhodeCodeUi.ui_key == URL_SEP)
4752 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
4753 return os.path.join(q.one().ui_value, GIST_STORE_LOC)
4754
4755 def get_api_data(self):
4756 """
4757 Common function for generating gist related data for API
4758 """
4759 gist = self
4760 data = {
4761 'gist_id': gist.gist_id,
4762 'type': gist.gist_type,
4763 'access_id': gist.gist_access_id,
4764 'description': gist.gist_description,
4765 'url': gist.gist_url(),
4766 'expires': gist.gist_expires,
4767 'created_on': gist.created_on,
4768 'modified_at': gist.modified_at,
4769 'content': None,
4770 'acl_level': gist.acl_level,
4771 }
4772 return data
4773
4774 def __json__(self):
4775 data = dict(
4776 )
4777 data.update(self.get_api_data())
4778 return data
4779 # SCM functions
4780
4781 def scm_instance(self, **kwargs):
4782 """
4783 Get an instance of VCS Repository
4784
4785 :param kwargs:
4786 """
4787 from rhodecode.model.gist import GistModel
4788 full_repo_path = os.path.join(self.base_path(), self.gist_access_id)
4789 return get_vcs_instance(
4790 repo_path=safe_str(full_repo_path), create=False,
4791 _vcs_alias=GistModel.vcs_backend)
4792
4793
4794 class ExternalIdentity(Base, BaseModel):
4795 __tablename__ = 'external_identities'
4796 __table_args__ = (
4797 Index('local_user_id_idx', 'local_user_id'),
4798 Index('external_id_idx', 'external_id'),
4799 base_table_args
4800 )
4801
4802 external_id = Column('external_id', Unicode(255), default=u'', primary_key=True)
4803 external_username = Column('external_username', Unicode(1024), default=u'')
4804 local_user_id = Column('local_user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
4805 provider_name = Column('provider_name', Unicode(255), default=u'', primary_key=True)
4806 access_token = Column('access_token', String(1024), default=u'')
4807 alt_token = Column('alt_token', String(1024), default=u'')
4808 token_secret = Column('token_secret', String(1024), default=u'')
4809
4810 @classmethod
4811 def by_external_id_and_provider(cls, external_id, provider_name, local_user_id=None):
4812 """
4813 Returns ExternalIdentity instance based on search params
4814
4815 :param external_id:
4816 :param provider_name:
4817 :return: ExternalIdentity
4818 """
4819 query = cls.query()
4820 query = query.filter(cls.external_id == external_id)
4821 query = query.filter(cls.provider_name == provider_name)
4822 if local_user_id:
4823 query = query.filter(cls.local_user_id == local_user_id)
4824 return query.first()
4825
4826 @classmethod
4827 def user_by_external_id_and_provider(cls, external_id, provider_name):
4828 """
4829 Returns User instance based on search params
4830
4831 :param external_id:
4832 :param provider_name:
4833 :return: User
4834 """
4835 query = User.query()
4836 query = query.filter(cls.external_id == external_id)
4837 query = query.filter(cls.provider_name == provider_name)
4838 query = query.filter(User.user_id == cls.local_user_id)
4839 return query.first()
4840
4841 @classmethod
4842 def by_local_user_id(cls, local_user_id):
4843 """
4844 Returns all tokens for user
4845
4846 :param local_user_id:
4847 :return: ExternalIdentity
4848 """
4849 query = cls.query()
4850 query = query.filter(cls.local_user_id == local_user_id)
4851 return query
4852
4853 @classmethod
4854 def load_provider_plugin(cls, plugin_id):
4855 from rhodecode.authentication.base import loadplugin
4856 _plugin_id = 'egg:rhodecode-enterprise-ee#{}'.format(plugin_id)
4857 auth_plugin = loadplugin(_plugin_id)
4858 return auth_plugin
4859
4860
4861 class Integration(Base, BaseModel):
4862 __tablename__ = 'integrations'
4863 __table_args__ = (
4864 base_table_args
4865 )
4866
4867 integration_id = Column('integration_id', Integer(), primary_key=True)
4868 integration_type = Column('integration_type', String(255))
4869 enabled = Column('enabled', Boolean(), nullable=False)
4870 name = Column('name', String(255), nullable=False)
4871 child_repos_only = Column('child_repos_only', Boolean(), nullable=False,
4872 default=False)
4873
4874 settings = Column(
4875 'settings_json', MutationObj.as_mutable(
4876 JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
4877 repo_id = Column(
4878 'repo_id', Integer(), ForeignKey('repositories.repo_id'),
4879 nullable=True, unique=None, default=None)
4880 repo = relationship('Repository', lazy='joined')
4881
4882 repo_group_id = Column(
4883 'repo_group_id', Integer(), ForeignKey('groups.group_id'),
4884 nullable=True, unique=None, default=None)
4885 repo_group = relationship('RepoGroup', lazy='joined')
4886
4887 @property
4888 def scope(self):
4889 if self.repo:
4890 return repr(self.repo)
4891 if self.repo_group:
4892 if self.child_repos_only:
4893 return repr(self.repo_group) + ' (child repos only)'
4894 else:
4895 return repr(self.repo_group) + ' (recursive)'
4896 if self.child_repos_only:
4897 return 'root_repos'
4898 return 'global'
4899
4900 def __repr__(self):
4901 return '<Integration(%r, %r)>' % (self.integration_type, self.scope)
4902
4903
4904 class RepoReviewRuleUser(Base, BaseModel):
4905 __tablename__ = 'repo_review_rules_users'
4906 __table_args__ = (
4907 base_table_args
4908 )
4909
4910 repo_review_rule_user_id = Column('repo_review_rule_user_id', Integer(), primary_key=True)
4911 repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
4912 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False)
4913 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
4914 user = relationship('User')
4915
4916 def rule_data(self):
4917 return {
4918 'mandatory': self.mandatory
4919 }
4920
4921
4922 class RepoReviewRuleUserGroup(Base, BaseModel):
4923 __tablename__ = 'repo_review_rules_users_groups'
4924 __table_args__ = (
4925 base_table_args
4926 )
4927
4928 VOTE_RULE_ALL = -1
4929
4930 repo_review_rule_users_group_id = Column('repo_review_rule_users_group_id', Integer(), primary_key=True)
4931 repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
4932 users_group_id = Column("users_group_id", Integer(),ForeignKey('users_groups.users_group_id'), nullable=False)
4933 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
4934 vote_rule = Column("vote_rule", Integer(), nullable=True, default=VOTE_RULE_ALL)
4935 users_group = relationship('UserGroup')
4936
4937 def rule_data(self):
4938 return {
4939 'mandatory': self.mandatory,
4940 'vote_rule': self.vote_rule
4941 }
4942
4943 @property
4944 def vote_rule_label(self):
4945 if not self.vote_rule or self.vote_rule == self.VOTE_RULE_ALL:
4946 return 'all must vote'
4947 else:
4948 return 'min. vote {}'.format(self.vote_rule)
4949
4950
4951 class RepoReviewRule(Base, BaseModel):
4952 __tablename__ = 'repo_review_rules'
4953 __table_args__ = (
4954 base_table_args
4955 )
4956
4957 repo_review_rule_id = Column(
4958 'repo_review_rule_id', Integer(), primary_key=True)
4959 repo_id = Column(
4960 "repo_id", Integer(), ForeignKey('repositories.repo_id'))
4961 repo = relationship('Repository', backref='review_rules')
4962
4963 review_rule_name = Column('review_rule_name', String(255))
4964 _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob
4965 _target_branch_pattern = Column("target_branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob
4966 _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob
4967
4968 use_authors_for_review = Column("use_authors_for_review", Boolean(), nullable=False, default=False)
4969 forbid_author_to_review = Column("forbid_author_to_review", Boolean(), nullable=False, default=False)
4970 forbid_commit_author_to_review = Column("forbid_commit_author_to_review", Boolean(), nullable=False, default=False)
4971 forbid_adding_reviewers = Column("forbid_adding_reviewers", Boolean(), nullable=False, default=False)
4972
4973 rule_users = relationship('RepoReviewRuleUser')
4974 rule_user_groups = relationship('RepoReviewRuleUserGroup')
4975
4976 def _validate_pattern(self, value):
4977 re.compile('^' + glob2re(value) + '$')
4978
4979 @hybrid_property
4980 def source_branch_pattern(self):
4981 return self._branch_pattern or '*'
4982
4983 @source_branch_pattern.setter
4984 def source_branch_pattern(self, value):
4985 self._validate_pattern(value)
4986 self._branch_pattern = value or '*'
4987
4988 @hybrid_property
4989 def target_branch_pattern(self):
4990 return self._target_branch_pattern or '*'
4991
4992 @target_branch_pattern.setter
4993 def target_branch_pattern(self, value):
4994 self._validate_pattern(value)
4995 self._target_branch_pattern = value or '*'
4996
4997 @hybrid_property
4998 def file_pattern(self):
4999 return self._file_pattern or '*'
5000
5001 @file_pattern.setter
5002 def file_pattern(self, value):
5003 self._validate_pattern(value)
5004 self._file_pattern = value or '*'
5005
5006 def matches(self, source_branch, target_branch, files_changed):
5007 """
5008 Check if this review rule matches a branch/files in a pull request
5009
5010 :param source_branch: source branch name for the commit
5011 :param target_branch: target branch name for the commit
5012 :param files_changed: list of file paths changed in the pull request
5013 """
5014
5015 source_branch = source_branch or ''
5016 target_branch = target_branch or ''
5017 files_changed = files_changed or []
5018
5019 branch_matches = True
5020 if source_branch or target_branch:
5021 if self.source_branch_pattern == '*':
5022 source_branch_match = True
5023 else:
5024 if self.source_branch_pattern.startswith('re:'):
5025 source_pattern = self.source_branch_pattern[3:]
5026 else:
5027 source_pattern = '^' + glob2re(self.source_branch_pattern) + '$'
5028 source_branch_regex = re.compile(source_pattern)
5029 source_branch_match = bool(source_branch_regex.search(source_branch))
5030 if self.target_branch_pattern == '*':
5031 target_branch_match = True
5032 else:
5033 if self.target_branch_pattern.startswith('re:'):
5034 target_pattern = self.target_branch_pattern[3:]
5035 else:
5036 target_pattern = '^' + glob2re(self.target_branch_pattern) + '$'
5037 target_branch_regex = re.compile(target_pattern)
5038 target_branch_match = bool(target_branch_regex.search(target_branch))
5039
5040 branch_matches = source_branch_match and target_branch_match
5041
5042 files_matches = True
5043 if self.file_pattern != '*':
5044 files_matches = False
5045 if self.file_pattern.startswith('re:'):
5046 file_pattern = self.file_pattern[3:]
5047 else:
5048 file_pattern = glob2re(self.file_pattern)
5049 file_regex = re.compile(file_pattern)
5050 for file_data in files_changed:
5051 filename = file_data.get('filename')
5052
5053 if file_regex.search(filename):
5054 files_matches = True
5055 break
5056
5057 return branch_matches and files_matches
5058
5059 @property
5060 def review_users(self):
5061 """ Returns the users which this rule applies to """
5062
5063 users = collections.OrderedDict()
5064
5065 for rule_user in self.rule_users:
5066 if rule_user.user.active:
5067 if rule_user.user not in users:
5068 users[rule_user.user.username] = {
5069 'user': rule_user.user,
5070 'source': 'user',
5071 'source_data': {},
5072 'data': rule_user.rule_data()
5073 }
5074
5075 for rule_user_group in self.rule_user_groups:
5076 source_data = {
5077 'user_group_id': rule_user_group.users_group.users_group_id,
5078 'name': rule_user_group.users_group.users_group_name,
5079 'members': len(rule_user_group.users_group.members)
5080 }
5081 for member in rule_user_group.users_group.members:
5082 if member.user.active:
5083 key = member.user.username
5084 if key in users:
5085 # skip this member as we have him already
5086 # this prevents from override the "first" matched
5087 # users with duplicates in multiple groups
5088 continue
5089
5090 users[key] = {
5091 'user': member.user,
5092 'source': 'user_group',
5093 'source_data': source_data,
5094 'data': rule_user_group.rule_data()
5095 }
5096
5097 return users
5098
5099 def user_group_vote_rule(self, user_id):
5100
5101 rules = []
5102 if not self.rule_user_groups:
5103 return rules
5104
5105 for user_group in self.rule_user_groups:
5106 user_group_members = [x.user_id for x in user_group.users_group.members]
5107 if user_id in user_group_members:
5108 rules.append(user_group)
5109 return rules
5110
5111 def __repr__(self):
5112 return '<RepoReviewerRule(id=%r, repo=%r)>' % (
5113 self.repo_review_rule_id, self.repo)
5114
5115
5116 class ScheduleEntry(Base, BaseModel):
5117 __tablename__ = 'schedule_entries'
5118 __table_args__ = (
5119 UniqueConstraint('schedule_name', name='s_schedule_name_idx'),
5120 UniqueConstraint('task_uid', name='s_task_uid_idx'),
5121 base_table_args,
5122 )
5123
5124 schedule_types = ['crontab', 'timedelta', 'integer']
5125 schedule_entry_id = Column('schedule_entry_id', Integer(), primary_key=True)
5126
5127 schedule_name = Column("schedule_name", String(255), nullable=False, unique=None, default=None)
5128 schedule_description = Column("schedule_description", String(10000), nullable=True, unique=None, default=None)
5129 schedule_enabled = Column("schedule_enabled", Boolean(), nullable=False, unique=None, default=True)
5130
5131 _schedule_type = Column("schedule_type", String(255), nullable=False, unique=None, default=None)
5132 schedule_definition = Column('schedule_definition_json', MutationObj.as_mutable(JsonType(default=lambda: "", dialect_map=dict(mysql=LONGTEXT()))))
5133
5134 schedule_last_run = Column('schedule_last_run', DateTime(timezone=False), nullable=True, unique=None, default=None)
5135 schedule_total_run_count = Column('schedule_total_run_count', Integer(), nullable=True, unique=None, default=0)
5136
5137 # task
5138 task_uid = Column("task_uid", String(255), nullable=False, unique=None, default=None)
5139 task_dot_notation = Column("task_dot_notation", String(4096), nullable=False, unique=None, default=None)
5140 task_args = Column('task_args_json', MutationObj.as_mutable(JsonType(default=list, dialect_map=dict(mysql=LONGTEXT()))))
5141 task_kwargs = Column('task_kwargs_json', MutationObj.as_mutable(JsonType(default=dict, dialect_map=dict(mysql=LONGTEXT()))))
5142
5143 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
5144 updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=None)
5145
5146 @hybrid_property
5147 def schedule_type(self):
5148 return self._schedule_type
5149
5150 @schedule_type.setter
5151 def schedule_type(self, val):
5152 if val not in self.schedule_types:
5153 raise ValueError('Value must be on of `{}` and got `{}`'.format(
5154 val, self.schedule_type))
5155
5156 self._schedule_type = val
5157
5158 @classmethod
5159 def get_uid(cls, obj):
5160 args = obj.task_args
5161 kwargs = obj.task_kwargs
5162 if isinstance(args, JsonRaw):
5163 try:
5164 args = json.loads(args)
5165 except ValueError:
5166 args = tuple()
5167
5168 if isinstance(kwargs, JsonRaw):
5169 try:
5170 kwargs = json.loads(kwargs)
5171 except ValueError:
5172 kwargs = dict()
5173
5174 dot_notation = obj.task_dot_notation
5175 val = '.'.join(map(safe_str, [
5176 sorted(dot_notation), args, sorted(kwargs.items())]))
5177 return hashlib.sha1(val).hexdigest()
5178
5179 @classmethod
5180 def get_by_schedule_name(cls, schedule_name):
5181 return cls.query().filter(cls.schedule_name == schedule_name).scalar()
5182
5183 @classmethod
5184 def get_by_schedule_id(cls, schedule_id):
5185 return cls.query().filter(cls.schedule_entry_id == schedule_id).scalar()
5186
5187 @property
5188 def task(self):
5189 return self.task_dot_notation
5190
5191 @property
5192 def schedule(self):
5193 from rhodecode.lib.celerylib.utils import raw_2_schedule
5194 schedule = raw_2_schedule(self.schedule_definition, self.schedule_type)
5195 return schedule
5196
5197 @property
5198 def args(self):
5199 try:
5200 return list(self.task_args or [])
5201 except ValueError:
5202 return list()
5203
5204 @property
5205 def kwargs(self):
5206 try:
5207 return dict(self.task_kwargs or {})
5208 except ValueError:
5209 return dict()
5210
5211 def _as_raw(self, val):
5212 if hasattr(val, 'de_coerce'):
5213 val = val.de_coerce()
5214 if val:
5215 val = json.dumps(val)
5216
5217 return val
5218
5219 @property
5220 def schedule_definition_raw(self):
5221 return self._as_raw(self.schedule_definition)
5222
5223 @property
5224 def args_raw(self):
5225 return self._as_raw(self.task_args)
5226
5227 @property
5228 def kwargs_raw(self):
5229 return self._as_raw(self.task_kwargs)
5230
5231 def __repr__(self):
5232 return '<DB:ScheduleEntry({}:{})>'.format(
5233 self.schedule_entry_id, self.schedule_name)
5234
5235
5236 @event.listens_for(ScheduleEntry, 'before_update')
5237 def update_task_uid(mapper, connection, target):
5238 target.task_uid = ScheduleEntry.get_uid(target)
5239
5240
5241 @event.listens_for(ScheduleEntry, 'before_insert')
5242 def set_task_uid(mapper, connection, target):
5243 target.task_uid = ScheduleEntry.get_uid(target)
5244
5245
5246 class _BaseBranchPerms(BaseModel):
5247 @classmethod
5248 def compute_hash(cls, value):
5249 return sha1_safe(value)
5250
5251 @hybrid_property
5252 def branch_pattern(self):
5253 return self._branch_pattern or '*'
5254
5255 @hybrid_property
5256 def branch_hash(self):
5257 return self._branch_hash
5258
5259 def _validate_glob(self, value):
5260 re.compile('^' + glob2re(value) + '$')
5261
5262 @branch_pattern.setter
5263 def branch_pattern(self, value):
5264 self._validate_glob(value)
5265 self._branch_pattern = value or '*'
5266 # set the Hash when setting the branch pattern
5267 self._branch_hash = self.compute_hash(self._branch_pattern)
5268
5269 def matches(self, branch):
5270 """
5271 Check if this the branch matches entry
5272
5273 :param branch: branch name for the commit
5274 """
5275
5276 branch = branch or ''
5277
5278 branch_matches = True
5279 if branch:
5280 branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$')
5281 branch_matches = bool(branch_regex.search(branch))
5282
5283 return branch_matches
5284
5285
5286 class UserToRepoBranchPermission(Base, _BaseBranchPerms):
5287 __tablename__ = 'user_to_repo_branch_permissions'
5288 __table_args__ = (
5289 base_table_args
5290 )
5291
5292 branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True)
5293
5294 repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
5295 repo = relationship('Repository', backref='user_branch_perms')
5296
5297 permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
5298 permission = relationship('Permission')
5299
5300 rule_to_perm_id = Column('rule_to_perm_id', Integer(), ForeignKey('repo_to_perm.repo_to_perm_id'), nullable=False, unique=None, default=None)
5301 user_repo_to_perm = relationship('UserRepoToPerm')
5302
5303 rule_order = Column('rule_order', Integer(), nullable=False)
5304 _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default=u'*') # glob
5305 _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql'))
5306
5307 def __unicode__(self):
5308 return u'<UserBranchPermission(%s => %r)>' % (
5309 self.user_repo_to_perm, self.branch_pattern)
5310
5311
5312 class UserGroupToRepoBranchPermission(Base, _BaseBranchPerms):
5313 __tablename__ = 'user_group_to_repo_branch_permissions'
5314 __table_args__ = (
5315 base_table_args
5316 )
5317
5318 branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True)
5319
5320 repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
5321 repo = relationship('Repository', backref='user_group_branch_perms')
5322
5323 permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
5324 permission = relationship('Permission')
5325
5326 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)
5327 user_group_repo_to_perm = relationship('UserGroupRepoToPerm')
5328
5329 rule_order = Column('rule_order', Integer(), nullable=False)
5330 _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default=u'*') # glob
5331 _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql'))
5332
5333 def __unicode__(self):
5334 return u'<UserBranchPermission(%s => %r)>' % (
5335 self.user_group_repo_to_perm, self.branch_pattern)
5336
5337
5338 class UserBookmark(Base, BaseModel):
5339 __tablename__ = 'user_bookmarks'
5340 __table_args__ = (
5341 UniqueConstraint('user_id', 'bookmark_repo_id'),
5342 UniqueConstraint('user_id', 'bookmark_repo_group_id'),
5343 UniqueConstraint('user_id', 'bookmark_position'),
5344 base_table_args
5345 )
5346
5347 user_bookmark_id = Column("user_bookmark_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
5348 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
5349 position = Column("bookmark_position", Integer(), nullable=False)
5350 title = Column("bookmark_title", String(255), nullable=True, unique=None, default=None)
5351 redirect_url = Column("bookmark_redirect_url", String(10240), nullable=True, unique=None, default=None)
5352 created_on = Column("created_on", DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
5353
5354 bookmark_repo_id = Column("bookmark_repo_id", Integer(), ForeignKey("repositories.repo_id"), nullable=True, unique=None, default=None)
5355 bookmark_repo_group_id = Column("bookmark_repo_group_id", Integer(), ForeignKey("groups.group_id"), nullable=True, unique=None, default=None)
5356
5357 user = relationship("User")
5358
5359 repository = relationship("Repository")
5360 repository_group = relationship("RepoGroup")
5361
5362 @classmethod
5363 def get_by_position_for_user(cls, position, user_id):
5364 return cls.query() \
5365 .filter(UserBookmark.user_id == user_id) \
5366 .filter(UserBookmark.position == position).scalar()
5367
5368 @classmethod
5369 def get_bookmarks_for_user(cls, user_id, cache=True):
5370 bookmarks = cls.query() \
5371 .filter(UserBookmark.user_id == user_id) \
5372 .options(joinedload(UserBookmark.repository)) \
5373 .options(joinedload(UserBookmark.repository_group)) \
5374 .order_by(UserBookmark.position.asc())
5375
5376 if cache:
5377 bookmarks = bookmarks.options(
5378 FromCache("sql_cache_short", "get_user_{}_bookmarks".format(user_id))
5379 )
5380
5381 return bookmarks.all()
5382
5383 def __unicode__(self):
5384 return u'<UserBookmark(%s @ %r)>' % (self.position, self.redirect_url)
5385
5386
5387 class FileStore(Base, BaseModel):
5388 __tablename__ = 'file_store'
5389 __table_args__ = (
5390 base_table_args
5391 )
5392
5393 file_store_id = Column('file_store_id', Integer(), primary_key=True)
5394 file_uid = Column('file_uid', String(1024), nullable=False)
5395 file_display_name = Column('file_display_name', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), nullable=True)
5396 file_description = Column('file_description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), nullable=True)
5397 file_org_name = Column('file_org_name', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), nullable=False)
5398
5399 # sha256 hash
5400 file_hash = Column('file_hash', String(512), nullable=False)
5401 file_size = Column('file_size', BigInteger(), nullable=False)
5402
5403 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
5404 accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True)
5405 accessed_count = Column('accessed_count', Integer(), default=0)
5406
5407 enabled = Column('enabled', Boolean(), nullable=False, default=True)
5408
5409 # if repo/repo_group reference is set, check for permissions
5410 check_acl = Column('check_acl', Boolean(), nullable=False, default=True)
5411
5412 # hidden defines an attachment that should be hidden from showing in artifact listing
5413 hidden = Column('hidden', Boolean(), nullable=False, default=False)
5414
5415 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
5416 upload_user = relationship('User', lazy='joined', primaryjoin='User.user_id==FileStore.user_id')
5417
5418 file_metadata = relationship('FileStoreMetadata', lazy='joined')
5419
5420 # scope limited to user, which requester have access to
5421 scope_user_id = Column(
5422 'scope_user_id', Integer(), ForeignKey('users.user_id'),
5423 nullable=True, unique=None, default=None)
5424 user = relationship('User', lazy='joined', primaryjoin='User.user_id==FileStore.scope_user_id')
5425
5426 # scope limited to user group, which requester have access to
5427 scope_user_group_id = Column(
5428 'scope_user_group_id', Integer(), ForeignKey('users_groups.users_group_id'),
5429 nullable=True, unique=None, default=None)
5430 user_group = relationship('UserGroup', lazy='joined')
5431
5432 # scope limited to repo, which requester have access to
5433 scope_repo_id = Column(
5434 'scope_repo_id', Integer(), ForeignKey('repositories.repo_id'),
5435 nullable=True, unique=None, default=None)
5436 repo = relationship('Repository', lazy='joined')
5437
5438 # scope limited to repo group, which requester have access to
5439 scope_repo_group_id = Column(
5440 'scope_repo_group_id', Integer(), ForeignKey('groups.group_id'),
5441 nullable=True, unique=None, default=None)
5442 repo_group = relationship('RepoGroup', lazy='joined')
5443
5444 @classmethod
5445 def get_by_store_uid(cls, file_store_uid):
5446 return FileStore.query().filter(FileStore.file_uid == file_store_uid).scalar()
5447
5448 @classmethod
5449 def create(cls, file_uid, filename, file_hash, file_size, file_display_name='',
5450 file_description='', enabled=True, hidden=False, check_acl=True,
5451 user_id=None, scope_user_id=None, scope_repo_id=None, scope_repo_group_id=None):
5452
5453 store_entry = FileStore()
5454 store_entry.file_uid = file_uid
5455 store_entry.file_display_name = file_display_name
5456 store_entry.file_org_name = filename
5457 store_entry.file_size = file_size
5458 store_entry.file_hash = file_hash
5459 store_entry.file_description = file_description
5460
5461 store_entry.check_acl = check_acl
5462 store_entry.enabled = enabled
5463 store_entry.hidden = hidden
5464
5465 store_entry.user_id = user_id
5466 store_entry.scope_user_id = scope_user_id
5467 store_entry.scope_repo_id = scope_repo_id
5468 store_entry.scope_repo_group_id = scope_repo_group_id
5469
5470 return store_entry
5471
5472 @classmethod
5473 def store_metadata(cls, file_store_id, args, commit=True):
5474 file_store = FileStore.get(file_store_id)
5475 if file_store is None:
5476 return
5477
5478 for section, key, value, value_type in args:
5479 has_key = FileStoreMetadata().query() \
5480 .filter(FileStoreMetadata.file_store_id == file_store.file_store_id) \
5481 .filter(FileStoreMetadata.file_store_meta_section == section) \
5482 .filter(FileStoreMetadata.file_store_meta_key == key) \
5483 .scalar()
5484 if has_key:
5485 msg = 'key `{}` already defined under section `{}` for this file.'\
5486 .format(key, section)
5487 raise ArtifactMetadataDuplicate(msg, err_section=section, err_key=key)
5488
5489 # NOTE(marcink): raises ArtifactMetadataBadValueType
5490 FileStoreMetadata.valid_value_type(value_type)
5491
5492 meta_entry = FileStoreMetadata()
5493 meta_entry.file_store = file_store
5494 meta_entry.file_store_meta_section = section
5495 meta_entry.file_store_meta_key = key
5496 meta_entry.file_store_meta_value_type = value_type
5497 meta_entry.file_store_meta_value = value
5498
5499 Session().add(meta_entry)
5500
5501 try:
5502 if commit:
5503 Session().commit()
5504 except IntegrityError:
5505 Session().rollback()
5506 raise ArtifactMetadataDuplicate('Duplicate section/key found for this file.')
5507
5508 @classmethod
5509 def bump_access_counter(cls, file_uid, commit=True):
5510 FileStore().query()\
5511 .filter(FileStore.file_uid == file_uid)\
5512 .update({FileStore.accessed_count: (FileStore.accessed_count + 1),
5513 FileStore.accessed_on: datetime.datetime.now()})
5514 if commit:
5515 Session().commit()
5516
5517 def __json__(self):
5518 data = {
5519 'filename': self.file_display_name,
5520 'filename_org': self.file_org_name,
5521 'file_uid': self.file_uid,
5522 'description': self.file_description,
5523 'hidden': self.hidden,
5524 'size': self.file_size,
5525 'created_on': self.created_on,
5526 'uploaded_by': self.upload_user.get_api_data(details='basic'),
5527 'downloaded_times': self.accessed_count,
5528 'sha256': self.file_hash,
5529 'metadata': self.file_metadata,
5530 }
5531
5532 return data
5533
5534 def __repr__(self):
5535 return '<FileStore({})>'.format(self.file_store_id)
5536
5537
5538 class FileStoreMetadata(Base, BaseModel):
5539 __tablename__ = 'file_store_metadata'
5540 __table_args__ = (
5541 UniqueConstraint('file_store_id', 'file_store_meta_section_hash', 'file_store_meta_key_hash'),
5542 Index('file_store_meta_section_idx', 'file_store_meta_section', mysql_length=255),
5543 Index('file_store_meta_key_idx', 'file_store_meta_key', mysql_length=255),
5544 base_table_args
5545 )
5546 SETTINGS_TYPES = {
5547 'str': safe_str,
5548 'int': safe_int,
5549 'unicode': safe_unicode,
5550 'bool': str2bool,
5551 'list': functools.partial(aslist, sep=',')
5552 }
5553
5554 file_store_meta_id = Column(
5555 "file_store_meta_id", Integer(), nullable=False, unique=True, default=None,
5556 primary_key=True)
5557 _file_store_meta_section = Column(
5558 "file_store_meta_section", UnicodeText().with_variant(UnicodeText(1024), 'mysql'),
5559 nullable=True, unique=None, default=None)
5560 _file_store_meta_section_hash = Column(
5561 "file_store_meta_section_hash", String(255),
5562 nullable=True, unique=None, default=None)
5563 _file_store_meta_key = Column(
5564 "file_store_meta_key", UnicodeText().with_variant(UnicodeText(1024), 'mysql'),
5565 nullable=True, unique=None, default=None)
5566 _file_store_meta_key_hash = Column(
5567 "file_store_meta_key_hash", String(255), nullable=True, unique=None, default=None)
5568 _file_store_meta_value = Column(
5569 "file_store_meta_value", UnicodeText().with_variant(UnicodeText(20480), 'mysql'),
5570 nullable=True, unique=None, default=None)
5571 _file_store_meta_value_type = Column(
5572 "file_store_meta_value_type", String(255), nullable=True, unique=None,
5573 default='unicode')
5574
5575 file_store_id = Column(
5576 'file_store_id', Integer(), ForeignKey('file_store.file_store_id'),
5577 nullable=True, unique=None, default=None)
5578
5579 file_store = relationship('FileStore', lazy='joined')
5580
5581 @classmethod
5582 def valid_value_type(cls, value):
5583 if value.split('.')[0] not in cls.SETTINGS_TYPES:
5584 raise ArtifactMetadataBadValueType(
5585 'value_type must be one of %s got %s' % (cls.SETTINGS_TYPES.keys(), value))
5586
5587 @hybrid_property
5588 def file_store_meta_section(self):
5589 return self._file_store_meta_section
5590
5591 @file_store_meta_section.setter
5592 def file_store_meta_section(self, value):
5593 self._file_store_meta_section = value
5594 self._file_store_meta_section_hash = _hash_key(value)
5595
5596 @hybrid_property
5597 def file_store_meta_key(self):
5598 return self._file_store_meta_key
5599
5600 @file_store_meta_key.setter
5601 def file_store_meta_key(self, value):
5602 self._file_store_meta_key = value
5603 self._file_store_meta_key_hash = _hash_key(value)
5604
5605 @hybrid_property
5606 def file_store_meta_value(self):
5607 val = self._file_store_meta_value
5608
5609 if self._file_store_meta_value_type:
5610 # e.g unicode.encrypted == unicode
5611 _type = self._file_store_meta_value_type.split('.')[0]
5612 # decode the encrypted value if it's encrypted field type
5613 if '.encrypted' in self._file_store_meta_value_type:
5614 cipher = EncryptedTextValue()
5615 val = safe_unicode(cipher.process_result_value(val, None))
5616 # do final type conversion
5617 converter = self.SETTINGS_TYPES.get(_type) or self.SETTINGS_TYPES['unicode']
5618 val = converter(val)
5619
5620 return val
5621
5622 @file_store_meta_value.setter
5623 def file_store_meta_value(self, val):
5624 val = safe_unicode(val)
5625 # encode the encrypted value
5626 if '.encrypted' in self.file_store_meta_value_type:
5627 cipher = EncryptedTextValue()
5628 val = safe_unicode(cipher.process_bind_param(val, None))
5629 self._file_store_meta_value = val
5630
5631 @hybrid_property
5632 def file_store_meta_value_type(self):
5633 return self._file_store_meta_value_type
5634
5635 @file_store_meta_value_type.setter
5636 def file_store_meta_value_type(self, val):
5637 # e.g unicode.encrypted
5638 self.valid_value_type(val)
5639 self._file_store_meta_value_type = val
5640
5641 def __json__(self):
5642 data = {
5643 'artifact': self.file_store.file_uid,
5644 'section': self.file_store_meta_section,
5645 'key': self.file_store_meta_key,
5646 'value': self.file_store_meta_value,
5647 }
5648
5649 return data
5650
5651 def __repr__(self):
5652 return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.file_store_meta_section,
5653 self.file_store_meta_key, self.file_store_meta_value)
5654
5655
5656 class DbMigrateVersion(Base, BaseModel):
5657 __tablename__ = 'db_migrate_version'
5658 __table_args__ = (
5659 base_table_args,
5660 )
5661
5662 repository_id = Column('repository_id', String(250), primary_key=True)
5663 repository_path = Column('repository_path', Text)
5664 version = Column('version', Integer)
5665
5666 @classmethod
5667 def set_version(cls, version):
5668 """
5669 Helper for forcing a different version, usually for debugging purposes via ishell.
5670 """
5671 ver = DbMigrateVersion.query().first()
5672 ver.version = version
5673 Session().commit()
5674
5675
5676 class DbSession(Base, BaseModel):
5677 __tablename__ = 'db_session'
5678 __table_args__ = (
5679 base_table_args,
5680 )
5681
5682 def __repr__(self):
5683 return '<DB:DbSession({})>'.format(self.id)
5684
5685 id = Column('id', Integer())
5686 namespace = Column('namespace', String(255), primary_key=True)
5687 accessed = Column('accessed', DateTime, nullable=False)
5688 created = Column('created', DateTime, nullable=False)
5689 data = Column('data', PickleType, nullable=False)
@@ -0,0 +1,52 b''
1 # -*- coding: utf-8 -*-
2
3 import logging
4 from sqlalchemy import *
5
6 from alembic.migration import MigrationContext
7 from alembic.operations import Operations
8
9 from rhodecode.lib.dbmigrate.versions import _reset_base
10 from rhodecode.model import meta, init_model_encryption
11
12
13 log = logging.getLogger(__name__)
14
15
16 def upgrade(migrate_engine):
17 """
18 Upgrade operations go here.
19 Don't create your own engine; bind migrate_engine to your metadata
20 """
21 _reset_base(migrate_engine)
22 from rhodecode.lib.dbmigrate.schema import db_4_20_0_0 as db
23
24 init_model_encryption(db)
25
26 context = MigrationContext.configure(migrate_engine.connect())
27 op = Operations(context)
28
29 table = db.PullRequestReviewers.__table__
30 with op.batch_alter_table(table.name) as batch_op:
31 new_column = Column('role', Unicode(255), nullable=True)
32 batch_op.add_column(new_column)
33
34 _fill_reviewers_role(db, op, meta.Session)
35
36
37 def downgrade(migrate_engine):
38 meta = MetaData()
39 meta.bind = migrate_engine
40
41
42 def fixups(models, _SESSION):
43 pass
44
45
46 def _fill_reviewers_role(models, op, session):
47 params = {'role': 'reviewer'}
48 query = text(
49 'UPDATE pull_request_reviewers SET role = :role'
50 ).bindparams(**params)
51 op.execute(query)
52 session().commit()
@@ -48,7 +48,7 b' PYRAMID_SETTINGS = {}'
48 EXTENSIONS = {}
48 EXTENSIONS = {}
49
49
50 __version__ = ('.'.join((str(each) for each in VERSION[:3])))
50 __version__ = ('.'.join((str(each) for each in VERSION[:3])))
51 __dbversion__ = 108 # defines current db version for migrations
51 __dbversion__ = 109 # defines current db version for migrations
52 __platform__ = platform.system()
52 __platform__ = platform.system()
53 __license__ = 'AGPLv3, and Commercial License'
53 __license__ = 'AGPLv3, and Commercial License'
54 __author__ = 'RhodeCode GmbH'
54 __author__ = 'RhodeCode GmbH'
@@ -166,8 +166,8 b' class RepoCommitsView(RepoAppView):'
166 if method == 'show':
166 if method == 'show':
167 inline_comments = CommentsModel().get_inline_comments(
167 inline_comments = CommentsModel().get_inline_comments(
168 self.db_repo.repo_id, revision=commit.raw_id)
168 self.db_repo.repo_id, revision=commit.raw_id)
169 c.inline_cnt = CommentsModel().get_inline_comments_count(
169 c.inline_cnt = len(CommentsModel().get_inline_comments_as_list(
170 inline_comments)
170 inline_comments))
171 c.inline_comments = inline_comments
171 c.inline_comments = inline_comments
172
172
173 cache_path = self.rhodecode_vcs_repo.get_create_shadow_cache_pr_path(
173 cache_path = self.rhodecode_vcs_repo.get_create_shadow_cache_pr_path(
@@ -641,7 +641,7 b' class CommentsModel(BaseModel):'
641 q = self._get_inline_comments_query(repo_id, revision, pull_request)
641 q = self._get_inline_comments_query(repo_id, revision, pull_request)
642 return self._group_comments_by_path_and_line_number(q)
642 return self._group_comments_by_path_and_line_number(q)
643
643
644 def get_inline_comments_count(self, inline_comments, skip_outdated=True,
644 def get_inline_comments_as_list(self, inline_comments, skip_outdated=True,
645 version=None):
645 version=None):
646 inline_cnt = 0
646 inline_cnt = 0
647 for fname, per_line_comments in inline_comments.iteritems():
647 for fname, per_line_comments in inline_comments.iteritems():
@@ -3810,6 +3810,10 b' class ChangesetComment(Base, BaseModel):'
3810 return self.display_state == self.COMMENT_OUTDATED
3810 return self.display_state == self.COMMENT_OUTDATED
3811
3811
3812 @property
3812 @property
3813 def outdated_js(self):
3814 return json.dumps(self.display_state == self.COMMENT_OUTDATED)
3815
3816 @property
3813 def immutable(self):
3817 def immutable(self):
3814 return self.immutable_state == self.OP_IMMUTABLE
3818 return self.immutable_state == self.OP_IMMUTABLE
3815
3819
@@ -4492,6 +4496,8 b' class PullRequestReviewers(Base, BaseMod'
4492 __table_args__ = (
4496 __table_args__ = (
4493 base_table_args,
4497 base_table_args,
4494 )
4498 )
4499 ROLE_REVIEWER = u'reviewer'
4500 ROLE_OBSERVER = u'observer'
4495
4501
4496 @hybrid_property
4502 @hybrid_property
4497 def reasons(self):
4503 def reasons(self):
@@ -4519,6 +4525,8 b' class PullRequestReviewers(Base, BaseMod'
4519 JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))
4525 JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))
4520
4526
4521 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
4527 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
4528 role = Column('role', Unicode(255), nullable=True, default=ROLE_REVIEWER)
4529
4522 user = relationship('User')
4530 user = relationship('User')
4523 pull_request = relationship('PullRequest')
4531 pull_request = relationship('PullRequest')
4524
4532
@@ -484,10 +484,6 b' ul.auth_plugins {'
484 white-space: pre-line;
484 white-space: pre-line;
485 }
485 }
486
486
487 .pr-details-title {
488 height: 16px
489 }
490
491 .pr-details-title-author-pref {
487 .pr-details-title-author-pref {
492 padding-right: 10px
488 padding-right: 10px
493 }
489 }
@@ -1492,26 +1488,17 b' table.integrations {'
1492
1488
1493 // Pull Requests
1489 // Pull Requests
1494 .summary-details {
1490 .summary-details {
1495 width: 72%;
1491 width: 100%;
1496 }
1492 }
1497 .pr-summary {
1493 .pr-summary {
1498 border-bottom: @border-thickness solid @grey5;
1494 border-bottom: @border-thickness solid @grey5;
1499 margin-bottom: @space;
1495 margin-bottom: @space;
1500 }
1496 }
1501
1497
1502 .reviewers-title {
1503 width: 25%;
1504 min-width: 200px;
1505
1506 &.first-panel {
1507 margin-top: 34px;
1508 }
1509 }
1510
1511 .reviewers {
1498 .reviewers {
1512 width: 25%;
1499 width: 98%;
1513 min-width: 200px;
1500 }
1514 }
1501
1515 .reviewers ul li {
1502 .reviewers ul li {
1516 position: relative;
1503 position: relative;
1517 width: 100%;
1504 width: 100%;
@@ -1593,6 +1580,9 b' table.integrations {'
1593 cursor: pointer;
1580 cursor: pointer;
1594 }
1581 }
1595 .pr-details-title {
1582 .pr-details-title {
1583 height: 20px;
1584 line-height: 20px;
1585
1596 padding-bottom: 8px;
1586 padding-bottom: 8px;
1597 border-bottom: @border-thickness solid @grey5;
1587 border-bottom: @border-thickness solid @grey5;
1598
1588
@@ -1617,7 +1607,7 b' table.integrations {'
1617 text-decoration: line-through;
1607 text-decoration: line-through;
1618 }
1608 }
1619
1609
1620 .todo-table {
1610 .todo-table, .comments-table {
1621 width: 100%;
1611 width: 100%;
1622
1612
1623 td {
1613 td {
@@ -38,10 +38,12 b''
38 <div class="main">
38 <div class="main">
39 ${next.main()}
39 ${next.main()}
40 </div>
40 </div>
41
41 </div>
42 </div>
42 <!-- END CONTENT -->
43 <!-- END CONTENT -->
43
44
44 </div>
45 </div>
46
45 <!-- FOOTER -->
47 <!-- FOOTER -->
46 <div id="footer">
48 <div id="footer">
47 <div id="footer-inner" class="title wrapper">
49 <div id="footer-inner" class="title wrapper">
@@ -159,45 +159,45 b" return '%s_%s_%i' % (h.md5_safe(commit+f"
159 </div>
159 </div>
160 % endif
160 % endif
161
161
162 ## comments
162 ## ## comments
163 <div class="pull-right">
163 ## <div class="pull-right">
164 <div class="comments-number" style="padding-left: 10px">
164 ## <div class="comments-number" style="padding-left: 10px">
165 % if hasattr(c, 'comments') and hasattr(c, 'inline_cnt'):
165 ## % if hasattr(c, 'comments') and hasattr(c, 'inline_cnt'):
166 <i class="icon-comment" style="color: #949494">COMMENTS:</i>
166 ## <i class="icon-comment" style="color: #949494">COMMENTS:</i>
167 % if c.comments:
167 ## % if c.comments:
168 <a href="#comments">${_ungettext("{} General", "{} General", len(c.comments)).format(len(c.comments))}</a>,
168 ## <a href="#comments">${_ungettext("{} General", "{} General", len(c.comments)).format(len(c.comments))}</a>,
169 % else:
169 ## % else:
170 ${_('0 General')}
170 ## ${_('0 General')}
171 % endif
171 ## % endif
172
172 ##
173 % if c.inline_cnt:
173 ## % if c.inline_cnt:
174 <a href="#" onclick="return Rhodecode.comments.nextComment();"
174 ## <a href="#" onclick="return Rhodecode.comments.nextComment();"
175 id="inline-comments-counter">${_ungettext("{} Inline", "{} Inline", c.inline_cnt).format(c.inline_cnt)}
175 ## id="inline-comments-counter">${_ungettext("{} Inline", "{} Inline", c.inline_cnt).format(c.inline_cnt)}
176 </a>
176 ## </a>
177 % else:
177 ## % else:
178 ${_('0 Inline')}
178 ## ${_('0 Inline')}
179 % endif
179 ## % endif
180 % endif
180 ## % endif
181
181 ##
182 % if pull_request_menu:
182 ## % if pull_request_menu:
183 <%
183 ## <%
184 outdated_comm_count_ver = pull_request_menu['outdated_comm_count_ver']
184 ## outdated_comm_count_ver = pull_request_menu['outdated_comm_count_ver']
185 %>
185 ## %>
186
186 ##
187 % if outdated_comm_count_ver:
187 ## % if outdated_comm_count_ver:
188 <a href="#" onclick="showOutdated(); Rhodecode.comments.nextOutdatedComment(); return false;">
188 ## <a href="#" onclick="showOutdated(); Rhodecode.comments.nextOutdatedComment(); return false;">
189 (${_("{} Outdated").format(outdated_comm_count_ver)})
189 ## (${_("{} Outdated").format(outdated_comm_count_ver)})
190 </a>
190 ## </a>
191 <a href="#" class="showOutdatedComments" onclick="showOutdated(this); return false;"> | ${_('show outdated')}</a>
191 ## <a href="#" class="showOutdatedComments" onclick="showOutdated(this); return false;"> | ${_('show outdated')}</a>
192 <a href="#" class="hideOutdatedComments" style="display: none" onclick="hideOutdated(this); return false;"> | ${_('hide outdated')}</a>
192 ## <a href="#" class="hideOutdatedComments" style="display: none" onclick="hideOutdated(this); return false;"> | ${_('hide outdated')}</a>
193 % else:
193 ## % else:
194 (${_("{} Outdated").format(outdated_comm_count_ver)})
194 ## (${_("{} Outdated").format(outdated_comm_count_ver)})
195 % endif
195 ## % endif
196
196 ##
197 % endif
197 ## % endif
198
198 ##
199 </div>
199 ## </div>
200 </div>
200 ## </div>
201
201
202 </div>
202 </div>
203
203
@@ -934,7 +934,7 b' def get_comments_for(diff_type, comments'
934 </span>
934 </span>
935 %endif
935 %endif
936 % if commit or pull_request_menu:
936 % if commit or pull_request_menu:
937 <span id="diff_nav">Loading diff...:</span>
937 <span class="tooltip" title="Navigate to previous or next change inside files." id="diff_nav">Loading diff...:</span>
938 <span class="cursor-pointer" onclick="scrollToPrevChunk(); return false">
938 <span class="cursor-pointer" onclick="scrollToPrevChunk(); return false">
939 <i class="icon-angle-up"></i>
939 <i class="icon-angle-up"></i>
940 </span>
940 </span>
@@ -39,8 +39,6 b' var CG = new ColorGenerator();'
39 </script>
39 </script>
40
40
41 <script id="ejs_reviewMemberEntry" type="text/template" class="ejsTemplate">
41 <script id="ejs_reviewMemberEntry" type="text/template" class="ejsTemplate">
42
43 <li id="reviewer_<%= member.user_id %>" class="reviewer_entry">
44 <%
42 <%
45 if (create) {
43 if (create) {
46 var edit_visibility = 'visible';
44 var edit_visibility = 'visible';
@@ -49,15 +47,18 b' var CG = new ColorGenerator();'
49 }
47 }
50
48
51 if (member.user_group && member.user_group.vote_rule) {
49 if (member.user_group && member.user_group.vote_rule) {
52 var groupStyle = 'border-left: 1px solid '+CG.asRGB(CG.getColor(member.user_group.vote_rule));
50 var groupStyle = 'border-right: 2px solid '+CG.asRGB(CG.getColor(member.user_group.vote_rule));
53 } else {
51 } else {
54 var groupStyle = 'border-left: 1px solid white';
52 var groupStyle = 'border-right: 2px solid transparent';
55 }
53 }
56 %>
54 %>
57
55
58 <div class="reviewers_member" style="<%= groupStyle%>" >
56 <li id="reviewer_<%= member.user_id %>" class="reviewer_entry" style="<%= groupStyle%>" tooltip="Review Group">
57
58 <div class="reviewers_member">
59 <div class="reviewer_status tooltip" title="<%= review_status_label %>">
59 <div class="reviewer_status tooltip" title="<%= review_status_label %>">
60 <i class="icon-circle review-status-<%= review_status %>"></i>
60 <i class="icon-circle review-status-<%= review_status %>"></i>
61
61 </div>
62 </div>
62 <div id="reviewer_<%= member.user_id %>_name" class="reviewer_name">
63 <div id="reviewer_<%= member.user_id %>_name" class="reviewer_name">
63 <% if (mandatory) { %>
64 <% if (mandatory) { %>
This diff has been collapsed as it changes many lines, (580 lines changed) Show them Hide them
@@ -280,154 +280,9 b''
280
280
281 </div>
281 </div>
282
282
283 ## REVIEW RULES
284 <div id="review_rules" style="display: none" class="reviewers-title block-right">
285 <div class="pr-details-title">
286 ${_('Reviewer rules')}
287 %if c.allowed_to_update:
288 <span id="close_edit_reviewers" class="block-right action_button last-item" style="display: none;">${_('Close')}</span>
289 %endif
290 </div>
291 <div class="pr-reviewer-rules">
292 ## review rules will be appended here, by default reviewers logic
293 </div>
294 <input id="review_data" type="hidden" name="review_data" value="">
295 </div>
296
283
297 ## REVIEWERS
298 <div class="reviewers-title first-panel block-right">
299 <div class="pr-details-title">
300 ${_('Pull request reviewers')}
301 %if c.allowed_to_update:
302 <span id="open_edit_reviewers" class="block-right action_button last-item">${_('Edit')}</span>
303 %endif
304 </div>
305 </div>
306 <div id="reviewers" class="block-right pr-details-content reviewers">
307
308 ## members redering block
309 <input type="hidden" name="__start__" value="review_members:sequence">
310 <ul id="review_members" class="group_members">
311
312 % for review_obj, member, reasons, mandatory, status in c.pull_request_reviewers:
313 <script>
314 var member = ${h.json.dumps(h.reviewer_as_json(member, reasons=reasons, mandatory=mandatory, user_group=review_obj.rule_user_group_data()))|n};
315 var status = "${(status[0][1].status if status else 'not_reviewed')}";
316 var status_lbl = "${h.commit_status_lbl(status[0][1].status if status else 'not_reviewed')}";
317 var allowed_to_update = ${h.json.dumps(c.allowed_to_update)};
318
319 var entry = renderTemplate('reviewMemberEntry', {
320 'member': member,
321 'mandatory': member.mandatory,
322 'reasons': member.reasons,
323 'allowed_to_update': allowed_to_update,
324 'review_status': status,
325 'review_status_label': status_lbl,
326 'user_group': member.user_group,
327 'create': false
328 });
329 $('#review_members').append(entry)
330 </script>
331
332 % endfor
333
334 </ul>
335
336 <input type="hidden" name="__end__" value="review_members:sequence">
337 ## end members redering block
338
339 %if not c.pull_request.is_closed():
340 <div id="add_reviewer" class="ac" style="display: none;">
341 %if c.allowed_to_update:
342 % if not c.forbid_adding_reviewers:
343 <div id="add_reviewer_input" class="reviewer_ac">
344 ${h.text('user', class_='ac-input', placeholder=_('Add reviewer or reviewer group'))}
345 <div id="reviewers_container"></div>
346 </div>
347 % endif
348 <div class="pull-right">
349 <button id="update_pull_request" class="btn btn-small no-margin">${_('Save Changes')}</button>
350 </div>
351 %endif
352 </div>
353 %endif
354 </div>
355
284
356 ## TODOs will be listed here
357 <div class="reviewers-title block-right">
358 <div class="pr-details-title">
359 ## Only show unresolved, that is only what matters
360 TODO Comments - ${len(c.unresolved_comments)} / ${(len(c.unresolved_comments) + len(c.resolved_comments))}
361
285
362 % if not c.at_version:
363 % if c.resolved_comments:
364 <span class="block-right action_button last-item noselect" onclick="$('.unresolved-todo-text').toggle(); return versionController.toggleElement(this, '.unresolved-todo');" data-toggle-on="Show resolved" data-toggle-off="Hide resolved">Show resolved</span>
365 % else:
366 <span class="block-right last-item noselect">Show resolved</span>
367 % endif
368 % endif
369 </div>
370 </div>
371 <div class="block-right pr-details-content reviewers">
372
373 <table class="todo-table">
374 <%
375 def sorter(entry):
376 user_id = entry.author.user_id
377 resolved = '1' if entry.resolved else '0'
378 if user_id == c.rhodecode_user.user_id:
379 # own comments first
380 user_id = 0
381 return '{}_{}_{}'.format(resolved, user_id, str(entry.comment_id).zfill(100))
382 %>
383
384 % if c.at_version:
385 <tr>
386 <td class="unresolved-todo-text">${_('unresolved TODOs unavailable in this view')}.</td>
387 </tr>
388 % else:
389 % for todo_comment in sorted(c.unresolved_comments + c.resolved_comments, key=sorter):
390 <% resolved = todo_comment.resolved %>
391 % if inline:
392 <% outdated_at_ver = todo_comment.outdated_at_version(getattr(c, 'at_version_num', None)) %>
393 % else:
394 <% outdated_at_ver = todo_comment.older_than_version(getattr(c, 'at_version_num', None)) %>
395 % endif
396
397 <tr ${('class="unresolved-todo" style="display: none"' if resolved else '') |n}>
398
399 <td class="td-todo-number">
400 % if resolved:
401 <a class="permalink todo-resolved tooltip" title="${_('Resolved by comment #{}').format(todo_comment.resolved.comment_id)}" href="#comment-${todo_comment.comment_id}" onclick="return Rhodecode.comments.scrollToComment($('#comment-${todo_comment.comment_id}'), 0, ${h.json.dumps(outdated_at_ver)})">
402 <i class="icon-flag-filled"></i> ${todo_comment.comment_id}</a>
403 % else:
404 <a class="permalink" href="#comment-${todo_comment.comment_id}" onclick="return Rhodecode.comments.scrollToComment($('#comment-${todo_comment.comment_id}'), 0, ${h.json.dumps(outdated_at_ver)})">
405 <i class="icon-flag-filled"></i> ${todo_comment.comment_id}</a>
406 % endif
407 </td>
408 <td class="td-todo-gravatar">
409 ${base.gravatar(todo_comment.author.email, 16, user=todo_comment.author, tooltip=True, extra_class=['no-margin'])}
410 </td>
411 <td class="todo-comment-text-wrapper">
412 <div class="todo-comment-text">
413 <code>${h.chop_at_smart(todo_comment.text, '\n', suffix_if_chopped='...')}</code>
414 </div>
415 </td>
416
417 </tr>
418 % endfor
419
420 % if len(c.unresolved_comments) == 0:
421 <tr>
422 <td class="unresolved-todo-text">${_('No unresolved TODOs')}.</td>
423 </tr>
424 % endif
425
426 % endif
427
428 </table>
429
430 </div>
431 </div>
286 </div>
432
287
433 </div>
288 </div>
@@ -616,9 +471,11 b''
616 <%namespace name="cbdiffs" file="/codeblocks/diffs.mako"/>
471 <%namespace name="cbdiffs" file="/codeblocks/diffs.mako"/>
617 % if c.at_version:
472 % if c.at_version:
618 <% c.inline_cnt = len(c.inline_versions[c.at_version_num]['display']) %>
473 <% c.inline_cnt = len(c.inline_versions[c.at_version_num]['display']) %>
474 <% c.inline_comments_flat = c.inline_versions[c.at_version_num]['display'] %>
619 <% c.comments = c.comment_versions[c.at_version_num]['display'] %>
475 <% c.comments = c.comment_versions[c.at_version_num]['display'] %>
620 % else:
476 % else:
621 <% c.inline_cnt = len(c.inline_versions[c.at_version_num]['until']) %>
477 <% c.inline_cnt = len(c.inline_versions[c.at_version_num]['until']) %>
478 <% c.inline_comments_flat = c.inline_versions[c.at_version_num]['until'] %>
622 <% c.comments = c.comment_versions[c.at_version_num]['until'] %>
479 <% c.comments = c.comment_versions[c.at_version_num]['until'] %>
623 % endif
480 % endif
624
481
@@ -916,6 +773,439 b''
916
773
917 </script>
774 </script>
918
775
776
777 ### NAVBOG RIGHT
778 <style>
779
780 .right-sidebar {
781 position: fixed;
782 top: 0px;
783 bottom: 0;
784 right: 0;
785
786 background: #fafafa;
787 z-index: 200;
788 }
789
790 .right-sidebar {
791 border-left: 1px solid #dbdbdb;
792 }
793
794 .right-sidebar.right-sidebar-expanded {
795 width: 320px;
796 overflow: scroll;
797 }
798
799 .right-sidebar.right-sidebar-collapsed {
800 width: 62px;
801 padding: 0;
802 display: block;
803 overflow: hidden;
804 }
805
806 .sidenav {
807 float: right;
808 will-change: min-height;
809 background: #fafafa;
810 width: 100%;
811 }
812
813 .sidebar-toggle {
814 height: 30px;
815 text-align: center;
816 margin: 15px 0 0 0;
817 }
818 .sidebar-toggle a {
819
820 }
821
822 .sidebar-content {
823 margin-left: 5px;
824 margin-right: 5px;
825 }
826
827 .sidebar-heading {
828 font-size: 1.2em;
829 font-weight: 700;
830 margin-top: 10px;
831 }
832
833 .sidebar-element {
834 margin-top: 20px;
835 }
836 .right-sidebar-collapsed-state {
837 display: flex;
838 flex-direction: column;
839 justify-content: center;
840 align-items: center;
841 padding: 0 10px;
842 cursor: pointer;
843 font-size: 1.3em;
844 margin: 0 -10px;
845 }
846
847 .right-sidebar-collapsed-state:hover {
848 background-color: #dbd9da;
849 }
850
851 .navbar__inner {
852 height: 100%;
853 background: #fafafa;
854 position: relative;
855 }
856
857 </style>
858
859
860
861 <aside class="right-sidebar right-sidebar-expanded">
862 <div class="sidenav">
863 ## TOGGLE
864 <div class="sidebar-toggle" onclick="toggleSidebar(); return false">
865 <a href="#toggleSidebar">
866
867 </a>
868 </div>
869
870 ## CONTENT
871 <div class="sidebar-content">
872
873 ## RULES SUMMARY/RULES
874 <div class="sidebar-element clear-both">
875
876 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="${_('Reviewers')}">
877 <i class="icon-circle review-status-${c.pull_request_review_status}"></i>
878 <br/>${len(c.pull_request_reviewers)}
879 </div>
880
881 ## REVIEW RULES
882 <div id="review_rules" style="display: none" class="">
883 <div class="pr-details-title">
884 <span class="sidebar-heading">
885 ${_('Reviewer rules')}
886 </span>
887
888 </div>
889 <div class="pr-reviewer-rules">
890 ## review rules will be appended here, by default reviewers logic
891 </div>
892 <input id="review_data" type="hidden" name="review_data" value="">
893 </div>
894
895 ## REVIEWERS
896 <div class="right-sidebar-expanded-state pr-details-title">
897 <span class="sidebar-heading">
898 <i class="icon-circle review-status-${c.pull_request_review_status}"></i>
899 ${_('Reviewers')} - ${len(c.pull_request_reviewers)}
900 </span>
901 %if c.allowed_to_update:
902 <span id="open_edit_reviewers" class="block-right action_button last-item">${_('Edit')}</span>
903 <span id="close_edit_reviewers" class="block-right action_button last-item" style="display: none;">${_('Close')}</span>
904 %endif
905 </div>
906 <div id="reviewers" class="right-sidebar-expanded-state pr-details-content reviewers">
907
908 ## members redering block
909 <input type="hidden" name="__start__" value="review_members:sequence">
910 <ul id="review_members" class="group_members">
911
912 % for review_obj, member, reasons, mandatory, status in c.pull_request_reviewers:
913 <script>
914 var member = ${h.json.dumps(h.reviewer_as_json(member, reasons=reasons, mandatory=mandatory, user_group=review_obj.rule_user_group_data()))|n};
915 var status = "${(status[0][1].status if status else 'not_reviewed')}";
916 var status_lbl = "${h.commit_status_lbl(status[0][1].status if status else 'not_reviewed')}";
917 var allowed_to_update = ${h.json.dumps(c.allowed_to_update)};
918
919 var entry = renderTemplate('reviewMemberEntry', {
920 'member': member,
921 'mandatory': member.mandatory,
922 'reasons': member.reasons,
923 'allowed_to_update': allowed_to_update,
924 'review_status': status,
925 'review_status_label': status_lbl,
926 'user_group': member.user_group,
927 'create': false
928 });
929 $('#review_members').append(entry)
930 </script>
931
932 % endfor
933
934 </ul>
935
936 <input type="hidden" name="__end__" value="review_members:sequence">
937 ## end members redering block
938
939 %if not c.pull_request.is_closed():
940 <div id="add_reviewer" class="ac" style="display: none;">
941 %if c.allowed_to_update:
942 % if not c.forbid_adding_reviewers:
943 <div id="add_reviewer_input" class="reviewer_ac">
944 ${h.text('user', class_='ac-input', placeholder=_('Add reviewer or reviewer group'))}
945 <div id="reviewers_container"></div>
946 </div>
947 % endif
948 <div class="pull-right">
949 <button id="update_pull_request" class="btn btn-small no-margin">${_('Save Changes')}</button>
950 </div>
951 %endif
952 </div>
953 %endif
954 </div>
955 </div>
956
957 ## OBSERVERS
958 <div class="sidebar-element clear-both">
959 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="${_('Observers')}">
960 <i class="icon-eye"></i>
961 <br/> 0
962 </div>
963
964 <div class="right-sidebar-expanded-state pr-details-title">
965 <span class="sidebar-heading">
966 <i class="icon-eye"></i>
967 ${_('Observers')}
968 </span>
969 </div>
970 <div class="right-sidebar-expanded-state pr-details-content">
971 No observers - 0
972 </div>
973 </div>
974
975 ## TODOs
976 <div class="sidebar-element clear-both">
977 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="TODOs">
978 <i class="icon-flag-filled"></i>
979 <br/> ${len(c.unresolved_comments)}
919 </div>
980 </div>
920
981
982 ## TODOs will be listed here
983 <div class="right-sidebar-expanded-state pr-details-title">
984 ## Only show unresolved, that is only what matters
985 <span class="sidebar-heading">
986 <i class="icon-flag-filled"></i>
987 TODOs - ${len(c.unresolved_comments)}
988 ##/ ${(len(c.unresolved_comments) + len(c.resolved_comments))}
989 </span>
990
991 % if not c.at_version:
992 % if c.resolved_comments:
993 <span class="block-right action_button last-item noselect" onclick="$('.unresolved-todo-text').toggle(); return versionController.toggleElement(this, '.unresolved-todo');" data-toggle-on="Show resolved" data-toggle-off="Hide resolved">Show resolved</span>
994 % else:
995 <span class="block-right last-item noselect">Show resolved</span>
996 % endif
997 % endif
998 </div>
999
1000 <div class="right-sidebar-expanded-state pr-details-content">
1001
1002 <table class="todo-table">
1003 <%
1004 def sorter(entry):
1005 user_id = entry.author.user_id
1006 resolved = '1' if entry.resolved else '0'
1007 if user_id == c.rhodecode_user.user_id:
1008 # own comments first
1009 user_id = 0
1010 return '{}_{}_{}'.format(resolved, user_id, str(entry.comment_id).zfill(100))
1011 %>
1012
1013 % if c.at_version:
1014 <tr>
1015 <td class="unresolved-todo-text">${_('unresolved TODOs unavailable in this view')}.</td>
1016 </tr>
1017 % else:
1018 % for todo_comment in sorted(c.unresolved_comments + c.resolved_comments, key=sorter):
1019 <% resolved = todo_comment.resolved %>
1020 % if inline:
1021 <% outdated_at_ver = todo_comment.outdated_at_version(getattr(c, 'at_version_num', None)) %>
1022 % else:
1023 <% outdated_at_ver = todo_comment.older_than_version(getattr(c, 'at_version_num', None)) %>
1024 % endif
1025
1026 <tr ${('class="unresolved-todo" style="display: none"' if resolved else '') |n}>
1027
1028 <td class="td-todo-number">
1029 % if resolved:
1030 <a class="permalink todo-resolved tooltip" title="${_('Resolved by comment #{}').format(todo_comment.resolved.comment_id)}" href="#comment-${todo_comment.comment_id}" onclick="return Rhodecode.comments.scrollToComment($('#comment-${todo_comment.comment_id}'), 0, ${h.json.dumps(outdated_at_ver)})">
1031 <i class="icon-flag-filled"></i> ${todo_comment.comment_id}</a>
1032 % else:
1033 <a class="permalink" href="#comment-${todo_comment.comment_id}" onclick="return Rhodecode.comments.scrollToComment($('#comment-${todo_comment.comment_id}'), 0, ${h.json.dumps(outdated_at_ver)})">
1034 <i class="icon-flag-filled"></i> ${todo_comment.comment_id}</a>
1035 % endif
1036 </td>
1037 <td class="td-todo-gravatar">
1038 ${base.gravatar(todo_comment.author.email, 16, user=todo_comment.author, tooltip=True, extra_class=['no-margin'])}
1039 </td>
1040 <td class="todo-comment-text-wrapper">
1041 <div class="todo-comment-text">
1042 <code>${h.chop_at_smart(todo_comment.text, '\n', suffix_if_chopped='...')}</code>
1043 </div>
1044 </td>
1045
1046 </tr>
1047 % endfor
1048
1049 % if len(c.unresolved_comments) == 0:
1050 <tr>
1051 <td class="unresolved-todo-text">${_('No unresolved TODOs')}.</td>
1052 </tr>
1053 % endif
1054
1055 % endif
1056
1057 </table>
1058
1059 </div>
1060 </div>
1061
1062 ## COMMENTS
1063 <div class="sidebar-element clear-both">
1064 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="${_('Comments')}">
1065 <i class="icon-comment" style="color: #949494"></i>
1066 <br/> ${len(c.inline_comments_flat+c.comments)}
1067 </div>
1068
1069 <div class="right-sidebar-expanded-state pr-details-title">
1070 <span class="sidebar-heading">
1071 <i class="icon-comment" style="color: #949494"></i>
1072 ${_('Comments')} - ${len(c.inline_comments_flat+c.comments)}
1073 ##${_ungettext("{} General", "{} General", len(c.comments)).format(len(c.comments))} /
1074 ##${_ungettext("{} Inline", "{} Inline", c.inline_cnt).format(len(c.inline_comments_flat))}
1075
1076 ## TODO check why this ins't working
1077 % if pull_request_menu:
1078 <%
1079 outdated_comm_count_ver = pull_request_menu['outdated_comm_count_ver']
1080 %>
1081
1082 % if outdated_comm_count_ver:
1083 <a href="#" onclick="showOutdated(); Rhodecode.comments.nextOutdatedComment(); return false;">
1084 (${_("{} Outdated").format(outdated_comm_count_ver)})
1085 </a>
1086 <a href="#" class="showOutdatedComments" onclick="showOutdated(this); return false;"> | ${_('show outdated')}</a>
1087 <a href="#" class="hideOutdatedComments" style="display: none" onclick="hideOutdated(this); return false;"> | ${_('hide outdated')}</a>
1088 % else:
1089 (${_("{} Outdated").format(outdated_comm_count_ver)})
1090 % endif
1091
1092 % endif
1093 </span>
1094 <span class="block-right action_button last-item noselect" onclick="return versionController.toggleElement(this, '.hidden-comment');" data-toggle-on="Show all" data-toggle-off="Hide all">Show all</span>
1095 </div>
1096
1097 <div class="right-sidebar-expanded-state pr-details-content">
1098 <table class="todo-table">
1099 <%
1100 def sorter(entry):
1101 user_id = entry.author.user_id
1102 return '{}'.format(str(entry.comment_id).zfill(100))
1103 %>
1104
1105 % for comment_obj in reversed(sorted(c.inline_comments_flat + c.comments, key=sorter)):
1106 <%
1107 display = ''
1108 _cls = ''
1109 %>
1110 ## SKIP TODOs we display them above
1111 % if comment_obj.is_todo:
1112 <% display = 'none' %>
1113 % endif
1114
1115 ## Skip outdated comments
1116 % if comment_obj.outdated:
1117 <% display = 'none' %>
1118 <% _cls = 'hidden-comment' %>
1119 % endif
1120
1121 <tr class="${_cls}" style="display: ${display}">
1122 <td class="td-todo-number">
1123 <a class="permalink" href="#comment-${comment_obj.comment_id}" onclick="return Rhodecode.comments.scrollToComment($('#comment-${comment_obj.comment_id}'), 0, ${comment_obj.outdated_js})">
1124 % if comment_obj.outdated:
1125 <i class="tooltip icon-comment-toggle" title="Outdated"></i>
1126 % elif comment_obj.is_inline:
1127 <i class="tooltip icon-code" title="Inline"></i>
1128 % else:
1129 <i class="tooltip icon-comment" title="General"></i>
1130 % endif
1131 ${comment_obj.comment_id}
1132 </a>
1133 </td>
1134 <td class="td-todo-gravatar">
1135 ${base.gravatar(comment_obj.author.email, 16, user=comment_obj.author, tooltip=True, extra_class=['no-margin'])}
1136 </td>
1137 <td class="todo-comment-text-wrapper">
1138 <div class="todo-comment-text">
1139 <code>${h.chop_at_smart(comment_obj.text, '\n', suffix_if_chopped='...')}</code>
1140 </div>
1141 </td>
1142 </tr>
1143 % endfor
1144
1145 </table>
1146 </div>
1147
1148 </div>
1149 </div>
1150
1151 </div>
1152 </aside>
1153
1154
1155 <script>
1156 var $sideBar = $('.right-sidebar');
1157 var marginExpanded = {'margin': '0 320px 0 0'};
1158 var marginCollapsed = {'margin': '0 50px 0 0'};
1159
1160 if($sideBar.hasClass('right-sidebar-expanded')) {
1161 $('.outerwrapper').css(marginExpanded);
1162 $('.sidebar-toggle a').html('<i class="icon-right" style="margin-right: -10px"></i><i class="icon-right"></i>');
1163 $('.right-sidebar-collapsed-state').hide();
1164 $('.right-sidebar-expanded-state').show();
1165 updateSticky()
1166
1167 } else {
1168 $('.outerwrapper').css(marginCollapsed);
1169 $('.sidebar-toggle a').html('<i class="icon-left" style="margin-right: -10px"></i><i class="icon-left"></i>');
1170 $('.right-sidebar-collapsed-state').hide();
1171 $('.right-sidebar-expanded-state').show();
1172 updateSticky()
1173 }
1174
1175 var toggleSidebar = function(){
1176 var $sideBar = $('.right-sidebar');
1177
1178 if($sideBar.hasClass('right-sidebar-expanded')) {
1179 // collapse now
1180 $sideBar.removeClass('right-sidebar-expanded')
1181 $sideBar.addClass('right-sidebar-collapsed')
1182 $('.outerwrapper').css(marginCollapsed);
1183 $('.sidebar-toggle a').html('<i class="icon-left" style="margin-right: -10px"></i><i class="icon-left"></i>');
1184 $('.right-sidebar-collapsed-state').show();
1185 $('.right-sidebar-expanded-state').hide();
1186
1187 } else {
1188 // expand now
1189 $('.outerwrapper').css(marginExpanded);
1190 $sideBar.addClass('right-sidebar-expanded')
1191 $sideBar.removeClass('right-sidebar-collapsed')
1192 $('.sidebar-toggle a').html('<i class="icon-right" style="margin-right: -10px"></i><i class="icon-right"></i>');
1193 $('.right-sidebar-collapsed-state').hide();
1194 $('.right-sidebar-expanded-state').show();
1195 }
1196
1197 // update our other sticky header in same context
1198 updateSticky()
1199 }
1200
1201 var sidebarElement = document.getElementById('pr-nav-sticky');
1202
1203 ## sidebar = new StickySidebar(sidebarElement, {
1204 ## containerSelector: '.main',
1205 ## minWidth: 62,
1206 ## innerWrapperSelector: '.navbar__inner',
1207 ## stickyClass: 'is-sticky',
1208 ## });
1209
1210 </script>
921 </%def>
1211 </%def>
@@ -948,8 +948,8 b' def assert_inline_comments(pull_request,'
948 if visible is not None:
948 if visible is not None:
949 inline_comments = CommentsModel().get_inline_comments(
949 inline_comments = CommentsModel().get_inline_comments(
950 pull_request.target_repo.repo_id, pull_request=pull_request)
950 pull_request.target_repo.repo_id, pull_request=pull_request)
951 inline_cnt = CommentsModel().get_inline_comments_count(
951 inline_cnt = len(CommentsModel().get_inline_comments_as_list(
952 inline_comments)
952 inline_comments))
953 assert inline_cnt == visible
953 assert inline_cnt == visible
954 if outdated is not None:
954 if outdated is not None:
955 outdated_comments = CommentsModel().get_outdated_comments(
955 outdated_comments = CommentsModel().get_outdated_comments(
General Comments 0
You need to be logged in to leave comments. Login now