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