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