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