##// END OF EJS Templates
pr-shadow: Use reference object to store the last merge reference of a PR. #1055
Martin Bornhold -
r1049:977e010e default
parent child Browse files
Show More
@@ -1,3683 +1,3691 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2
2
3 # Copyright (C) 2010-2016 RhodeCode GmbH
3 # Copyright (C) 2010-2016 RhodeCode GmbH
4 #
4 #
5 # This program is free software: you can redistribute it and/or modify
5 # This program is free software: you can redistribute it and/or modify
6 # it under the terms of the GNU Affero General Public License, version 3
6 # it under the terms of the GNU Affero General Public License, version 3
7 # (only), as published by the Free Software Foundation.
7 # (only), as published by the Free Software Foundation.
8 #
8 #
9 # This program is distributed in the hope that it will be useful,
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 # GNU General Public License for more details.
12 # GNU General Public License for more details.
13 #
13 #
14 # You should have received a copy of the GNU Affero General Public License
14 # You should have received a copy of the GNU Affero General Public License
15 # along with this program. If not, see <http://www.gnu.org/licenses/>.
15 # along with this program. If not, see <http://www.gnu.org/licenses/>.
16 #
16 #
17 # This program is dual-licensed. If you wish to learn more about the
17 # This program is dual-licensed. If you wish to learn more about the
18 # RhodeCode Enterprise Edition, including its added features, Support services,
18 # RhodeCode Enterprise Edition, including its added features, Support services,
19 # and proprietary license terms, please see https://rhodecode.com/licenses/
19 # and proprietary license terms, please see https://rhodecode.com/licenses/
20
20
21 """
21 """
22 Database Models for RhodeCode Enterprise
22 Database Models for RhodeCode Enterprise
23 """
23 """
24
24
25 import re
25 import re
26 import os
26 import os
27 import time
27 import time
28 import hashlib
28 import hashlib
29 import logging
29 import logging
30 import datetime
30 import datetime
31 import warnings
31 import warnings
32 import ipaddress
32 import ipaddress
33 import functools
33 import functools
34 import traceback
34 import traceback
35 import collections
35 import collections
36
36
37
37
38 from sqlalchemy import *
38 from sqlalchemy import *
39 from sqlalchemy.ext.declarative import declared_attr
39 from sqlalchemy.ext.declarative import declared_attr
40 from sqlalchemy.ext.hybrid import hybrid_property
40 from sqlalchemy.ext.hybrid import hybrid_property
41 from sqlalchemy.orm import (
41 from sqlalchemy.orm import (
42 relationship, joinedload, class_mapper, validates, aliased)
42 relationship, joinedload, class_mapper, validates, aliased)
43 from sqlalchemy.sql.expression import true
43 from sqlalchemy.sql.expression import true
44 from beaker.cache import cache_region
44 from beaker.cache import cache_region
45 from webob.exc import HTTPNotFound
45 from webob.exc import HTTPNotFound
46 from zope.cachedescriptors.property import Lazy as LazyProperty
46 from zope.cachedescriptors.property import Lazy as LazyProperty
47
47
48 from pylons import url
48 from pylons import url
49 from pylons.i18n.translation import lazy_ugettext as _
49 from pylons.i18n.translation import lazy_ugettext as _
50
50
51 from rhodecode.lib.vcs import get_vcs_instance
51 from rhodecode.lib.vcs import get_vcs_instance
52 from rhodecode.lib.vcs.backends.base import EmptyCommit, Reference
52 from rhodecode.lib.vcs.backends.base import EmptyCommit, Reference
53 from rhodecode.lib.utils2 import (
53 from rhodecode.lib.utils2 import (
54 str2bool, safe_str, get_commit_safe, safe_unicode, md5_safe,
54 str2bool, safe_str, get_commit_safe, safe_unicode, md5_safe,
55 time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,
55 time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,
56 glob2re)
56 glob2re)
57 from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType
57 from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType
58 from rhodecode.lib.ext_json import json
58 from rhodecode.lib.ext_json import json
59 from rhodecode.lib.caching_query import FromCache
59 from rhodecode.lib.caching_query import FromCache
60 from rhodecode.lib.encrypt import AESCipher
60 from rhodecode.lib.encrypt import AESCipher
61
61
62 from rhodecode.model.meta import Base, Session
62 from rhodecode.model.meta import Base, Session
63
63
64 URL_SEP = '/'
64 URL_SEP = '/'
65 log = logging.getLogger(__name__)
65 log = logging.getLogger(__name__)
66
66
67 # =============================================================================
67 # =============================================================================
68 # BASE CLASSES
68 # BASE CLASSES
69 # =============================================================================
69 # =============================================================================
70
70
71 # this is propagated from .ini file rhodecode.encrypted_values.secret or
71 # this is propagated from .ini file rhodecode.encrypted_values.secret or
72 # beaker.session.secret if first is not set.
72 # beaker.session.secret if first is not set.
73 # and initialized at environment.py
73 # and initialized at environment.py
74 ENCRYPTION_KEY = None
74 ENCRYPTION_KEY = None
75
75
76 # used to sort permissions by types, '#' used here is not allowed to be in
76 # used to sort permissions by types, '#' used here is not allowed to be in
77 # usernames, and it's very early in sorted string.printable table.
77 # usernames, and it's very early in sorted string.printable table.
78 PERMISSION_TYPE_SORT = {
78 PERMISSION_TYPE_SORT = {
79 'admin': '####',
79 'admin': '####',
80 'write': '###',
80 'write': '###',
81 'read': '##',
81 'read': '##',
82 'none': '#',
82 'none': '#',
83 }
83 }
84
84
85
85
86 def display_sort(obj):
86 def display_sort(obj):
87 """
87 """
88 Sort function used to sort permissions in .permissions() function of
88 Sort function used to sort permissions in .permissions() function of
89 Repository, RepoGroup, UserGroup. Also it put the default user in front
89 Repository, RepoGroup, UserGroup. Also it put the default user in front
90 of all other resources
90 of all other resources
91 """
91 """
92
92
93 if obj.username == User.DEFAULT_USER:
93 if obj.username == User.DEFAULT_USER:
94 return '#####'
94 return '#####'
95 prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
95 prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
96 return prefix + obj.username
96 return prefix + obj.username
97
97
98
98
99 def _hash_key(k):
99 def _hash_key(k):
100 return md5_safe(k)
100 return md5_safe(k)
101
101
102
102
103 class EncryptedTextValue(TypeDecorator):
103 class EncryptedTextValue(TypeDecorator):
104 """
104 """
105 Special column for encrypted long text data, use like::
105 Special column for encrypted long text data, use like::
106
106
107 value = Column("encrypted_value", EncryptedValue(), nullable=False)
107 value = Column("encrypted_value", EncryptedValue(), nullable=False)
108
108
109 This column is intelligent so if value is in unencrypted form it return
109 This column is intelligent so if value is in unencrypted form it return
110 unencrypted form, but on save it always encrypts
110 unencrypted form, but on save it always encrypts
111 """
111 """
112 impl = Text
112 impl = Text
113
113
114 def process_bind_param(self, value, dialect):
114 def process_bind_param(self, value, dialect):
115 if not value:
115 if not value:
116 return value
116 return value
117 if value.startswith('enc$aes$') or value.startswith('enc$aes_hmac$'):
117 if value.startswith('enc$aes$') or value.startswith('enc$aes_hmac$'):
118 # protect against double encrypting if someone manually starts
118 # protect against double encrypting if someone manually starts
119 # doing
119 # doing
120 raise ValueError('value needs to be in unencrypted format, ie. '
120 raise ValueError('value needs to be in unencrypted format, ie. '
121 'not starting with enc$aes')
121 'not starting with enc$aes')
122 return 'enc$aes_hmac$%s' % AESCipher(
122 return 'enc$aes_hmac$%s' % AESCipher(
123 ENCRYPTION_KEY, hmac=True).encrypt(value)
123 ENCRYPTION_KEY, hmac=True).encrypt(value)
124
124
125 def process_result_value(self, value, dialect):
125 def process_result_value(self, value, dialect):
126 import rhodecode
126 import rhodecode
127
127
128 if not value:
128 if not value:
129 return value
129 return value
130
130
131 parts = value.split('$', 3)
131 parts = value.split('$', 3)
132 if not len(parts) == 3:
132 if not len(parts) == 3:
133 # probably not encrypted values
133 # probably not encrypted values
134 return value
134 return value
135 else:
135 else:
136 if parts[0] != 'enc':
136 if parts[0] != 'enc':
137 # parts ok but without our header ?
137 # parts ok but without our header ?
138 return value
138 return value
139 enc_strict_mode = str2bool(rhodecode.CONFIG.get(
139 enc_strict_mode = str2bool(rhodecode.CONFIG.get(
140 'rhodecode.encrypted_values.strict') or True)
140 'rhodecode.encrypted_values.strict') or True)
141 # at that stage we know it's our encryption
141 # at that stage we know it's our encryption
142 if parts[1] == 'aes':
142 if parts[1] == 'aes':
143 decrypted_data = AESCipher(ENCRYPTION_KEY).decrypt(parts[2])
143 decrypted_data = AESCipher(ENCRYPTION_KEY).decrypt(parts[2])
144 elif parts[1] == 'aes_hmac':
144 elif parts[1] == 'aes_hmac':
145 decrypted_data = AESCipher(
145 decrypted_data = AESCipher(
146 ENCRYPTION_KEY, hmac=True,
146 ENCRYPTION_KEY, hmac=True,
147 strict_verification=enc_strict_mode).decrypt(parts[2])
147 strict_verification=enc_strict_mode).decrypt(parts[2])
148 else:
148 else:
149 raise ValueError(
149 raise ValueError(
150 'Encryption type part is wrong, must be `aes` '
150 'Encryption type part is wrong, must be `aes` '
151 'or `aes_hmac`, got `%s` instead' % (parts[1]))
151 'or `aes_hmac`, got `%s` instead' % (parts[1]))
152 return decrypted_data
152 return decrypted_data
153
153
154
154
155 class BaseModel(object):
155 class BaseModel(object):
156 """
156 """
157 Base Model for all classes
157 Base Model for all classes
158 """
158 """
159
159
160 @classmethod
160 @classmethod
161 def _get_keys(cls):
161 def _get_keys(cls):
162 """return column names for this model """
162 """return column names for this model """
163 return class_mapper(cls).c.keys()
163 return class_mapper(cls).c.keys()
164
164
165 def get_dict(self):
165 def get_dict(self):
166 """
166 """
167 return dict with keys and values corresponding
167 return dict with keys and values corresponding
168 to this model data """
168 to this model data """
169
169
170 d = {}
170 d = {}
171 for k in self._get_keys():
171 for k in self._get_keys():
172 d[k] = getattr(self, k)
172 d[k] = getattr(self, k)
173
173
174 # also use __json__() if present to get additional fields
174 # also use __json__() if present to get additional fields
175 _json_attr = getattr(self, '__json__', None)
175 _json_attr = getattr(self, '__json__', None)
176 if _json_attr:
176 if _json_attr:
177 # update with attributes from __json__
177 # update with attributes from __json__
178 if callable(_json_attr):
178 if callable(_json_attr):
179 _json_attr = _json_attr()
179 _json_attr = _json_attr()
180 for k, val in _json_attr.iteritems():
180 for k, val in _json_attr.iteritems():
181 d[k] = val
181 d[k] = val
182 return d
182 return d
183
183
184 def get_appstruct(self):
184 def get_appstruct(self):
185 """return list with keys and values tuples corresponding
185 """return list with keys and values tuples corresponding
186 to this model data """
186 to this model data """
187
187
188 l = []
188 l = []
189 for k in self._get_keys():
189 for k in self._get_keys():
190 l.append((k, getattr(self, k),))
190 l.append((k, getattr(self, k),))
191 return l
191 return l
192
192
193 def populate_obj(self, populate_dict):
193 def populate_obj(self, populate_dict):
194 """populate model with data from given populate_dict"""
194 """populate model with data from given populate_dict"""
195
195
196 for k in self._get_keys():
196 for k in self._get_keys():
197 if k in populate_dict:
197 if k in populate_dict:
198 setattr(self, k, populate_dict[k])
198 setattr(self, k, populate_dict[k])
199
199
200 @classmethod
200 @classmethod
201 def query(cls):
201 def query(cls):
202 return Session().query(cls)
202 return Session().query(cls)
203
203
204 @classmethod
204 @classmethod
205 def get(cls, id_):
205 def get(cls, id_):
206 if id_:
206 if id_:
207 return cls.query().get(id_)
207 return cls.query().get(id_)
208
208
209 @classmethod
209 @classmethod
210 def get_or_404(cls, id_):
210 def get_or_404(cls, id_):
211 try:
211 try:
212 id_ = int(id_)
212 id_ = int(id_)
213 except (TypeError, ValueError):
213 except (TypeError, ValueError):
214 raise HTTPNotFound
214 raise HTTPNotFound
215
215
216 res = cls.query().get(id_)
216 res = cls.query().get(id_)
217 if not res:
217 if not res:
218 raise HTTPNotFound
218 raise HTTPNotFound
219 return res
219 return res
220
220
221 @classmethod
221 @classmethod
222 def getAll(cls):
222 def getAll(cls):
223 # deprecated and left for backward compatibility
223 # deprecated and left for backward compatibility
224 return cls.get_all()
224 return cls.get_all()
225
225
226 @classmethod
226 @classmethod
227 def get_all(cls):
227 def get_all(cls):
228 return cls.query().all()
228 return cls.query().all()
229
229
230 @classmethod
230 @classmethod
231 def delete(cls, id_):
231 def delete(cls, id_):
232 obj = cls.query().get(id_)
232 obj = cls.query().get(id_)
233 Session().delete(obj)
233 Session().delete(obj)
234
234
235 @classmethod
235 @classmethod
236 def identity_cache(cls, session, attr_name, value):
236 def identity_cache(cls, session, attr_name, value):
237 exist_in_session = []
237 exist_in_session = []
238 for (item_cls, pkey), instance in session.identity_map.items():
238 for (item_cls, pkey), instance in session.identity_map.items():
239 if cls == item_cls and getattr(instance, attr_name) == value:
239 if cls == item_cls and getattr(instance, attr_name) == value:
240 exist_in_session.append(instance)
240 exist_in_session.append(instance)
241 if exist_in_session:
241 if exist_in_session:
242 if len(exist_in_session) == 1:
242 if len(exist_in_session) == 1:
243 return exist_in_session[0]
243 return exist_in_session[0]
244 log.exception(
244 log.exception(
245 'multiple objects with attr %s and '
245 'multiple objects with attr %s and '
246 'value %s found with same name: %r',
246 'value %s found with same name: %r',
247 attr_name, value, exist_in_session)
247 attr_name, value, exist_in_session)
248
248
249 def __repr__(self):
249 def __repr__(self):
250 if hasattr(self, '__unicode__'):
250 if hasattr(self, '__unicode__'):
251 # python repr needs to return str
251 # python repr needs to return str
252 try:
252 try:
253 return safe_str(self.__unicode__())
253 return safe_str(self.__unicode__())
254 except UnicodeDecodeError:
254 except UnicodeDecodeError:
255 pass
255 pass
256 return '<DB:%s>' % (self.__class__.__name__)
256 return '<DB:%s>' % (self.__class__.__name__)
257
257
258
258
259 class RhodeCodeSetting(Base, BaseModel):
259 class RhodeCodeSetting(Base, BaseModel):
260 __tablename__ = 'rhodecode_settings'
260 __tablename__ = 'rhodecode_settings'
261 __table_args__ = (
261 __table_args__ = (
262 UniqueConstraint('app_settings_name'),
262 UniqueConstraint('app_settings_name'),
263 {'extend_existing': True, 'mysql_engine': 'InnoDB',
263 {'extend_existing': True, 'mysql_engine': 'InnoDB',
264 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
264 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
265 )
265 )
266
266
267 SETTINGS_TYPES = {
267 SETTINGS_TYPES = {
268 'str': safe_str,
268 'str': safe_str,
269 'int': safe_int,
269 'int': safe_int,
270 'unicode': safe_unicode,
270 'unicode': safe_unicode,
271 'bool': str2bool,
271 'bool': str2bool,
272 'list': functools.partial(aslist, sep=',')
272 'list': functools.partial(aslist, sep=',')
273 }
273 }
274 DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions'
274 DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions'
275 GLOBAL_CONF_KEY = 'app_settings'
275 GLOBAL_CONF_KEY = 'app_settings'
276
276
277 app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
277 app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
278 app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None)
278 app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None)
279 _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None)
279 _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None)
280 _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None)
280 _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None)
281
281
282 def __init__(self, key='', val='', type='unicode'):
282 def __init__(self, key='', val='', type='unicode'):
283 self.app_settings_name = key
283 self.app_settings_name = key
284 self.app_settings_type = type
284 self.app_settings_type = type
285 self.app_settings_value = val
285 self.app_settings_value = val
286
286
287 @validates('_app_settings_value')
287 @validates('_app_settings_value')
288 def validate_settings_value(self, key, val):
288 def validate_settings_value(self, key, val):
289 assert type(val) == unicode
289 assert type(val) == unicode
290 return val
290 return val
291
291
292 @hybrid_property
292 @hybrid_property
293 def app_settings_value(self):
293 def app_settings_value(self):
294 v = self._app_settings_value
294 v = self._app_settings_value
295 _type = self.app_settings_type
295 _type = self.app_settings_type
296 if _type:
296 if _type:
297 _type = self.app_settings_type.split('.')[0]
297 _type = self.app_settings_type.split('.')[0]
298 # decode the encrypted value
298 # decode the encrypted value
299 if 'encrypted' in self.app_settings_type:
299 if 'encrypted' in self.app_settings_type:
300 cipher = EncryptedTextValue()
300 cipher = EncryptedTextValue()
301 v = safe_unicode(cipher.process_result_value(v, None))
301 v = safe_unicode(cipher.process_result_value(v, None))
302
302
303 converter = self.SETTINGS_TYPES.get(_type) or \
303 converter = self.SETTINGS_TYPES.get(_type) or \
304 self.SETTINGS_TYPES['unicode']
304 self.SETTINGS_TYPES['unicode']
305 return converter(v)
305 return converter(v)
306
306
307 @app_settings_value.setter
307 @app_settings_value.setter
308 def app_settings_value(self, val):
308 def app_settings_value(self, val):
309 """
309 """
310 Setter that will always make sure we use unicode in app_settings_value
310 Setter that will always make sure we use unicode in app_settings_value
311
311
312 :param val:
312 :param val:
313 """
313 """
314 val = safe_unicode(val)
314 val = safe_unicode(val)
315 # encode the encrypted value
315 # encode the encrypted value
316 if 'encrypted' in self.app_settings_type:
316 if 'encrypted' in self.app_settings_type:
317 cipher = EncryptedTextValue()
317 cipher = EncryptedTextValue()
318 val = safe_unicode(cipher.process_bind_param(val, None))
318 val = safe_unicode(cipher.process_bind_param(val, None))
319 self._app_settings_value = val
319 self._app_settings_value = val
320
320
321 @hybrid_property
321 @hybrid_property
322 def app_settings_type(self):
322 def app_settings_type(self):
323 return self._app_settings_type
323 return self._app_settings_type
324
324
325 @app_settings_type.setter
325 @app_settings_type.setter
326 def app_settings_type(self, val):
326 def app_settings_type(self, val):
327 if val.split('.')[0] not in self.SETTINGS_TYPES:
327 if val.split('.')[0] not in self.SETTINGS_TYPES:
328 raise Exception('type must be one of %s got %s'
328 raise Exception('type must be one of %s got %s'
329 % (self.SETTINGS_TYPES.keys(), val))
329 % (self.SETTINGS_TYPES.keys(), val))
330 self._app_settings_type = val
330 self._app_settings_type = val
331
331
332 def __unicode__(self):
332 def __unicode__(self):
333 return u"<%s('%s:%s[%s]')>" % (
333 return u"<%s('%s:%s[%s]')>" % (
334 self.__class__.__name__,
334 self.__class__.__name__,
335 self.app_settings_name, self.app_settings_value,
335 self.app_settings_name, self.app_settings_value,
336 self.app_settings_type
336 self.app_settings_type
337 )
337 )
338
338
339
339
340 class RhodeCodeUi(Base, BaseModel):
340 class RhodeCodeUi(Base, BaseModel):
341 __tablename__ = 'rhodecode_ui'
341 __tablename__ = 'rhodecode_ui'
342 __table_args__ = (
342 __table_args__ = (
343 UniqueConstraint('ui_key'),
343 UniqueConstraint('ui_key'),
344 {'extend_existing': True, 'mysql_engine': 'InnoDB',
344 {'extend_existing': True, 'mysql_engine': 'InnoDB',
345 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
345 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
346 )
346 )
347
347
348 HOOK_REPO_SIZE = 'changegroup.repo_size'
348 HOOK_REPO_SIZE = 'changegroup.repo_size'
349 # HG
349 # HG
350 HOOK_PRE_PULL = 'preoutgoing.pre_pull'
350 HOOK_PRE_PULL = 'preoutgoing.pre_pull'
351 HOOK_PULL = 'outgoing.pull_logger'
351 HOOK_PULL = 'outgoing.pull_logger'
352 HOOK_PRE_PUSH = 'prechangegroup.pre_push'
352 HOOK_PRE_PUSH = 'prechangegroup.pre_push'
353 HOOK_PUSH = 'changegroup.push_logger'
353 HOOK_PUSH = 'changegroup.push_logger'
354
354
355 # TODO: johbo: Unify way how hooks are configured for git and hg,
355 # TODO: johbo: Unify way how hooks are configured for git and hg,
356 # git part is currently hardcoded.
356 # git part is currently hardcoded.
357
357
358 # SVN PATTERNS
358 # SVN PATTERNS
359 SVN_BRANCH_ID = 'vcs_svn_branch'
359 SVN_BRANCH_ID = 'vcs_svn_branch'
360 SVN_TAG_ID = 'vcs_svn_tag'
360 SVN_TAG_ID = 'vcs_svn_tag'
361
361
362 ui_id = Column(
362 ui_id = Column(
363 "ui_id", Integer(), nullable=False, unique=True, default=None,
363 "ui_id", Integer(), nullable=False, unique=True, default=None,
364 primary_key=True)
364 primary_key=True)
365 ui_section = Column(
365 ui_section = Column(
366 "ui_section", String(255), nullable=True, unique=None, default=None)
366 "ui_section", String(255), nullable=True, unique=None, default=None)
367 ui_key = Column(
367 ui_key = Column(
368 "ui_key", String(255), nullable=True, unique=None, default=None)
368 "ui_key", String(255), nullable=True, unique=None, default=None)
369 ui_value = Column(
369 ui_value = Column(
370 "ui_value", String(255), nullable=True, unique=None, default=None)
370 "ui_value", String(255), nullable=True, unique=None, default=None)
371 ui_active = Column(
371 ui_active = Column(
372 "ui_active", Boolean(), nullable=True, unique=None, default=True)
372 "ui_active", Boolean(), nullable=True, unique=None, default=True)
373
373
374 def __repr__(self):
374 def __repr__(self):
375 return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section,
375 return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section,
376 self.ui_key, self.ui_value)
376 self.ui_key, self.ui_value)
377
377
378
378
379 class RepoRhodeCodeSetting(Base, BaseModel):
379 class RepoRhodeCodeSetting(Base, BaseModel):
380 __tablename__ = 'repo_rhodecode_settings'
380 __tablename__ = 'repo_rhodecode_settings'
381 __table_args__ = (
381 __table_args__ = (
382 UniqueConstraint(
382 UniqueConstraint(
383 'app_settings_name', 'repository_id',
383 'app_settings_name', 'repository_id',
384 name='uq_repo_rhodecode_setting_name_repo_id'),
384 name='uq_repo_rhodecode_setting_name_repo_id'),
385 {'extend_existing': True, 'mysql_engine': 'InnoDB',
385 {'extend_existing': True, 'mysql_engine': 'InnoDB',
386 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
386 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
387 )
387 )
388
388
389 repository_id = Column(
389 repository_id = Column(
390 "repository_id", Integer(), ForeignKey('repositories.repo_id'),
390 "repository_id", Integer(), ForeignKey('repositories.repo_id'),
391 nullable=False)
391 nullable=False)
392 app_settings_id = Column(
392 app_settings_id = Column(
393 "app_settings_id", Integer(), nullable=False, unique=True,
393 "app_settings_id", Integer(), nullable=False, unique=True,
394 default=None, primary_key=True)
394 default=None, primary_key=True)
395 app_settings_name = Column(
395 app_settings_name = Column(
396 "app_settings_name", String(255), nullable=True, unique=None,
396 "app_settings_name", String(255), nullable=True, unique=None,
397 default=None)
397 default=None)
398 _app_settings_value = Column(
398 _app_settings_value = Column(
399 "app_settings_value", String(4096), nullable=True, unique=None,
399 "app_settings_value", String(4096), nullable=True, unique=None,
400 default=None)
400 default=None)
401 _app_settings_type = Column(
401 _app_settings_type = Column(
402 "app_settings_type", String(255), nullable=True, unique=None,
402 "app_settings_type", String(255), nullable=True, unique=None,
403 default=None)
403 default=None)
404
404
405 repository = relationship('Repository')
405 repository = relationship('Repository')
406
406
407 def __init__(self, repository_id, key='', val='', type='unicode'):
407 def __init__(self, repository_id, key='', val='', type='unicode'):
408 self.repository_id = repository_id
408 self.repository_id = repository_id
409 self.app_settings_name = key
409 self.app_settings_name = key
410 self.app_settings_type = type
410 self.app_settings_type = type
411 self.app_settings_value = val
411 self.app_settings_value = val
412
412
413 @validates('_app_settings_value')
413 @validates('_app_settings_value')
414 def validate_settings_value(self, key, val):
414 def validate_settings_value(self, key, val):
415 assert type(val) == unicode
415 assert type(val) == unicode
416 return val
416 return val
417
417
418 @hybrid_property
418 @hybrid_property
419 def app_settings_value(self):
419 def app_settings_value(self):
420 v = self._app_settings_value
420 v = self._app_settings_value
421 type_ = self.app_settings_type
421 type_ = self.app_settings_type
422 SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
422 SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
423 converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode']
423 converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode']
424 return converter(v)
424 return converter(v)
425
425
426 @app_settings_value.setter
426 @app_settings_value.setter
427 def app_settings_value(self, val):
427 def app_settings_value(self, val):
428 """
428 """
429 Setter that will always make sure we use unicode in app_settings_value
429 Setter that will always make sure we use unicode in app_settings_value
430
430
431 :param val:
431 :param val:
432 """
432 """
433 self._app_settings_value = safe_unicode(val)
433 self._app_settings_value = safe_unicode(val)
434
434
435 @hybrid_property
435 @hybrid_property
436 def app_settings_type(self):
436 def app_settings_type(self):
437 return self._app_settings_type
437 return self._app_settings_type
438
438
439 @app_settings_type.setter
439 @app_settings_type.setter
440 def app_settings_type(self, val):
440 def app_settings_type(self, val):
441 SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
441 SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
442 if val not in SETTINGS_TYPES:
442 if val not in SETTINGS_TYPES:
443 raise Exception('type must be one of %s got %s'
443 raise Exception('type must be one of %s got %s'
444 % (SETTINGS_TYPES.keys(), val))
444 % (SETTINGS_TYPES.keys(), val))
445 self._app_settings_type = val
445 self._app_settings_type = val
446
446
447 def __unicode__(self):
447 def __unicode__(self):
448 return u"<%s('%s:%s:%s[%s]')>" % (
448 return u"<%s('%s:%s:%s[%s]')>" % (
449 self.__class__.__name__, self.repository.repo_name,
449 self.__class__.__name__, self.repository.repo_name,
450 self.app_settings_name, self.app_settings_value,
450 self.app_settings_name, self.app_settings_value,
451 self.app_settings_type
451 self.app_settings_type
452 )
452 )
453
453
454
454
455 class RepoRhodeCodeUi(Base, BaseModel):
455 class RepoRhodeCodeUi(Base, BaseModel):
456 __tablename__ = 'repo_rhodecode_ui'
456 __tablename__ = 'repo_rhodecode_ui'
457 __table_args__ = (
457 __table_args__ = (
458 UniqueConstraint(
458 UniqueConstraint(
459 'repository_id', 'ui_section', 'ui_key',
459 'repository_id', 'ui_section', 'ui_key',
460 name='uq_repo_rhodecode_ui_repository_id_section_key'),
460 name='uq_repo_rhodecode_ui_repository_id_section_key'),
461 {'extend_existing': True, 'mysql_engine': 'InnoDB',
461 {'extend_existing': True, 'mysql_engine': 'InnoDB',
462 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
462 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
463 )
463 )
464
464
465 repository_id = Column(
465 repository_id = Column(
466 "repository_id", Integer(), ForeignKey('repositories.repo_id'),
466 "repository_id", Integer(), ForeignKey('repositories.repo_id'),
467 nullable=False)
467 nullable=False)
468 ui_id = Column(
468 ui_id = Column(
469 "ui_id", Integer(), nullable=False, unique=True, default=None,
469 "ui_id", Integer(), nullable=False, unique=True, default=None,
470 primary_key=True)
470 primary_key=True)
471 ui_section = Column(
471 ui_section = Column(
472 "ui_section", String(255), nullable=True, unique=None, default=None)
472 "ui_section", String(255), nullable=True, unique=None, default=None)
473 ui_key = Column(
473 ui_key = Column(
474 "ui_key", String(255), nullable=True, unique=None, default=None)
474 "ui_key", String(255), nullable=True, unique=None, default=None)
475 ui_value = Column(
475 ui_value = Column(
476 "ui_value", String(255), nullable=True, unique=None, default=None)
476 "ui_value", String(255), nullable=True, unique=None, default=None)
477 ui_active = Column(
477 ui_active = Column(
478 "ui_active", Boolean(), nullable=True, unique=None, default=True)
478 "ui_active", Boolean(), nullable=True, unique=None, default=True)
479
479
480 repository = relationship('Repository')
480 repository = relationship('Repository')
481
481
482 def __repr__(self):
482 def __repr__(self):
483 return '<%s[%s:%s]%s=>%s]>' % (
483 return '<%s[%s:%s]%s=>%s]>' % (
484 self.__class__.__name__, self.repository.repo_name,
484 self.__class__.__name__, self.repository.repo_name,
485 self.ui_section, self.ui_key, self.ui_value)
485 self.ui_section, self.ui_key, self.ui_value)
486
486
487
487
488 class User(Base, BaseModel):
488 class User(Base, BaseModel):
489 __tablename__ = 'users'
489 __tablename__ = 'users'
490 __table_args__ = (
490 __table_args__ = (
491 UniqueConstraint('username'), UniqueConstraint('email'),
491 UniqueConstraint('username'), UniqueConstraint('email'),
492 Index('u_username_idx', 'username'),
492 Index('u_username_idx', 'username'),
493 Index('u_email_idx', 'email'),
493 Index('u_email_idx', 'email'),
494 {'extend_existing': True, 'mysql_engine': 'InnoDB',
494 {'extend_existing': True, 'mysql_engine': 'InnoDB',
495 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
495 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
496 )
496 )
497 DEFAULT_USER = 'default'
497 DEFAULT_USER = 'default'
498 DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org'
498 DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org'
499 DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}'
499 DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}'
500
500
501 user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
501 user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
502 username = Column("username", String(255), nullable=True, unique=None, default=None)
502 username = Column("username", String(255), nullable=True, unique=None, default=None)
503 password = Column("password", String(255), nullable=True, unique=None, default=None)
503 password = Column("password", String(255), nullable=True, unique=None, default=None)
504 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
504 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
505 admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)
505 admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)
506 name = Column("firstname", String(255), nullable=True, unique=None, default=None)
506 name = Column("firstname", String(255), nullable=True, unique=None, default=None)
507 lastname = Column("lastname", String(255), nullable=True, unique=None, default=None)
507 lastname = Column("lastname", String(255), nullable=True, unique=None, default=None)
508 _email = Column("email", String(255), nullable=True, unique=None, default=None)
508 _email = Column("email", String(255), nullable=True, unique=None, default=None)
509 last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)
509 last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)
510 extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None)
510 extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None)
511 extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None)
511 extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None)
512 api_key = Column("api_key", String(255), nullable=True, unique=None, default=None)
512 api_key = Column("api_key", String(255), nullable=True, unique=None, default=None)
513 inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
513 inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
514 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
514 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
515 _user_data = Column("user_data", LargeBinary(), nullable=True) # JSON data
515 _user_data = Column("user_data", LargeBinary(), nullable=True) # JSON data
516
516
517 user_log = relationship('UserLog')
517 user_log = relationship('UserLog')
518 user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')
518 user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')
519
519
520 repositories = relationship('Repository')
520 repositories = relationship('Repository')
521 repository_groups = relationship('RepoGroup')
521 repository_groups = relationship('RepoGroup')
522 user_groups = relationship('UserGroup')
522 user_groups = relationship('UserGroup')
523
523
524 user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')
524 user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')
525 followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all')
525 followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all')
526
526
527 repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')
527 repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')
528 repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')
528 repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')
529 user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all')
529 user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all')
530
530
531 group_member = relationship('UserGroupMember', cascade='all')
531 group_member = relationship('UserGroupMember', cascade='all')
532
532
533 notifications = relationship('UserNotification', cascade='all')
533 notifications = relationship('UserNotification', cascade='all')
534 # notifications assigned to this user
534 # notifications assigned to this user
535 user_created_notifications = relationship('Notification', cascade='all')
535 user_created_notifications = relationship('Notification', cascade='all')
536 # comments created by this user
536 # comments created by this user
537 user_comments = relationship('ChangesetComment', cascade='all')
537 user_comments = relationship('ChangesetComment', cascade='all')
538 # user profile extra info
538 # user profile extra info
539 user_emails = relationship('UserEmailMap', cascade='all')
539 user_emails = relationship('UserEmailMap', cascade='all')
540 user_ip_map = relationship('UserIpMap', cascade='all')
540 user_ip_map = relationship('UserIpMap', cascade='all')
541 user_auth_tokens = relationship('UserApiKeys', cascade='all')
541 user_auth_tokens = relationship('UserApiKeys', cascade='all')
542 # gists
542 # gists
543 user_gists = relationship('Gist', cascade='all')
543 user_gists = relationship('Gist', cascade='all')
544 # user pull requests
544 # user pull requests
545 user_pull_requests = relationship('PullRequest', cascade='all')
545 user_pull_requests = relationship('PullRequest', cascade='all')
546 # external identities
546 # external identities
547 extenal_identities = relationship(
547 extenal_identities = relationship(
548 'ExternalIdentity',
548 'ExternalIdentity',
549 primaryjoin="User.user_id==ExternalIdentity.local_user_id",
549 primaryjoin="User.user_id==ExternalIdentity.local_user_id",
550 cascade='all')
550 cascade='all')
551
551
552 def __unicode__(self):
552 def __unicode__(self):
553 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
553 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
554 self.user_id, self.username)
554 self.user_id, self.username)
555
555
556 @hybrid_property
556 @hybrid_property
557 def email(self):
557 def email(self):
558 return self._email
558 return self._email
559
559
560 @email.setter
560 @email.setter
561 def email(self, val):
561 def email(self, val):
562 self._email = val.lower() if val else None
562 self._email = val.lower() if val else None
563
563
564 @property
564 @property
565 def firstname(self):
565 def firstname(self):
566 # alias for future
566 # alias for future
567 return self.name
567 return self.name
568
568
569 @property
569 @property
570 def emails(self):
570 def emails(self):
571 other = UserEmailMap.query().filter(UserEmailMap.user==self).all()
571 other = UserEmailMap.query().filter(UserEmailMap.user==self).all()
572 return [self.email] + [x.email for x in other]
572 return [self.email] + [x.email for x in other]
573
573
574 @property
574 @property
575 def auth_tokens(self):
575 def auth_tokens(self):
576 return [self.api_key] + [x.api_key for x in self.extra_auth_tokens]
576 return [self.api_key] + [x.api_key for x in self.extra_auth_tokens]
577
577
578 @property
578 @property
579 def extra_auth_tokens(self):
579 def extra_auth_tokens(self):
580 return UserApiKeys.query().filter(UserApiKeys.user == self).all()
580 return UserApiKeys.query().filter(UserApiKeys.user == self).all()
581
581
582 @property
582 @property
583 def feed_token(self):
583 def feed_token(self):
584 feed_tokens = UserApiKeys.query()\
584 feed_tokens = UserApiKeys.query()\
585 .filter(UserApiKeys.user == self)\
585 .filter(UserApiKeys.user == self)\
586 .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED)\
586 .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED)\
587 .all()
587 .all()
588 if feed_tokens:
588 if feed_tokens:
589 return feed_tokens[0].api_key
589 return feed_tokens[0].api_key
590 else:
590 else:
591 # use the main token so we don't end up with nothing...
591 # use the main token so we don't end up with nothing...
592 return self.api_key
592 return self.api_key
593
593
594 @classmethod
594 @classmethod
595 def extra_valid_auth_tokens(cls, user, role=None):
595 def extra_valid_auth_tokens(cls, user, role=None):
596 tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\
596 tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\
597 .filter(or_(UserApiKeys.expires == -1,
597 .filter(or_(UserApiKeys.expires == -1,
598 UserApiKeys.expires >= time.time()))
598 UserApiKeys.expires >= time.time()))
599 if role:
599 if role:
600 tokens = tokens.filter(or_(UserApiKeys.role == role,
600 tokens = tokens.filter(or_(UserApiKeys.role == role,
601 UserApiKeys.role == UserApiKeys.ROLE_ALL))
601 UserApiKeys.role == UserApiKeys.ROLE_ALL))
602 return tokens.all()
602 return tokens.all()
603
603
604 @property
604 @property
605 def ip_addresses(self):
605 def ip_addresses(self):
606 ret = UserIpMap.query().filter(UserIpMap.user == self).all()
606 ret = UserIpMap.query().filter(UserIpMap.user == self).all()
607 return [x.ip_addr for x in ret]
607 return [x.ip_addr for x in ret]
608
608
609 @property
609 @property
610 def username_and_name(self):
610 def username_and_name(self):
611 return '%s (%s %s)' % (self.username, self.firstname, self.lastname)
611 return '%s (%s %s)' % (self.username, self.firstname, self.lastname)
612
612
613 @property
613 @property
614 def username_or_name_or_email(self):
614 def username_or_name_or_email(self):
615 full_name = self.full_name if self.full_name is not ' ' else None
615 full_name = self.full_name if self.full_name is not ' ' else None
616 return self.username or full_name or self.email
616 return self.username or full_name or self.email
617
617
618 @property
618 @property
619 def full_name(self):
619 def full_name(self):
620 return '%s %s' % (self.firstname, self.lastname)
620 return '%s %s' % (self.firstname, self.lastname)
621
621
622 @property
622 @property
623 def full_name_or_username(self):
623 def full_name_or_username(self):
624 return ('%s %s' % (self.firstname, self.lastname)
624 return ('%s %s' % (self.firstname, self.lastname)
625 if (self.firstname and self.lastname) else self.username)
625 if (self.firstname and self.lastname) else self.username)
626
626
627 @property
627 @property
628 def full_contact(self):
628 def full_contact(self):
629 return '%s %s <%s>' % (self.firstname, self.lastname, self.email)
629 return '%s %s <%s>' % (self.firstname, self.lastname, self.email)
630
630
631 @property
631 @property
632 def short_contact(self):
632 def short_contact(self):
633 return '%s %s' % (self.firstname, self.lastname)
633 return '%s %s' % (self.firstname, self.lastname)
634
634
635 @property
635 @property
636 def is_admin(self):
636 def is_admin(self):
637 return self.admin
637 return self.admin
638
638
639 @property
639 @property
640 def AuthUser(self):
640 def AuthUser(self):
641 """
641 """
642 Returns instance of AuthUser for this user
642 Returns instance of AuthUser for this user
643 """
643 """
644 from rhodecode.lib.auth import AuthUser
644 from rhodecode.lib.auth import AuthUser
645 return AuthUser(user_id=self.user_id, api_key=self.api_key,
645 return AuthUser(user_id=self.user_id, api_key=self.api_key,
646 username=self.username)
646 username=self.username)
647
647
648 @hybrid_property
648 @hybrid_property
649 def user_data(self):
649 def user_data(self):
650 if not self._user_data:
650 if not self._user_data:
651 return {}
651 return {}
652
652
653 try:
653 try:
654 return json.loads(self._user_data)
654 return json.loads(self._user_data)
655 except TypeError:
655 except TypeError:
656 return {}
656 return {}
657
657
658 @user_data.setter
658 @user_data.setter
659 def user_data(self, val):
659 def user_data(self, val):
660 if not isinstance(val, dict):
660 if not isinstance(val, dict):
661 raise Exception('user_data must be dict, got %s' % type(val))
661 raise Exception('user_data must be dict, got %s' % type(val))
662 try:
662 try:
663 self._user_data = json.dumps(val)
663 self._user_data = json.dumps(val)
664 except Exception:
664 except Exception:
665 log.error(traceback.format_exc())
665 log.error(traceback.format_exc())
666
666
667 @classmethod
667 @classmethod
668 def get_by_username(cls, username, case_insensitive=False,
668 def get_by_username(cls, username, case_insensitive=False,
669 cache=False, identity_cache=False):
669 cache=False, identity_cache=False):
670 session = Session()
670 session = Session()
671
671
672 if case_insensitive:
672 if case_insensitive:
673 q = cls.query().filter(
673 q = cls.query().filter(
674 func.lower(cls.username) == func.lower(username))
674 func.lower(cls.username) == func.lower(username))
675 else:
675 else:
676 q = cls.query().filter(cls.username == username)
676 q = cls.query().filter(cls.username == username)
677
677
678 if cache:
678 if cache:
679 if identity_cache:
679 if identity_cache:
680 val = cls.identity_cache(session, 'username', username)
680 val = cls.identity_cache(session, 'username', username)
681 if val:
681 if val:
682 return val
682 return val
683 else:
683 else:
684 q = q.options(
684 q = q.options(
685 FromCache("sql_cache_short",
685 FromCache("sql_cache_short",
686 "get_user_by_name_%s" % _hash_key(username)))
686 "get_user_by_name_%s" % _hash_key(username)))
687
687
688 return q.scalar()
688 return q.scalar()
689
689
690 @classmethod
690 @classmethod
691 def get_by_auth_token(cls, auth_token, cache=False, fallback=True):
691 def get_by_auth_token(cls, auth_token, cache=False, fallback=True):
692 q = cls.query().filter(cls.api_key == auth_token)
692 q = cls.query().filter(cls.api_key == auth_token)
693
693
694 if cache:
694 if cache:
695 q = q.options(FromCache("sql_cache_short",
695 q = q.options(FromCache("sql_cache_short",
696 "get_auth_token_%s" % auth_token))
696 "get_auth_token_%s" % auth_token))
697 res = q.scalar()
697 res = q.scalar()
698
698
699 if fallback and not res:
699 if fallback and not res:
700 #fallback to additional keys
700 #fallback to additional keys
701 _res = UserApiKeys.query()\
701 _res = UserApiKeys.query()\
702 .filter(UserApiKeys.api_key == auth_token)\
702 .filter(UserApiKeys.api_key == auth_token)\
703 .filter(or_(UserApiKeys.expires == -1,
703 .filter(or_(UserApiKeys.expires == -1,
704 UserApiKeys.expires >= time.time()))\
704 UserApiKeys.expires >= time.time()))\
705 .first()
705 .first()
706 if _res:
706 if _res:
707 res = _res.user
707 res = _res.user
708 return res
708 return res
709
709
710 @classmethod
710 @classmethod
711 def get_by_email(cls, email, case_insensitive=False, cache=False):
711 def get_by_email(cls, email, case_insensitive=False, cache=False):
712
712
713 if case_insensitive:
713 if case_insensitive:
714 q = cls.query().filter(func.lower(cls.email) == func.lower(email))
714 q = cls.query().filter(func.lower(cls.email) == func.lower(email))
715
715
716 else:
716 else:
717 q = cls.query().filter(cls.email == email)
717 q = cls.query().filter(cls.email == email)
718
718
719 if cache:
719 if cache:
720 q = q.options(FromCache("sql_cache_short",
720 q = q.options(FromCache("sql_cache_short",
721 "get_email_key_%s" % _hash_key(email)))
721 "get_email_key_%s" % _hash_key(email)))
722
722
723 ret = q.scalar()
723 ret = q.scalar()
724 if ret is None:
724 if ret is None:
725 q = UserEmailMap.query()
725 q = UserEmailMap.query()
726 # try fetching in alternate email map
726 # try fetching in alternate email map
727 if case_insensitive:
727 if case_insensitive:
728 q = q.filter(func.lower(UserEmailMap.email) == func.lower(email))
728 q = q.filter(func.lower(UserEmailMap.email) == func.lower(email))
729 else:
729 else:
730 q = q.filter(UserEmailMap.email == email)
730 q = q.filter(UserEmailMap.email == email)
731 q = q.options(joinedload(UserEmailMap.user))
731 q = q.options(joinedload(UserEmailMap.user))
732 if cache:
732 if cache:
733 q = q.options(FromCache("sql_cache_short",
733 q = q.options(FromCache("sql_cache_short",
734 "get_email_map_key_%s" % email))
734 "get_email_map_key_%s" % email))
735 ret = getattr(q.scalar(), 'user', None)
735 ret = getattr(q.scalar(), 'user', None)
736
736
737 return ret
737 return ret
738
738
739 @classmethod
739 @classmethod
740 def get_from_cs_author(cls, author):
740 def get_from_cs_author(cls, author):
741 """
741 """
742 Tries to get User objects out of commit author string
742 Tries to get User objects out of commit author string
743
743
744 :param author:
744 :param author:
745 """
745 """
746 from rhodecode.lib.helpers import email, author_name
746 from rhodecode.lib.helpers import email, author_name
747 # Valid email in the attribute passed, see if they're in the system
747 # Valid email in the attribute passed, see if they're in the system
748 _email = email(author)
748 _email = email(author)
749 if _email:
749 if _email:
750 user = cls.get_by_email(_email, case_insensitive=True)
750 user = cls.get_by_email(_email, case_insensitive=True)
751 if user:
751 if user:
752 return user
752 return user
753 # Maybe we can match by username?
753 # Maybe we can match by username?
754 _author = author_name(author)
754 _author = author_name(author)
755 user = cls.get_by_username(_author, case_insensitive=True)
755 user = cls.get_by_username(_author, case_insensitive=True)
756 if user:
756 if user:
757 return user
757 return user
758
758
759 def update_userdata(self, **kwargs):
759 def update_userdata(self, **kwargs):
760 usr = self
760 usr = self
761 old = usr.user_data
761 old = usr.user_data
762 old.update(**kwargs)
762 old.update(**kwargs)
763 usr.user_data = old
763 usr.user_data = old
764 Session().add(usr)
764 Session().add(usr)
765 log.debug('updated userdata with ', kwargs)
765 log.debug('updated userdata with ', kwargs)
766
766
767 def update_lastlogin(self):
767 def update_lastlogin(self):
768 """Update user lastlogin"""
768 """Update user lastlogin"""
769 self.last_login = datetime.datetime.now()
769 self.last_login = datetime.datetime.now()
770 Session().add(self)
770 Session().add(self)
771 log.debug('updated user %s lastlogin', self.username)
771 log.debug('updated user %s lastlogin', self.username)
772
772
773 def update_lastactivity(self):
773 def update_lastactivity(self):
774 """Update user lastactivity"""
774 """Update user lastactivity"""
775 usr = self
775 usr = self
776 old = usr.user_data
776 old = usr.user_data
777 old.update({'last_activity': time.time()})
777 old.update({'last_activity': time.time()})
778 usr.user_data = old
778 usr.user_data = old
779 Session().add(usr)
779 Session().add(usr)
780 log.debug('updated user %s lastactivity', usr.username)
780 log.debug('updated user %s lastactivity', usr.username)
781
781
782 def update_password(self, new_password, change_api_key=False):
782 def update_password(self, new_password, change_api_key=False):
783 from rhodecode.lib.auth import get_crypt_password,generate_auth_token
783 from rhodecode.lib.auth import get_crypt_password,generate_auth_token
784
784
785 self.password = get_crypt_password(new_password)
785 self.password = get_crypt_password(new_password)
786 if change_api_key:
786 if change_api_key:
787 self.api_key = generate_auth_token(self.username)
787 self.api_key = generate_auth_token(self.username)
788 Session().add(self)
788 Session().add(self)
789
789
790 @classmethod
790 @classmethod
791 def get_first_super_admin(cls):
791 def get_first_super_admin(cls):
792 user = User.query().filter(User.admin == true()).first()
792 user = User.query().filter(User.admin == true()).first()
793 if user is None:
793 if user is None:
794 raise Exception('FATAL: Missing administrative account!')
794 raise Exception('FATAL: Missing administrative account!')
795 return user
795 return user
796
796
797 @classmethod
797 @classmethod
798 def get_all_super_admins(cls):
798 def get_all_super_admins(cls):
799 """
799 """
800 Returns all admin accounts sorted by username
800 Returns all admin accounts sorted by username
801 """
801 """
802 return User.query().filter(User.admin == true())\
802 return User.query().filter(User.admin == true())\
803 .order_by(User.username.asc()).all()
803 .order_by(User.username.asc()).all()
804
804
805 @classmethod
805 @classmethod
806 def get_default_user(cls, cache=False):
806 def get_default_user(cls, cache=False):
807 user = User.get_by_username(User.DEFAULT_USER, cache=cache)
807 user = User.get_by_username(User.DEFAULT_USER, cache=cache)
808 if user is None:
808 if user is None:
809 raise Exception('FATAL: Missing default account!')
809 raise Exception('FATAL: Missing default account!')
810 return user
810 return user
811
811
812 def _get_default_perms(self, user, suffix=''):
812 def _get_default_perms(self, user, suffix=''):
813 from rhodecode.model.permission import PermissionModel
813 from rhodecode.model.permission import PermissionModel
814 return PermissionModel().get_default_perms(user.user_perms, suffix)
814 return PermissionModel().get_default_perms(user.user_perms, suffix)
815
815
816 def get_default_perms(self, suffix=''):
816 def get_default_perms(self, suffix=''):
817 return self._get_default_perms(self, suffix)
817 return self._get_default_perms(self, suffix)
818
818
819 def get_api_data(self, include_secrets=False, details='full'):
819 def get_api_data(self, include_secrets=False, details='full'):
820 """
820 """
821 Common function for generating user related data for API
821 Common function for generating user related data for API
822
822
823 :param include_secrets: By default secrets in the API data will be replaced
823 :param include_secrets: By default secrets in the API data will be replaced
824 by a placeholder value to prevent exposing this data by accident. In case
824 by a placeholder value to prevent exposing this data by accident. In case
825 this data shall be exposed, set this flag to ``True``.
825 this data shall be exposed, set this flag to ``True``.
826
826
827 :param details: details can be 'basic|full' basic gives only a subset of
827 :param details: details can be 'basic|full' basic gives only a subset of
828 the available user information that includes user_id, name and emails.
828 the available user information that includes user_id, name and emails.
829 """
829 """
830 user = self
830 user = self
831 user_data = self.user_data
831 user_data = self.user_data
832 data = {
832 data = {
833 'user_id': user.user_id,
833 'user_id': user.user_id,
834 'username': user.username,
834 'username': user.username,
835 'firstname': user.name,
835 'firstname': user.name,
836 'lastname': user.lastname,
836 'lastname': user.lastname,
837 'email': user.email,
837 'email': user.email,
838 'emails': user.emails,
838 'emails': user.emails,
839 }
839 }
840 if details == 'basic':
840 if details == 'basic':
841 return data
841 return data
842
842
843 api_key_length = 40
843 api_key_length = 40
844 api_key_replacement = '*' * api_key_length
844 api_key_replacement = '*' * api_key_length
845
845
846 extras = {
846 extras = {
847 'api_key': api_key_replacement,
847 'api_key': api_key_replacement,
848 'api_keys': [api_key_replacement],
848 'api_keys': [api_key_replacement],
849 'active': user.active,
849 'active': user.active,
850 'admin': user.admin,
850 'admin': user.admin,
851 'extern_type': user.extern_type,
851 'extern_type': user.extern_type,
852 'extern_name': user.extern_name,
852 'extern_name': user.extern_name,
853 'last_login': user.last_login,
853 'last_login': user.last_login,
854 'ip_addresses': user.ip_addresses,
854 'ip_addresses': user.ip_addresses,
855 'language': user_data.get('language')
855 'language': user_data.get('language')
856 }
856 }
857 data.update(extras)
857 data.update(extras)
858
858
859 if include_secrets:
859 if include_secrets:
860 data['api_key'] = user.api_key
860 data['api_key'] = user.api_key
861 data['api_keys'] = user.auth_tokens
861 data['api_keys'] = user.auth_tokens
862 return data
862 return data
863
863
864 def __json__(self):
864 def __json__(self):
865 data = {
865 data = {
866 'full_name': self.full_name,
866 'full_name': self.full_name,
867 'full_name_or_username': self.full_name_or_username,
867 'full_name_or_username': self.full_name_or_username,
868 'short_contact': self.short_contact,
868 'short_contact': self.short_contact,
869 'full_contact': self.full_contact,
869 'full_contact': self.full_contact,
870 }
870 }
871 data.update(self.get_api_data())
871 data.update(self.get_api_data())
872 return data
872 return data
873
873
874
874
875 class UserApiKeys(Base, BaseModel):
875 class UserApiKeys(Base, BaseModel):
876 __tablename__ = 'user_api_keys'
876 __tablename__ = 'user_api_keys'
877 __table_args__ = (
877 __table_args__ = (
878 Index('uak_api_key_idx', 'api_key'),
878 Index('uak_api_key_idx', 'api_key'),
879 Index('uak_api_key_expires_idx', 'api_key', 'expires'),
879 Index('uak_api_key_expires_idx', 'api_key', 'expires'),
880 UniqueConstraint('api_key'),
880 UniqueConstraint('api_key'),
881 {'extend_existing': True, 'mysql_engine': 'InnoDB',
881 {'extend_existing': True, 'mysql_engine': 'InnoDB',
882 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
882 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
883 )
883 )
884 __mapper_args__ = {}
884 __mapper_args__ = {}
885
885
886 # ApiKey role
886 # ApiKey role
887 ROLE_ALL = 'token_role_all'
887 ROLE_ALL = 'token_role_all'
888 ROLE_HTTP = 'token_role_http'
888 ROLE_HTTP = 'token_role_http'
889 ROLE_VCS = 'token_role_vcs'
889 ROLE_VCS = 'token_role_vcs'
890 ROLE_API = 'token_role_api'
890 ROLE_API = 'token_role_api'
891 ROLE_FEED = 'token_role_feed'
891 ROLE_FEED = 'token_role_feed'
892 ROLES = [ROLE_ALL, ROLE_HTTP, ROLE_VCS, ROLE_API, ROLE_FEED]
892 ROLES = [ROLE_ALL, ROLE_HTTP, ROLE_VCS, ROLE_API, ROLE_FEED]
893
893
894 user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
894 user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
895 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
895 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
896 api_key = Column("api_key", String(255), nullable=False, unique=True)
896 api_key = Column("api_key", String(255), nullable=False, unique=True)
897 description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
897 description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
898 expires = Column('expires', Float(53), nullable=False)
898 expires = Column('expires', Float(53), nullable=False)
899 role = Column('role', String(255), nullable=True)
899 role = Column('role', String(255), nullable=True)
900 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
900 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
901
901
902 user = relationship('User', lazy='joined')
902 user = relationship('User', lazy='joined')
903
903
904 @classmethod
904 @classmethod
905 def _get_role_name(cls, role):
905 def _get_role_name(cls, role):
906 return {
906 return {
907 cls.ROLE_ALL: _('all'),
907 cls.ROLE_ALL: _('all'),
908 cls.ROLE_HTTP: _('http/web interface'),
908 cls.ROLE_HTTP: _('http/web interface'),
909 cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'),
909 cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'),
910 cls.ROLE_API: _('api calls'),
910 cls.ROLE_API: _('api calls'),
911 cls.ROLE_FEED: _('feed access'),
911 cls.ROLE_FEED: _('feed access'),
912 }.get(role, role)
912 }.get(role, role)
913
913
914 @property
914 @property
915 def expired(self):
915 def expired(self):
916 if self.expires == -1:
916 if self.expires == -1:
917 return False
917 return False
918 return time.time() > self.expires
918 return time.time() > self.expires
919
919
920 @property
920 @property
921 def role_humanized(self):
921 def role_humanized(self):
922 return self._get_role_name(self.role)
922 return self._get_role_name(self.role)
923
923
924
924
925 class UserEmailMap(Base, BaseModel):
925 class UserEmailMap(Base, BaseModel):
926 __tablename__ = 'user_email_map'
926 __tablename__ = 'user_email_map'
927 __table_args__ = (
927 __table_args__ = (
928 Index('uem_email_idx', 'email'),
928 Index('uem_email_idx', 'email'),
929 UniqueConstraint('email'),
929 UniqueConstraint('email'),
930 {'extend_existing': True, 'mysql_engine': 'InnoDB',
930 {'extend_existing': True, 'mysql_engine': 'InnoDB',
931 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
931 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
932 )
932 )
933 __mapper_args__ = {}
933 __mapper_args__ = {}
934
934
935 email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
935 email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
936 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
936 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
937 _email = Column("email", String(255), nullable=True, unique=False, default=None)
937 _email = Column("email", String(255), nullable=True, unique=False, default=None)
938 user = relationship('User', lazy='joined')
938 user = relationship('User', lazy='joined')
939
939
940 @validates('_email')
940 @validates('_email')
941 def validate_email(self, key, email):
941 def validate_email(self, key, email):
942 # check if this email is not main one
942 # check if this email is not main one
943 main_email = Session().query(User).filter(User.email == email).scalar()
943 main_email = Session().query(User).filter(User.email == email).scalar()
944 if main_email is not None:
944 if main_email is not None:
945 raise AttributeError('email %s is present is user table' % email)
945 raise AttributeError('email %s is present is user table' % email)
946 return email
946 return email
947
947
948 @hybrid_property
948 @hybrid_property
949 def email(self):
949 def email(self):
950 return self._email
950 return self._email
951
951
952 @email.setter
952 @email.setter
953 def email(self, val):
953 def email(self, val):
954 self._email = val.lower() if val else None
954 self._email = val.lower() if val else None
955
955
956
956
957 class UserIpMap(Base, BaseModel):
957 class UserIpMap(Base, BaseModel):
958 __tablename__ = 'user_ip_map'
958 __tablename__ = 'user_ip_map'
959 __table_args__ = (
959 __table_args__ = (
960 UniqueConstraint('user_id', 'ip_addr'),
960 UniqueConstraint('user_id', 'ip_addr'),
961 {'extend_existing': True, 'mysql_engine': 'InnoDB',
961 {'extend_existing': True, 'mysql_engine': 'InnoDB',
962 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
962 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
963 )
963 )
964 __mapper_args__ = {}
964 __mapper_args__ = {}
965
965
966 ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
966 ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
967 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
967 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
968 ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None)
968 ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None)
969 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
969 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
970 description = Column("description", String(10000), nullable=True, unique=None, default=None)
970 description = Column("description", String(10000), nullable=True, unique=None, default=None)
971 user = relationship('User', lazy='joined')
971 user = relationship('User', lazy='joined')
972
972
973 @classmethod
973 @classmethod
974 def _get_ip_range(cls, ip_addr):
974 def _get_ip_range(cls, ip_addr):
975 net = ipaddress.ip_network(ip_addr, strict=False)
975 net = ipaddress.ip_network(ip_addr, strict=False)
976 return [str(net.network_address), str(net.broadcast_address)]
976 return [str(net.network_address), str(net.broadcast_address)]
977
977
978 def __json__(self):
978 def __json__(self):
979 return {
979 return {
980 'ip_addr': self.ip_addr,
980 'ip_addr': self.ip_addr,
981 'ip_range': self._get_ip_range(self.ip_addr),
981 'ip_range': self._get_ip_range(self.ip_addr),
982 }
982 }
983
983
984 def __unicode__(self):
984 def __unicode__(self):
985 return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,
985 return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,
986 self.user_id, self.ip_addr)
986 self.user_id, self.ip_addr)
987
987
988 class UserLog(Base, BaseModel):
988 class UserLog(Base, BaseModel):
989 __tablename__ = 'user_logs'
989 __tablename__ = 'user_logs'
990 __table_args__ = (
990 __table_args__ = (
991 {'extend_existing': True, 'mysql_engine': 'InnoDB',
991 {'extend_existing': True, 'mysql_engine': 'InnoDB',
992 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
992 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
993 )
993 )
994 user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
994 user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
995 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
995 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
996 username = Column("username", String(255), nullable=True, unique=None, default=None)
996 username = Column("username", String(255), nullable=True, unique=None, default=None)
997 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True)
997 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True)
998 repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None)
998 repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None)
999 user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None)
999 user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None)
1000 action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None)
1000 action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None)
1001 action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)
1001 action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)
1002
1002
1003 def __unicode__(self):
1003 def __unicode__(self):
1004 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
1004 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
1005 self.repository_name,
1005 self.repository_name,
1006 self.action)
1006 self.action)
1007
1007
1008 @property
1008 @property
1009 def action_as_day(self):
1009 def action_as_day(self):
1010 return datetime.date(*self.action_date.timetuple()[:3])
1010 return datetime.date(*self.action_date.timetuple()[:3])
1011
1011
1012 user = relationship('User')
1012 user = relationship('User')
1013 repository = relationship('Repository', cascade='')
1013 repository = relationship('Repository', cascade='')
1014
1014
1015
1015
1016 class UserGroup(Base, BaseModel):
1016 class UserGroup(Base, BaseModel):
1017 __tablename__ = 'users_groups'
1017 __tablename__ = 'users_groups'
1018 __table_args__ = (
1018 __table_args__ = (
1019 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1019 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1020 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1020 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1021 )
1021 )
1022
1022
1023 users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1023 users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1024 users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None)
1024 users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None)
1025 user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None)
1025 user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None)
1026 users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
1026 users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
1027 inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
1027 inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
1028 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
1028 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
1029 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1029 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1030 _group_data = Column("group_data", LargeBinary(), nullable=True) # JSON data
1030 _group_data = Column("group_data", LargeBinary(), nullable=True) # JSON data
1031
1031
1032 members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
1032 members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
1033 users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
1033 users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
1034 users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
1034 users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
1035 users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
1035 users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
1036 user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all')
1036 user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all')
1037 user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all')
1037 user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all')
1038
1038
1039 user = relationship('User')
1039 user = relationship('User')
1040
1040
1041 @hybrid_property
1041 @hybrid_property
1042 def group_data(self):
1042 def group_data(self):
1043 if not self._group_data:
1043 if not self._group_data:
1044 return {}
1044 return {}
1045
1045
1046 try:
1046 try:
1047 return json.loads(self._group_data)
1047 return json.loads(self._group_data)
1048 except TypeError:
1048 except TypeError:
1049 return {}
1049 return {}
1050
1050
1051 @group_data.setter
1051 @group_data.setter
1052 def group_data(self, val):
1052 def group_data(self, val):
1053 try:
1053 try:
1054 self._group_data = json.dumps(val)
1054 self._group_data = json.dumps(val)
1055 except Exception:
1055 except Exception:
1056 log.error(traceback.format_exc())
1056 log.error(traceback.format_exc())
1057
1057
1058 def __unicode__(self):
1058 def __unicode__(self):
1059 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
1059 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
1060 self.users_group_id,
1060 self.users_group_id,
1061 self.users_group_name)
1061 self.users_group_name)
1062
1062
1063 @classmethod
1063 @classmethod
1064 def get_by_group_name(cls, group_name, cache=False,
1064 def get_by_group_name(cls, group_name, cache=False,
1065 case_insensitive=False):
1065 case_insensitive=False):
1066 if case_insensitive:
1066 if case_insensitive:
1067 q = cls.query().filter(func.lower(cls.users_group_name) ==
1067 q = cls.query().filter(func.lower(cls.users_group_name) ==
1068 func.lower(group_name))
1068 func.lower(group_name))
1069
1069
1070 else:
1070 else:
1071 q = cls.query().filter(cls.users_group_name == group_name)
1071 q = cls.query().filter(cls.users_group_name == group_name)
1072 if cache:
1072 if cache:
1073 q = q.options(FromCache(
1073 q = q.options(FromCache(
1074 "sql_cache_short",
1074 "sql_cache_short",
1075 "get_group_%s" % _hash_key(group_name)))
1075 "get_group_%s" % _hash_key(group_name)))
1076 return q.scalar()
1076 return q.scalar()
1077
1077
1078 @classmethod
1078 @classmethod
1079 def get(cls, user_group_id, cache=False):
1079 def get(cls, user_group_id, cache=False):
1080 user_group = cls.query()
1080 user_group = cls.query()
1081 if cache:
1081 if cache:
1082 user_group = user_group.options(FromCache("sql_cache_short",
1082 user_group = user_group.options(FromCache("sql_cache_short",
1083 "get_users_group_%s" % user_group_id))
1083 "get_users_group_%s" % user_group_id))
1084 return user_group.get(user_group_id)
1084 return user_group.get(user_group_id)
1085
1085
1086 def permissions(self, with_admins=True, with_owner=True):
1086 def permissions(self, with_admins=True, with_owner=True):
1087 q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self)
1087 q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self)
1088 q = q.options(joinedload(UserUserGroupToPerm.user_group),
1088 q = q.options(joinedload(UserUserGroupToPerm.user_group),
1089 joinedload(UserUserGroupToPerm.user),
1089 joinedload(UserUserGroupToPerm.user),
1090 joinedload(UserUserGroupToPerm.permission),)
1090 joinedload(UserUserGroupToPerm.permission),)
1091
1091
1092 # get owners and admins and permissions. We do a trick of re-writing
1092 # get owners and admins and permissions. We do a trick of re-writing
1093 # objects from sqlalchemy to named-tuples due to sqlalchemy session
1093 # objects from sqlalchemy to named-tuples due to sqlalchemy session
1094 # has a global reference and changing one object propagates to all
1094 # has a global reference and changing one object propagates to all
1095 # others. This means if admin is also an owner admin_row that change
1095 # others. This means if admin is also an owner admin_row that change
1096 # would propagate to both objects
1096 # would propagate to both objects
1097 perm_rows = []
1097 perm_rows = []
1098 for _usr in q.all():
1098 for _usr in q.all():
1099 usr = AttributeDict(_usr.user.get_dict())
1099 usr = AttributeDict(_usr.user.get_dict())
1100 usr.permission = _usr.permission.permission_name
1100 usr.permission = _usr.permission.permission_name
1101 perm_rows.append(usr)
1101 perm_rows.append(usr)
1102
1102
1103 # filter the perm rows by 'default' first and then sort them by
1103 # filter the perm rows by 'default' first and then sort them by
1104 # admin,write,read,none permissions sorted again alphabetically in
1104 # admin,write,read,none permissions sorted again alphabetically in
1105 # each group
1105 # each group
1106 perm_rows = sorted(perm_rows, key=display_sort)
1106 perm_rows = sorted(perm_rows, key=display_sort)
1107
1107
1108 _admin_perm = 'usergroup.admin'
1108 _admin_perm = 'usergroup.admin'
1109 owner_row = []
1109 owner_row = []
1110 if with_owner:
1110 if with_owner:
1111 usr = AttributeDict(self.user.get_dict())
1111 usr = AttributeDict(self.user.get_dict())
1112 usr.owner_row = True
1112 usr.owner_row = True
1113 usr.permission = _admin_perm
1113 usr.permission = _admin_perm
1114 owner_row.append(usr)
1114 owner_row.append(usr)
1115
1115
1116 super_admin_rows = []
1116 super_admin_rows = []
1117 if with_admins:
1117 if with_admins:
1118 for usr in User.get_all_super_admins():
1118 for usr in User.get_all_super_admins():
1119 # if this admin is also owner, don't double the record
1119 # if this admin is also owner, don't double the record
1120 if usr.user_id == owner_row[0].user_id:
1120 if usr.user_id == owner_row[0].user_id:
1121 owner_row[0].admin_row = True
1121 owner_row[0].admin_row = True
1122 else:
1122 else:
1123 usr = AttributeDict(usr.get_dict())
1123 usr = AttributeDict(usr.get_dict())
1124 usr.admin_row = True
1124 usr.admin_row = True
1125 usr.permission = _admin_perm
1125 usr.permission = _admin_perm
1126 super_admin_rows.append(usr)
1126 super_admin_rows.append(usr)
1127
1127
1128 return super_admin_rows + owner_row + perm_rows
1128 return super_admin_rows + owner_row + perm_rows
1129
1129
1130 def permission_user_groups(self):
1130 def permission_user_groups(self):
1131 q = UserGroupUserGroupToPerm.query().filter(UserGroupUserGroupToPerm.target_user_group == self)
1131 q = UserGroupUserGroupToPerm.query().filter(UserGroupUserGroupToPerm.target_user_group == self)
1132 q = q.options(joinedload(UserGroupUserGroupToPerm.user_group),
1132 q = q.options(joinedload(UserGroupUserGroupToPerm.user_group),
1133 joinedload(UserGroupUserGroupToPerm.target_user_group),
1133 joinedload(UserGroupUserGroupToPerm.target_user_group),
1134 joinedload(UserGroupUserGroupToPerm.permission),)
1134 joinedload(UserGroupUserGroupToPerm.permission),)
1135
1135
1136 perm_rows = []
1136 perm_rows = []
1137 for _user_group in q.all():
1137 for _user_group in q.all():
1138 usr = AttributeDict(_user_group.user_group.get_dict())
1138 usr = AttributeDict(_user_group.user_group.get_dict())
1139 usr.permission = _user_group.permission.permission_name
1139 usr.permission = _user_group.permission.permission_name
1140 perm_rows.append(usr)
1140 perm_rows.append(usr)
1141
1141
1142 return perm_rows
1142 return perm_rows
1143
1143
1144 def _get_default_perms(self, user_group, suffix=''):
1144 def _get_default_perms(self, user_group, suffix=''):
1145 from rhodecode.model.permission import PermissionModel
1145 from rhodecode.model.permission import PermissionModel
1146 return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix)
1146 return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix)
1147
1147
1148 def get_default_perms(self, suffix=''):
1148 def get_default_perms(self, suffix=''):
1149 return self._get_default_perms(self, suffix)
1149 return self._get_default_perms(self, suffix)
1150
1150
1151 def get_api_data(self, with_group_members=True, include_secrets=False):
1151 def get_api_data(self, with_group_members=True, include_secrets=False):
1152 """
1152 """
1153 :param include_secrets: See :meth:`User.get_api_data`, this parameter is
1153 :param include_secrets: See :meth:`User.get_api_data`, this parameter is
1154 basically forwarded.
1154 basically forwarded.
1155
1155
1156 """
1156 """
1157 user_group = self
1157 user_group = self
1158
1158
1159 data = {
1159 data = {
1160 'users_group_id': user_group.users_group_id,
1160 'users_group_id': user_group.users_group_id,
1161 'group_name': user_group.users_group_name,
1161 'group_name': user_group.users_group_name,
1162 'group_description': user_group.user_group_description,
1162 'group_description': user_group.user_group_description,
1163 'active': user_group.users_group_active,
1163 'active': user_group.users_group_active,
1164 'owner': user_group.user.username,
1164 'owner': user_group.user.username,
1165 }
1165 }
1166 if with_group_members:
1166 if with_group_members:
1167 users = []
1167 users = []
1168 for user in user_group.members:
1168 for user in user_group.members:
1169 user = user.user
1169 user = user.user
1170 users.append(user.get_api_data(include_secrets=include_secrets))
1170 users.append(user.get_api_data(include_secrets=include_secrets))
1171 data['users'] = users
1171 data['users'] = users
1172
1172
1173 return data
1173 return data
1174
1174
1175
1175
1176 class UserGroupMember(Base, BaseModel):
1176 class UserGroupMember(Base, BaseModel):
1177 __tablename__ = 'users_groups_members'
1177 __tablename__ = 'users_groups_members'
1178 __table_args__ = (
1178 __table_args__ = (
1179 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1179 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1180 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1180 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1181 )
1181 )
1182
1182
1183 users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1183 users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1184 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
1184 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
1185 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
1185 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
1186
1186
1187 user = relationship('User', lazy='joined')
1187 user = relationship('User', lazy='joined')
1188 users_group = relationship('UserGroup')
1188 users_group = relationship('UserGroup')
1189
1189
1190 def __init__(self, gr_id='', u_id=''):
1190 def __init__(self, gr_id='', u_id=''):
1191 self.users_group_id = gr_id
1191 self.users_group_id = gr_id
1192 self.user_id = u_id
1192 self.user_id = u_id
1193
1193
1194
1194
1195 class RepositoryField(Base, BaseModel):
1195 class RepositoryField(Base, BaseModel):
1196 __tablename__ = 'repositories_fields'
1196 __tablename__ = 'repositories_fields'
1197 __table_args__ = (
1197 __table_args__ = (
1198 UniqueConstraint('repository_id', 'field_key'), # no-multi field
1198 UniqueConstraint('repository_id', 'field_key'), # no-multi field
1199 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1199 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1200 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1200 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1201 )
1201 )
1202 PREFIX = 'ex_' # prefix used in form to not conflict with already existing fields
1202 PREFIX = 'ex_' # prefix used in form to not conflict with already existing fields
1203
1203
1204 repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1204 repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1205 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
1205 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
1206 field_key = Column("field_key", String(250))
1206 field_key = Column("field_key", String(250))
1207 field_label = Column("field_label", String(1024), nullable=False)
1207 field_label = Column("field_label", String(1024), nullable=False)
1208 field_value = Column("field_value", String(10000), nullable=False)
1208 field_value = Column("field_value", String(10000), nullable=False)
1209 field_desc = Column("field_desc", String(1024), nullable=False)
1209 field_desc = Column("field_desc", String(1024), nullable=False)
1210 field_type = Column("field_type", String(255), nullable=False, unique=None)
1210 field_type = Column("field_type", String(255), nullable=False, unique=None)
1211 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1211 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1212
1212
1213 repository = relationship('Repository')
1213 repository = relationship('Repository')
1214
1214
1215 @property
1215 @property
1216 def field_key_prefixed(self):
1216 def field_key_prefixed(self):
1217 return 'ex_%s' % self.field_key
1217 return 'ex_%s' % self.field_key
1218
1218
1219 @classmethod
1219 @classmethod
1220 def un_prefix_key(cls, key):
1220 def un_prefix_key(cls, key):
1221 if key.startswith(cls.PREFIX):
1221 if key.startswith(cls.PREFIX):
1222 return key[len(cls.PREFIX):]
1222 return key[len(cls.PREFIX):]
1223 return key
1223 return key
1224
1224
1225 @classmethod
1225 @classmethod
1226 def get_by_key_name(cls, key, repo):
1226 def get_by_key_name(cls, key, repo):
1227 row = cls.query()\
1227 row = cls.query()\
1228 .filter(cls.repository == repo)\
1228 .filter(cls.repository == repo)\
1229 .filter(cls.field_key == key).scalar()
1229 .filter(cls.field_key == key).scalar()
1230 return row
1230 return row
1231
1231
1232
1232
1233 class Repository(Base, BaseModel):
1233 class Repository(Base, BaseModel):
1234 __tablename__ = 'repositories'
1234 __tablename__ = 'repositories'
1235 __table_args__ = (
1235 __table_args__ = (
1236 Index('r_repo_name_idx', 'repo_name', mysql_length=255),
1236 Index('r_repo_name_idx', 'repo_name', mysql_length=255),
1237 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1237 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1238 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1238 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1239 )
1239 )
1240 DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'
1240 DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'
1241 DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'
1241 DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'
1242
1242
1243 STATE_CREATED = 'repo_state_created'
1243 STATE_CREATED = 'repo_state_created'
1244 STATE_PENDING = 'repo_state_pending'
1244 STATE_PENDING = 'repo_state_pending'
1245 STATE_ERROR = 'repo_state_error'
1245 STATE_ERROR = 'repo_state_error'
1246
1246
1247 LOCK_AUTOMATIC = 'lock_auto'
1247 LOCK_AUTOMATIC = 'lock_auto'
1248 LOCK_API = 'lock_api'
1248 LOCK_API = 'lock_api'
1249 LOCK_WEB = 'lock_web'
1249 LOCK_WEB = 'lock_web'
1250 LOCK_PULL = 'lock_pull'
1250 LOCK_PULL = 'lock_pull'
1251
1251
1252 NAME_SEP = URL_SEP
1252 NAME_SEP = URL_SEP
1253
1253
1254 repo_id = Column(
1254 repo_id = Column(
1255 "repo_id", Integer(), nullable=False, unique=True, default=None,
1255 "repo_id", Integer(), nullable=False, unique=True, default=None,
1256 primary_key=True)
1256 primary_key=True)
1257 _repo_name = Column(
1257 _repo_name = Column(
1258 "repo_name", Text(), nullable=False, default=None)
1258 "repo_name", Text(), nullable=False, default=None)
1259 _repo_name_hash = Column(
1259 _repo_name_hash = Column(
1260 "repo_name_hash", String(255), nullable=False, unique=True)
1260 "repo_name_hash", String(255), nullable=False, unique=True)
1261 repo_state = Column("repo_state", String(255), nullable=True)
1261 repo_state = Column("repo_state", String(255), nullable=True)
1262
1262
1263 clone_uri = Column(
1263 clone_uri = Column(
1264 "clone_uri", EncryptedTextValue(), nullable=True, unique=False,
1264 "clone_uri", EncryptedTextValue(), nullable=True, unique=False,
1265 default=None)
1265 default=None)
1266 repo_type = Column(
1266 repo_type = Column(
1267 "repo_type", String(255), nullable=False, unique=False, default=None)
1267 "repo_type", String(255), nullable=False, unique=False, default=None)
1268 user_id = Column(
1268 user_id = Column(
1269 "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
1269 "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
1270 unique=False, default=None)
1270 unique=False, default=None)
1271 private = Column(
1271 private = Column(
1272 "private", Boolean(), nullable=True, unique=None, default=None)
1272 "private", Boolean(), nullable=True, unique=None, default=None)
1273 enable_statistics = Column(
1273 enable_statistics = Column(
1274 "statistics", Boolean(), nullable=True, unique=None, default=True)
1274 "statistics", Boolean(), nullable=True, unique=None, default=True)
1275 enable_downloads = Column(
1275 enable_downloads = Column(
1276 "downloads", Boolean(), nullable=True, unique=None, default=True)
1276 "downloads", Boolean(), nullable=True, unique=None, default=True)
1277 description = Column(
1277 description = Column(
1278 "description", String(10000), nullable=True, unique=None, default=None)
1278 "description", String(10000), nullable=True, unique=None, default=None)
1279 created_on = Column(
1279 created_on = Column(
1280 'created_on', DateTime(timezone=False), nullable=True, unique=None,
1280 'created_on', DateTime(timezone=False), nullable=True, unique=None,
1281 default=datetime.datetime.now)
1281 default=datetime.datetime.now)
1282 updated_on = Column(
1282 updated_on = Column(
1283 'updated_on', DateTime(timezone=False), nullable=True, unique=None,
1283 'updated_on', DateTime(timezone=False), nullable=True, unique=None,
1284 default=datetime.datetime.now)
1284 default=datetime.datetime.now)
1285 _landing_revision = Column(
1285 _landing_revision = Column(
1286 "landing_revision", String(255), nullable=False, unique=False,
1286 "landing_revision", String(255), nullable=False, unique=False,
1287 default=None)
1287 default=None)
1288 enable_locking = Column(
1288 enable_locking = Column(
1289 "enable_locking", Boolean(), nullable=False, unique=None,
1289 "enable_locking", Boolean(), nullable=False, unique=None,
1290 default=False)
1290 default=False)
1291 _locked = Column(
1291 _locked = Column(
1292 "locked", String(255), nullable=True, unique=False, default=None)
1292 "locked", String(255), nullable=True, unique=False, default=None)
1293 _changeset_cache = Column(
1293 _changeset_cache = Column(
1294 "changeset_cache", LargeBinary(), nullable=True) # JSON data
1294 "changeset_cache", LargeBinary(), nullable=True) # JSON data
1295
1295
1296 fork_id = Column(
1296 fork_id = Column(
1297 "fork_id", Integer(), ForeignKey('repositories.repo_id'),
1297 "fork_id", Integer(), ForeignKey('repositories.repo_id'),
1298 nullable=True, unique=False, default=None)
1298 nullable=True, unique=False, default=None)
1299 group_id = Column(
1299 group_id = Column(
1300 "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True,
1300 "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True,
1301 unique=False, default=None)
1301 unique=False, default=None)
1302
1302
1303 user = relationship('User', lazy='joined')
1303 user = relationship('User', lazy='joined')
1304 fork = relationship('Repository', remote_side=repo_id, lazy='joined')
1304 fork = relationship('Repository', remote_side=repo_id, lazy='joined')
1305 group = relationship('RepoGroup', lazy='joined')
1305 group = relationship('RepoGroup', lazy='joined')
1306 repo_to_perm = relationship(
1306 repo_to_perm = relationship(
1307 'UserRepoToPerm', cascade='all',
1307 'UserRepoToPerm', cascade='all',
1308 order_by='UserRepoToPerm.repo_to_perm_id')
1308 order_by='UserRepoToPerm.repo_to_perm_id')
1309 users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
1309 users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
1310 stats = relationship('Statistics', cascade='all', uselist=False)
1310 stats = relationship('Statistics', cascade='all', uselist=False)
1311
1311
1312 followers = relationship(
1312 followers = relationship(
1313 'UserFollowing',
1313 'UserFollowing',
1314 primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id',
1314 primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id',
1315 cascade='all')
1315 cascade='all')
1316 extra_fields = relationship(
1316 extra_fields = relationship(
1317 'RepositoryField', cascade="all, delete, delete-orphan")
1317 'RepositoryField', cascade="all, delete, delete-orphan")
1318 logs = relationship('UserLog')
1318 logs = relationship('UserLog')
1319 comments = relationship(
1319 comments = relationship(
1320 'ChangesetComment', cascade="all, delete, delete-orphan")
1320 'ChangesetComment', cascade="all, delete, delete-orphan")
1321 pull_requests_source = relationship(
1321 pull_requests_source = relationship(
1322 'PullRequest',
1322 'PullRequest',
1323 primaryjoin='PullRequest.source_repo_id==Repository.repo_id',
1323 primaryjoin='PullRequest.source_repo_id==Repository.repo_id',
1324 cascade="all, delete, delete-orphan")
1324 cascade="all, delete, delete-orphan")
1325 pull_requests_target = relationship(
1325 pull_requests_target = relationship(
1326 'PullRequest',
1326 'PullRequest',
1327 primaryjoin='PullRequest.target_repo_id==Repository.repo_id',
1327 primaryjoin='PullRequest.target_repo_id==Repository.repo_id',
1328 cascade="all, delete, delete-orphan")
1328 cascade="all, delete, delete-orphan")
1329 ui = relationship('RepoRhodeCodeUi', cascade="all")
1329 ui = relationship('RepoRhodeCodeUi', cascade="all")
1330 settings = relationship('RepoRhodeCodeSetting', cascade="all")
1330 settings = relationship('RepoRhodeCodeSetting', cascade="all")
1331 integrations = relationship('Integration',
1331 integrations = relationship('Integration',
1332 cascade="all, delete, delete-orphan")
1332 cascade="all, delete, delete-orphan")
1333
1333
1334 def __unicode__(self):
1334 def __unicode__(self):
1335 return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,
1335 return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,
1336 safe_unicode(self.repo_name))
1336 safe_unicode(self.repo_name))
1337
1337
1338 @hybrid_property
1338 @hybrid_property
1339 def landing_rev(self):
1339 def landing_rev(self):
1340 # always should return [rev_type, rev]
1340 # always should return [rev_type, rev]
1341 if self._landing_revision:
1341 if self._landing_revision:
1342 _rev_info = self._landing_revision.split(':')
1342 _rev_info = self._landing_revision.split(':')
1343 if len(_rev_info) < 2:
1343 if len(_rev_info) < 2:
1344 _rev_info.insert(0, 'rev')
1344 _rev_info.insert(0, 'rev')
1345 return [_rev_info[0], _rev_info[1]]
1345 return [_rev_info[0], _rev_info[1]]
1346 return [None, None]
1346 return [None, None]
1347
1347
1348 @landing_rev.setter
1348 @landing_rev.setter
1349 def landing_rev(self, val):
1349 def landing_rev(self, val):
1350 if ':' not in val:
1350 if ':' not in val:
1351 raise ValueError('value must be delimited with `:` and consist '
1351 raise ValueError('value must be delimited with `:` and consist '
1352 'of <rev_type>:<rev>, got %s instead' % val)
1352 'of <rev_type>:<rev>, got %s instead' % val)
1353 self._landing_revision = val
1353 self._landing_revision = val
1354
1354
1355 @hybrid_property
1355 @hybrid_property
1356 def locked(self):
1356 def locked(self):
1357 if self._locked:
1357 if self._locked:
1358 user_id, timelocked, reason = self._locked.split(':')
1358 user_id, timelocked, reason = self._locked.split(':')
1359 lock_values = int(user_id), timelocked, reason
1359 lock_values = int(user_id), timelocked, reason
1360 else:
1360 else:
1361 lock_values = [None, None, None]
1361 lock_values = [None, None, None]
1362 return lock_values
1362 return lock_values
1363
1363
1364 @locked.setter
1364 @locked.setter
1365 def locked(self, val):
1365 def locked(self, val):
1366 if val and isinstance(val, (list, tuple)):
1366 if val and isinstance(val, (list, tuple)):
1367 self._locked = ':'.join(map(str, val))
1367 self._locked = ':'.join(map(str, val))
1368 else:
1368 else:
1369 self._locked = None
1369 self._locked = None
1370
1370
1371 @hybrid_property
1371 @hybrid_property
1372 def changeset_cache(self):
1372 def changeset_cache(self):
1373 from rhodecode.lib.vcs.backends.base import EmptyCommit
1373 from rhodecode.lib.vcs.backends.base import EmptyCommit
1374 dummy = EmptyCommit().__json__()
1374 dummy = EmptyCommit().__json__()
1375 if not self._changeset_cache:
1375 if not self._changeset_cache:
1376 return dummy
1376 return dummy
1377 try:
1377 try:
1378 return json.loads(self._changeset_cache)
1378 return json.loads(self._changeset_cache)
1379 except TypeError:
1379 except TypeError:
1380 return dummy
1380 return dummy
1381 except Exception:
1381 except Exception:
1382 log.error(traceback.format_exc())
1382 log.error(traceback.format_exc())
1383 return dummy
1383 return dummy
1384
1384
1385 @changeset_cache.setter
1385 @changeset_cache.setter
1386 def changeset_cache(self, val):
1386 def changeset_cache(self, val):
1387 try:
1387 try:
1388 self._changeset_cache = json.dumps(val)
1388 self._changeset_cache = json.dumps(val)
1389 except Exception:
1389 except Exception:
1390 log.error(traceback.format_exc())
1390 log.error(traceback.format_exc())
1391
1391
1392 @hybrid_property
1392 @hybrid_property
1393 def repo_name(self):
1393 def repo_name(self):
1394 return self._repo_name
1394 return self._repo_name
1395
1395
1396 @repo_name.setter
1396 @repo_name.setter
1397 def repo_name(self, value):
1397 def repo_name(self, value):
1398 self._repo_name = value
1398 self._repo_name = value
1399 self._repo_name_hash = hashlib.sha1(safe_str(value)).hexdigest()
1399 self._repo_name_hash = hashlib.sha1(safe_str(value)).hexdigest()
1400
1400
1401 @classmethod
1401 @classmethod
1402 def normalize_repo_name(cls, repo_name):
1402 def normalize_repo_name(cls, repo_name):
1403 """
1403 """
1404 Normalizes os specific repo_name to the format internally stored inside
1404 Normalizes os specific repo_name to the format internally stored inside
1405 database using URL_SEP
1405 database using URL_SEP
1406
1406
1407 :param cls:
1407 :param cls:
1408 :param repo_name:
1408 :param repo_name:
1409 """
1409 """
1410 return cls.NAME_SEP.join(repo_name.split(os.sep))
1410 return cls.NAME_SEP.join(repo_name.split(os.sep))
1411
1411
1412 @classmethod
1412 @classmethod
1413 def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False):
1413 def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False):
1414 session = Session()
1414 session = Session()
1415 q = session.query(cls).filter(cls.repo_name == repo_name)
1415 q = session.query(cls).filter(cls.repo_name == repo_name)
1416
1416
1417 if cache:
1417 if cache:
1418 if identity_cache:
1418 if identity_cache:
1419 val = cls.identity_cache(session, 'repo_name', repo_name)
1419 val = cls.identity_cache(session, 'repo_name', repo_name)
1420 if val:
1420 if val:
1421 return val
1421 return val
1422 else:
1422 else:
1423 q = q.options(
1423 q = q.options(
1424 FromCache("sql_cache_short",
1424 FromCache("sql_cache_short",
1425 "get_repo_by_name_%s" % _hash_key(repo_name)))
1425 "get_repo_by_name_%s" % _hash_key(repo_name)))
1426
1426
1427 return q.scalar()
1427 return q.scalar()
1428
1428
1429 @classmethod
1429 @classmethod
1430 def get_by_full_path(cls, repo_full_path):
1430 def get_by_full_path(cls, repo_full_path):
1431 repo_name = repo_full_path.split(cls.base_path(), 1)[-1]
1431 repo_name = repo_full_path.split(cls.base_path(), 1)[-1]
1432 repo_name = cls.normalize_repo_name(repo_name)
1432 repo_name = cls.normalize_repo_name(repo_name)
1433 return cls.get_by_repo_name(repo_name.strip(URL_SEP))
1433 return cls.get_by_repo_name(repo_name.strip(URL_SEP))
1434
1434
1435 @classmethod
1435 @classmethod
1436 def get_repo_forks(cls, repo_id):
1436 def get_repo_forks(cls, repo_id):
1437 return cls.query().filter(Repository.fork_id == repo_id)
1437 return cls.query().filter(Repository.fork_id == repo_id)
1438
1438
1439 @classmethod
1439 @classmethod
1440 def base_path(cls):
1440 def base_path(cls):
1441 """
1441 """
1442 Returns base path when all repos are stored
1442 Returns base path when all repos are stored
1443
1443
1444 :param cls:
1444 :param cls:
1445 """
1445 """
1446 q = Session().query(RhodeCodeUi)\
1446 q = Session().query(RhodeCodeUi)\
1447 .filter(RhodeCodeUi.ui_key == cls.NAME_SEP)
1447 .filter(RhodeCodeUi.ui_key == cls.NAME_SEP)
1448 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
1448 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
1449 return q.one().ui_value
1449 return q.one().ui_value
1450
1450
1451 @classmethod
1451 @classmethod
1452 def is_valid(cls, repo_name):
1452 def is_valid(cls, repo_name):
1453 """
1453 """
1454 returns True if given repo name is a valid filesystem repository
1454 returns True if given repo name is a valid filesystem repository
1455
1455
1456 :param cls:
1456 :param cls:
1457 :param repo_name:
1457 :param repo_name:
1458 """
1458 """
1459 from rhodecode.lib.utils import is_valid_repo
1459 from rhodecode.lib.utils import is_valid_repo
1460
1460
1461 return is_valid_repo(repo_name, cls.base_path())
1461 return is_valid_repo(repo_name, cls.base_path())
1462
1462
1463 @classmethod
1463 @classmethod
1464 def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None),
1464 def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None),
1465 case_insensitive=True):
1465 case_insensitive=True):
1466 q = Repository.query()
1466 q = Repository.query()
1467
1467
1468 if not isinstance(user_id, Optional):
1468 if not isinstance(user_id, Optional):
1469 q = q.filter(Repository.user_id == user_id)
1469 q = q.filter(Repository.user_id == user_id)
1470
1470
1471 if not isinstance(group_id, Optional):
1471 if not isinstance(group_id, Optional):
1472 q = q.filter(Repository.group_id == group_id)
1472 q = q.filter(Repository.group_id == group_id)
1473
1473
1474 if case_insensitive:
1474 if case_insensitive:
1475 q = q.order_by(func.lower(Repository.repo_name))
1475 q = q.order_by(func.lower(Repository.repo_name))
1476 else:
1476 else:
1477 q = q.order_by(Repository.repo_name)
1477 q = q.order_by(Repository.repo_name)
1478 return q.all()
1478 return q.all()
1479
1479
1480 @property
1480 @property
1481 def forks(self):
1481 def forks(self):
1482 """
1482 """
1483 Return forks of this repo
1483 Return forks of this repo
1484 """
1484 """
1485 return Repository.get_repo_forks(self.repo_id)
1485 return Repository.get_repo_forks(self.repo_id)
1486
1486
1487 @property
1487 @property
1488 def parent(self):
1488 def parent(self):
1489 """
1489 """
1490 Returns fork parent
1490 Returns fork parent
1491 """
1491 """
1492 return self.fork
1492 return self.fork
1493
1493
1494 @property
1494 @property
1495 def just_name(self):
1495 def just_name(self):
1496 return self.repo_name.split(self.NAME_SEP)[-1]
1496 return self.repo_name.split(self.NAME_SEP)[-1]
1497
1497
1498 @property
1498 @property
1499 def groups_with_parents(self):
1499 def groups_with_parents(self):
1500 groups = []
1500 groups = []
1501 if self.group is None:
1501 if self.group is None:
1502 return groups
1502 return groups
1503
1503
1504 cur_gr = self.group
1504 cur_gr = self.group
1505 groups.insert(0, cur_gr)
1505 groups.insert(0, cur_gr)
1506 while 1:
1506 while 1:
1507 gr = getattr(cur_gr, 'parent_group', None)
1507 gr = getattr(cur_gr, 'parent_group', None)
1508 cur_gr = cur_gr.parent_group
1508 cur_gr = cur_gr.parent_group
1509 if gr is None:
1509 if gr is None:
1510 break
1510 break
1511 groups.insert(0, gr)
1511 groups.insert(0, gr)
1512
1512
1513 return groups
1513 return groups
1514
1514
1515 @property
1515 @property
1516 def groups_and_repo(self):
1516 def groups_and_repo(self):
1517 return self.groups_with_parents, self
1517 return self.groups_with_parents, self
1518
1518
1519 @LazyProperty
1519 @LazyProperty
1520 def repo_path(self):
1520 def repo_path(self):
1521 """
1521 """
1522 Returns base full path for that repository means where it actually
1522 Returns base full path for that repository means where it actually
1523 exists on a filesystem
1523 exists on a filesystem
1524 """
1524 """
1525 q = Session().query(RhodeCodeUi).filter(
1525 q = Session().query(RhodeCodeUi).filter(
1526 RhodeCodeUi.ui_key == self.NAME_SEP)
1526 RhodeCodeUi.ui_key == self.NAME_SEP)
1527 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
1527 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
1528 return q.one().ui_value
1528 return q.one().ui_value
1529
1529
1530 @property
1530 @property
1531 def repo_full_path(self):
1531 def repo_full_path(self):
1532 p = [self.repo_path]
1532 p = [self.repo_path]
1533 # we need to split the name by / since this is how we store the
1533 # we need to split the name by / since this is how we store the
1534 # names in the database, but that eventually needs to be converted
1534 # names in the database, but that eventually needs to be converted
1535 # into a valid system path
1535 # into a valid system path
1536 p += self.repo_name.split(self.NAME_SEP)
1536 p += self.repo_name.split(self.NAME_SEP)
1537 return os.path.join(*map(safe_unicode, p))
1537 return os.path.join(*map(safe_unicode, p))
1538
1538
1539 @property
1539 @property
1540 def cache_keys(self):
1540 def cache_keys(self):
1541 """
1541 """
1542 Returns associated cache keys for that repo
1542 Returns associated cache keys for that repo
1543 """
1543 """
1544 return CacheKey.query()\
1544 return CacheKey.query()\
1545 .filter(CacheKey.cache_args == self.repo_name)\
1545 .filter(CacheKey.cache_args == self.repo_name)\
1546 .order_by(CacheKey.cache_key)\
1546 .order_by(CacheKey.cache_key)\
1547 .all()
1547 .all()
1548
1548
1549 def get_new_name(self, repo_name):
1549 def get_new_name(self, repo_name):
1550 """
1550 """
1551 returns new full repository name based on assigned group and new new
1551 returns new full repository name based on assigned group and new new
1552
1552
1553 :param group_name:
1553 :param group_name:
1554 """
1554 """
1555 path_prefix = self.group.full_path_splitted if self.group else []
1555 path_prefix = self.group.full_path_splitted if self.group else []
1556 return self.NAME_SEP.join(path_prefix + [repo_name])
1556 return self.NAME_SEP.join(path_prefix + [repo_name])
1557
1557
1558 @property
1558 @property
1559 def _config(self):
1559 def _config(self):
1560 """
1560 """
1561 Returns db based config object.
1561 Returns db based config object.
1562 """
1562 """
1563 from rhodecode.lib.utils import make_db_config
1563 from rhodecode.lib.utils import make_db_config
1564 return make_db_config(clear_session=False, repo=self)
1564 return make_db_config(clear_session=False, repo=self)
1565
1565
1566 def permissions(self, with_admins=True, with_owner=True):
1566 def permissions(self, with_admins=True, with_owner=True):
1567 q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self)
1567 q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self)
1568 q = q.options(joinedload(UserRepoToPerm.repository),
1568 q = q.options(joinedload(UserRepoToPerm.repository),
1569 joinedload(UserRepoToPerm.user),
1569 joinedload(UserRepoToPerm.user),
1570 joinedload(UserRepoToPerm.permission),)
1570 joinedload(UserRepoToPerm.permission),)
1571
1571
1572 # get owners and admins and permissions. We do a trick of re-writing
1572 # get owners and admins and permissions. We do a trick of re-writing
1573 # objects from sqlalchemy to named-tuples due to sqlalchemy session
1573 # objects from sqlalchemy to named-tuples due to sqlalchemy session
1574 # has a global reference and changing one object propagates to all
1574 # has a global reference and changing one object propagates to all
1575 # others. This means if admin is also an owner admin_row that change
1575 # others. This means if admin is also an owner admin_row that change
1576 # would propagate to both objects
1576 # would propagate to both objects
1577 perm_rows = []
1577 perm_rows = []
1578 for _usr in q.all():
1578 for _usr in q.all():
1579 usr = AttributeDict(_usr.user.get_dict())
1579 usr = AttributeDict(_usr.user.get_dict())
1580 usr.permission = _usr.permission.permission_name
1580 usr.permission = _usr.permission.permission_name
1581 perm_rows.append(usr)
1581 perm_rows.append(usr)
1582
1582
1583 # filter the perm rows by 'default' first and then sort them by
1583 # filter the perm rows by 'default' first and then sort them by
1584 # admin,write,read,none permissions sorted again alphabetically in
1584 # admin,write,read,none permissions sorted again alphabetically in
1585 # each group
1585 # each group
1586 perm_rows = sorted(perm_rows, key=display_sort)
1586 perm_rows = sorted(perm_rows, key=display_sort)
1587
1587
1588 _admin_perm = 'repository.admin'
1588 _admin_perm = 'repository.admin'
1589 owner_row = []
1589 owner_row = []
1590 if with_owner:
1590 if with_owner:
1591 usr = AttributeDict(self.user.get_dict())
1591 usr = AttributeDict(self.user.get_dict())
1592 usr.owner_row = True
1592 usr.owner_row = True
1593 usr.permission = _admin_perm
1593 usr.permission = _admin_perm
1594 owner_row.append(usr)
1594 owner_row.append(usr)
1595
1595
1596 super_admin_rows = []
1596 super_admin_rows = []
1597 if with_admins:
1597 if with_admins:
1598 for usr in User.get_all_super_admins():
1598 for usr in User.get_all_super_admins():
1599 # if this admin is also owner, don't double the record
1599 # if this admin is also owner, don't double the record
1600 if usr.user_id == owner_row[0].user_id:
1600 if usr.user_id == owner_row[0].user_id:
1601 owner_row[0].admin_row = True
1601 owner_row[0].admin_row = True
1602 else:
1602 else:
1603 usr = AttributeDict(usr.get_dict())
1603 usr = AttributeDict(usr.get_dict())
1604 usr.admin_row = True
1604 usr.admin_row = True
1605 usr.permission = _admin_perm
1605 usr.permission = _admin_perm
1606 super_admin_rows.append(usr)
1606 super_admin_rows.append(usr)
1607
1607
1608 return super_admin_rows + owner_row + perm_rows
1608 return super_admin_rows + owner_row + perm_rows
1609
1609
1610 def permission_user_groups(self):
1610 def permission_user_groups(self):
1611 q = UserGroupRepoToPerm.query().filter(
1611 q = UserGroupRepoToPerm.query().filter(
1612 UserGroupRepoToPerm.repository == self)
1612 UserGroupRepoToPerm.repository == self)
1613 q = q.options(joinedload(UserGroupRepoToPerm.repository),
1613 q = q.options(joinedload(UserGroupRepoToPerm.repository),
1614 joinedload(UserGroupRepoToPerm.users_group),
1614 joinedload(UserGroupRepoToPerm.users_group),
1615 joinedload(UserGroupRepoToPerm.permission),)
1615 joinedload(UserGroupRepoToPerm.permission),)
1616
1616
1617 perm_rows = []
1617 perm_rows = []
1618 for _user_group in q.all():
1618 for _user_group in q.all():
1619 usr = AttributeDict(_user_group.users_group.get_dict())
1619 usr = AttributeDict(_user_group.users_group.get_dict())
1620 usr.permission = _user_group.permission.permission_name
1620 usr.permission = _user_group.permission.permission_name
1621 perm_rows.append(usr)
1621 perm_rows.append(usr)
1622
1622
1623 return perm_rows
1623 return perm_rows
1624
1624
1625 def get_api_data(self, include_secrets=False):
1625 def get_api_data(self, include_secrets=False):
1626 """
1626 """
1627 Common function for generating repo api data
1627 Common function for generating repo api data
1628
1628
1629 :param include_secrets: See :meth:`User.get_api_data`.
1629 :param include_secrets: See :meth:`User.get_api_data`.
1630
1630
1631 """
1631 """
1632 # TODO: mikhail: Here there is an anti-pattern, we probably need to
1632 # TODO: mikhail: Here there is an anti-pattern, we probably need to
1633 # move this methods on models level.
1633 # move this methods on models level.
1634 from rhodecode.model.settings import SettingsModel
1634 from rhodecode.model.settings import SettingsModel
1635
1635
1636 repo = self
1636 repo = self
1637 _user_id, _time, _reason = self.locked
1637 _user_id, _time, _reason = self.locked
1638
1638
1639 data = {
1639 data = {
1640 'repo_id': repo.repo_id,
1640 'repo_id': repo.repo_id,
1641 'repo_name': repo.repo_name,
1641 'repo_name': repo.repo_name,
1642 'repo_type': repo.repo_type,
1642 'repo_type': repo.repo_type,
1643 'clone_uri': repo.clone_uri or '',
1643 'clone_uri': repo.clone_uri or '',
1644 'url': url('summary_home', repo_name=self.repo_name, qualified=True),
1644 'url': url('summary_home', repo_name=self.repo_name, qualified=True),
1645 'private': repo.private,
1645 'private': repo.private,
1646 'created_on': repo.created_on,
1646 'created_on': repo.created_on,
1647 'description': repo.description,
1647 'description': repo.description,
1648 'landing_rev': repo.landing_rev,
1648 'landing_rev': repo.landing_rev,
1649 'owner': repo.user.username,
1649 'owner': repo.user.username,
1650 'fork_of': repo.fork.repo_name if repo.fork else None,
1650 'fork_of': repo.fork.repo_name if repo.fork else None,
1651 'enable_statistics': repo.enable_statistics,
1651 'enable_statistics': repo.enable_statistics,
1652 'enable_locking': repo.enable_locking,
1652 'enable_locking': repo.enable_locking,
1653 'enable_downloads': repo.enable_downloads,
1653 'enable_downloads': repo.enable_downloads,
1654 'last_changeset': repo.changeset_cache,
1654 'last_changeset': repo.changeset_cache,
1655 'locked_by': User.get(_user_id).get_api_data(
1655 'locked_by': User.get(_user_id).get_api_data(
1656 include_secrets=include_secrets) if _user_id else None,
1656 include_secrets=include_secrets) if _user_id else None,
1657 'locked_date': time_to_datetime(_time) if _time else None,
1657 'locked_date': time_to_datetime(_time) if _time else None,
1658 'lock_reason': _reason if _reason else None,
1658 'lock_reason': _reason if _reason else None,
1659 }
1659 }
1660
1660
1661 # TODO: mikhail: should be per-repo settings here
1661 # TODO: mikhail: should be per-repo settings here
1662 rc_config = SettingsModel().get_all_settings()
1662 rc_config = SettingsModel().get_all_settings()
1663 repository_fields = str2bool(
1663 repository_fields = str2bool(
1664 rc_config.get('rhodecode_repository_fields'))
1664 rc_config.get('rhodecode_repository_fields'))
1665 if repository_fields:
1665 if repository_fields:
1666 for f in self.extra_fields:
1666 for f in self.extra_fields:
1667 data[f.field_key_prefixed] = f.field_value
1667 data[f.field_key_prefixed] = f.field_value
1668
1668
1669 return data
1669 return data
1670
1670
1671 @classmethod
1671 @classmethod
1672 def lock(cls, repo, user_id, lock_time=None, lock_reason=None):
1672 def lock(cls, repo, user_id, lock_time=None, lock_reason=None):
1673 if not lock_time:
1673 if not lock_time:
1674 lock_time = time.time()
1674 lock_time = time.time()
1675 if not lock_reason:
1675 if not lock_reason:
1676 lock_reason = cls.LOCK_AUTOMATIC
1676 lock_reason = cls.LOCK_AUTOMATIC
1677 repo.locked = [user_id, lock_time, lock_reason]
1677 repo.locked = [user_id, lock_time, lock_reason]
1678 Session().add(repo)
1678 Session().add(repo)
1679 Session().commit()
1679 Session().commit()
1680
1680
1681 @classmethod
1681 @classmethod
1682 def unlock(cls, repo):
1682 def unlock(cls, repo):
1683 repo.locked = None
1683 repo.locked = None
1684 Session().add(repo)
1684 Session().add(repo)
1685 Session().commit()
1685 Session().commit()
1686
1686
1687 @classmethod
1687 @classmethod
1688 def getlock(cls, repo):
1688 def getlock(cls, repo):
1689 return repo.locked
1689 return repo.locked
1690
1690
1691 def is_user_lock(self, user_id):
1691 def is_user_lock(self, user_id):
1692 if self.lock[0]:
1692 if self.lock[0]:
1693 lock_user_id = safe_int(self.lock[0])
1693 lock_user_id = safe_int(self.lock[0])
1694 user_id = safe_int(user_id)
1694 user_id = safe_int(user_id)
1695 # both are ints, and they are equal
1695 # both are ints, and they are equal
1696 return all([lock_user_id, user_id]) and lock_user_id == user_id
1696 return all([lock_user_id, user_id]) and lock_user_id == user_id
1697
1697
1698 return False
1698 return False
1699
1699
1700 def get_locking_state(self, action, user_id, only_when_enabled=True):
1700 def get_locking_state(self, action, user_id, only_when_enabled=True):
1701 """
1701 """
1702 Checks locking on this repository, if locking is enabled and lock is
1702 Checks locking on this repository, if locking is enabled and lock is
1703 present returns a tuple of make_lock, locked, locked_by.
1703 present returns a tuple of make_lock, locked, locked_by.
1704 make_lock can have 3 states None (do nothing) True, make lock
1704 make_lock can have 3 states None (do nothing) True, make lock
1705 False release lock, This value is later propagated to hooks, which
1705 False release lock, This value is later propagated to hooks, which
1706 do the locking. Think about this as signals passed to hooks what to do.
1706 do the locking. Think about this as signals passed to hooks what to do.
1707
1707
1708 """
1708 """
1709 # TODO: johbo: This is part of the business logic and should be moved
1709 # TODO: johbo: This is part of the business logic and should be moved
1710 # into the RepositoryModel.
1710 # into the RepositoryModel.
1711
1711
1712 if action not in ('push', 'pull'):
1712 if action not in ('push', 'pull'):
1713 raise ValueError("Invalid action value: %s" % repr(action))
1713 raise ValueError("Invalid action value: %s" % repr(action))
1714
1714
1715 # defines if locked error should be thrown to user
1715 # defines if locked error should be thrown to user
1716 currently_locked = False
1716 currently_locked = False
1717 # defines if new lock should be made, tri-state
1717 # defines if new lock should be made, tri-state
1718 make_lock = None
1718 make_lock = None
1719 repo = self
1719 repo = self
1720 user = User.get(user_id)
1720 user = User.get(user_id)
1721
1721
1722 lock_info = repo.locked
1722 lock_info = repo.locked
1723
1723
1724 if repo and (repo.enable_locking or not only_when_enabled):
1724 if repo and (repo.enable_locking or not only_when_enabled):
1725 if action == 'push':
1725 if action == 'push':
1726 # check if it's already locked !, if it is compare users
1726 # check if it's already locked !, if it is compare users
1727 locked_by_user_id = lock_info[0]
1727 locked_by_user_id = lock_info[0]
1728 if user.user_id == locked_by_user_id:
1728 if user.user_id == locked_by_user_id:
1729 log.debug(
1729 log.debug(
1730 'Got `push` action from user %s, now unlocking', user)
1730 'Got `push` action from user %s, now unlocking', user)
1731 # unlock if we have push from user who locked
1731 # unlock if we have push from user who locked
1732 make_lock = False
1732 make_lock = False
1733 else:
1733 else:
1734 # we're not the same user who locked, ban with
1734 # we're not the same user who locked, ban with
1735 # code defined in settings (default is 423 HTTP Locked) !
1735 # code defined in settings (default is 423 HTTP Locked) !
1736 log.debug('Repo %s is currently locked by %s', repo, user)
1736 log.debug('Repo %s is currently locked by %s', repo, user)
1737 currently_locked = True
1737 currently_locked = True
1738 elif action == 'pull':
1738 elif action == 'pull':
1739 # [0] user [1] date
1739 # [0] user [1] date
1740 if lock_info[0] and lock_info[1]:
1740 if lock_info[0] and lock_info[1]:
1741 log.debug('Repo %s is currently locked by %s', repo, user)
1741 log.debug('Repo %s is currently locked by %s', repo, user)
1742 currently_locked = True
1742 currently_locked = True
1743 else:
1743 else:
1744 log.debug('Setting lock on repo %s by %s', repo, user)
1744 log.debug('Setting lock on repo %s by %s', repo, user)
1745 make_lock = True
1745 make_lock = True
1746
1746
1747 else:
1747 else:
1748 log.debug('Repository %s do not have locking enabled', repo)
1748 log.debug('Repository %s do not have locking enabled', repo)
1749
1749
1750 log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s',
1750 log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s',
1751 make_lock, currently_locked, lock_info)
1751 make_lock, currently_locked, lock_info)
1752
1752
1753 from rhodecode.lib.auth import HasRepoPermissionAny
1753 from rhodecode.lib.auth import HasRepoPermissionAny
1754 perm_check = HasRepoPermissionAny('repository.write', 'repository.admin')
1754 perm_check = HasRepoPermissionAny('repository.write', 'repository.admin')
1755 if make_lock and not perm_check(repo_name=repo.repo_name, user=user):
1755 if make_lock and not perm_check(repo_name=repo.repo_name, user=user):
1756 # if we don't have at least write permission we cannot make a lock
1756 # if we don't have at least write permission we cannot make a lock
1757 log.debug('lock state reset back to FALSE due to lack '
1757 log.debug('lock state reset back to FALSE due to lack '
1758 'of at least read permission')
1758 'of at least read permission')
1759 make_lock = False
1759 make_lock = False
1760
1760
1761 return make_lock, currently_locked, lock_info
1761 return make_lock, currently_locked, lock_info
1762
1762
1763 @property
1763 @property
1764 def last_db_change(self):
1764 def last_db_change(self):
1765 return self.updated_on
1765 return self.updated_on
1766
1766
1767 @property
1767 @property
1768 def clone_uri_hidden(self):
1768 def clone_uri_hidden(self):
1769 clone_uri = self.clone_uri
1769 clone_uri = self.clone_uri
1770 if clone_uri:
1770 if clone_uri:
1771 import urlobject
1771 import urlobject
1772 url_obj = urlobject.URLObject(clone_uri)
1772 url_obj = urlobject.URLObject(clone_uri)
1773 if url_obj.password:
1773 if url_obj.password:
1774 clone_uri = url_obj.with_password('*****')
1774 clone_uri = url_obj.with_password('*****')
1775 return clone_uri
1775 return clone_uri
1776
1776
1777 def clone_url(self, **override):
1777 def clone_url(self, **override):
1778 qualified_home_url = url('home', qualified=True)
1778 qualified_home_url = url('home', qualified=True)
1779
1779
1780 uri_tmpl = None
1780 uri_tmpl = None
1781 if 'with_id' in override:
1781 if 'with_id' in override:
1782 uri_tmpl = self.DEFAULT_CLONE_URI_ID
1782 uri_tmpl = self.DEFAULT_CLONE_URI_ID
1783 del override['with_id']
1783 del override['with_id']
1784
1784
1785 if 'uri_tmpl' in override:
1785 if 'uri_tmpl' in override:
1786 uri_tmpl = override['uri_tmpl']
1786 uri_tmpl = override['uri_tmpl']
1787 del override['uri_tmpl']
1787 del override['uri_tmpl']
1788
1788
1789 # we didn't override our tmpl from **overrides
1789 # we didn't override our tmpl from **overrides
1790 if not uri_tmpl:
1790 if not uri_tmpl:
1791 uri_tmpl = self.DEFAULT_CLONE_URI
1791 uri_tmpl = self.DEFAULT_CLONE_URI
1792 try:
1792 try:
1793 from pylons import tmpl_context as c
1793 from pylons import tmpl_context as c
1794 uri_tmpl = c.clone_uri_tmpl
1794 uri_tmpl = c.clone_uri_tmpl
1795 except Exception:
1795 except Exception:
1796 # in any case if we call this outside of request context,
1796 # in any case if we call this outside of request context,
1797 # ie, not having tmpl_context set up
1797 # ie, not having tmpl_context set up
1798 pass
1798 pass
1799
1799
1800 return get_clone_url(uri_tmpl=uri_tmpl,
1800 return get_clone_url(uri_tmpl=uri_tmpl,
1801 qualifed_home_url=qualified_home_url,
1801 qualifed_home_url=qualified_home_url,
1802 repo_name=self.repo_name,
1802 repo_name=self.repo_name,
1803 repo_id=self.repo_id, **override)
1803 repo_id=self.repo_id, **override)
1804
1804
1805 def set_state(self, state):
1805 def set_state(self, state):
1806 self.repo_state = state
1806 self.repo_state = state
1807 Session().add(self)
1807 Session().add(self)
1808 #==========================================================================
1808 #==========================================================================
1809 # SCM PROPERTIES
1809 # SCM PROPERTIES
1810 #==========================================================================
1810 #==========================================================================
1811
1811
1812 def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
1812 def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
1813 return get_commit_safe(
1813 return get_commit_safe(
1814 self.scm_instance(), commit_id, commit_idx, pre_load=pre_load)
1814 self.scm_instance(), commit_id, commit_idx, pre_load=pre_load)
1815
1815
1816 def get_changeset(self, rev=None, pre_load=None):
1816 def get_changeset(self, rev=None, pre_load=None):
1817 warnings.warn("Use get_commit", DeprecationWarning)
1817 warnings.warn("Use get_commit", DeprecationWarning)
1818 commit_id = None
1818 commit_id = None
1819 commit_idx = None
1819 commit_idx = None
1820 if isinstance(rev, basestring):
1820 if isinstance(rev, basestring):
1821 commit_id = rev
1821 commit_id = rev
1822 else:
1822 else:
1823 commit_idx = rev
1823 commit_idx = rev
1824 return self.get_commit(commit_id=commit_id, commit_idx=commit_idx,
1824 return self.get_commit(commit_id=commit_id, commit_idx=commit_idx,
1825 pre_load=pre_load)
1825 pre_load=pre_load)
1826
1826
1827 def get_landing_commit(self):
1827 def get_landing_commit(self):
1828 """
1828 """
1829 Returns landing commit, or if that doesn't exist returns the tip
1829 Returns landing commit, or if that doesn't exist returns the tip
1830 """
1830 """
1831 _rev_type, _rev = self.landing_rev
1831 _rev_type, _rev = self.landing_rev
1832 commit = self.get_commit(_rev)
1832 commit = self.get_commit(_rev)
1833 if isinstance(commit, EmptyCommit):
1833 if isinstance(commit, EmptyCommit):
1834 return self.get_commit()
1834 return self.get_commit()
1835 return commit
1835 return commit
1836
1836
1837 def update_commit_cache(self, cs_cache=None, config=None):
1837 def update_commit_cache(self, cs_cache=None, config=None):
1838 """
1838 """
1839 Update cache of last changeset for repository, keys should be::
1839 Update cache of last changeset for repository, keys should be::
1840
1840
1841 short_id
1841 short_id
1842 raw_id
1842 raw_id
1843 revision
1843 revision
1844 parents
1844 parents
1845 message
1845 message
1846 date
1846 date
1847 author
1847 author
1848
1848
1849 :param cs_cache:
1849 :param cs_cache:
1850 """
1850 """
1851 from rhodecode.lib.vcs.backends.base import BaseChangeset
1851 from rhodecode.lib.vcs.backends.base import BaseChangeset
1852 if cs_cache is None:
1852 if cs_cache is None:
1853 # use no-cache version here
1853 # use no-cache version here
1854 scm_repo = self.scm_instance(cache=False, config=config)
1854 scm_repo = self.scm_instance(cache=False, config=config)
1855 if scm_repo:
1855 if scm_repo:
1856 cs_cache = scm_repo.get_commit(
1856 cs_cache = scm_repo.get_commit(
1857 pre_load=["author", "date", "message", "parents"])
1857 pre_load=["author", "date", "message", "parents"])
1858 else:
1858 else:
1859 cs_cache = EmptyCommit()
1859 cs_cache = EmptyCommit()
1860
1860
1861 if isinstance(cs_cache, BaseChangeset):
1861 if isinstance(cs_cache, BaseChangeset):
1862 cs_cache = cs_cache.__json__()
1862 cs_cache = cs_cache.__json__()
1863
1863
1864 def is_outdated(new_cs_cache):
1864 def is_outdated(new_cs_cache):
1865 if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or
1865 if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or
1866 new_cs_cache['revision'] != self.changeset_cache['revision']):
1866 new_cs_cache['revision'] != self.changeset_cache['revision']):
1867 return True
1867 return True
1868 return False
1868 return False
1869
1869
1870 # check if we have maybe already latest cached revision
1870 # check if we have maybe already latest cached revision
1871 if is_outdated(cs_cache) or not self.changeset_cache:
1871 if is_outdated(cs_cache) or not self.changeset_cache:
1872 _default = datetime.datetime.fromtimestamp(0)
1872 _default = datetime.datetime.fromtimestamp(0)
1873 last_change = cs_cache.get('date') or _default
1873 last_change = cs_cache.get('date') or _default
1874 log.debug('updated repo %s with new cs cache %s',
1874 log.debug('updated repo %s with new cs cache %s',
1875 self.repo_name, cs_cache)
1875 self.repo_name, cs_cache)
1876 self.updated_on = last_change
1876 self.updated_on = last_change
1877 self.changeset_cache = cs_cache
1877 self.changeset_cache = cs_cache
1878 Session().add(self)
1878 Session().add(self)
1879 Session().commit()
1879 Session().commit()
1880 else:
1880 else:
1881 log.debug('Skipping update_commit_cache for repo:`%s` '
1881 log.debug('Skipping update_commit_cache for repo:`%s` '
1882 'commit already with latest changes', self.repo_name)
1882 'commit already with latest changes', self.repo_name)
1883
1883
1884 @property
1884 @property
1885 def tip(self):
1885 def tip(self):
1886 return self.get_commit('tip')
1886 return self.get_commit('tip')
1887
1887
1888 @property
1888 @property
1889 def author(self):
1889 def author(self):
1890 return self.tip.author
1890 return self.tip.author
1891
1891
1892 @property
1892 @property
1893 def last_change(self):
1893 def last_change(self):
1894 return self.scm_instance().last_change
1894 return self.scm_instance().last_change
1895
1895
1896 def get_comments(self, revisions=None):
1896 def get_comments(self, revisions=None):
1897 """
1897 """
1898 Returns comments for this repository grouped by revisions
1898 Returns comments for this repository grouped by revisions
1899
1899
1900 :param revisions: filter query by revisions only
1900 :param revisions: filter query by revisions only
1901 """
1901 """
1902 cmts = ChangesetComment.query()\
1902 cmts = ChangesetComment.query()\
1903 .filter(ChangesetComment.repo == self)
1903 .filter(ChangesetComment.repo == self)
1904 if revisions:
1904 if revisions:
1905 cmts = cmts.filter(ChangesetComment.revision.in_(revisions))
1905 cmts = cmts.filter(ChangesetComment.revision.in_(revisions))
1906 grouped = collections.defaultdict(list)
1906 grouped = collections.defaultdict(list)
1907 for cmt in cmts.all():
1907 for cmt in cmts.all():
1908 grouped[cmt.revision].append(cmt)
1908 grouped[cmt.revision].append(cmt)
1909 return grouped
1909 return grouped
1910
1910
1911 def statuses(self, revisions=None):
1911 def statuses(self, revisions=None):
1912 """
1912 """
1913 Returns statuses for this repository
1913 Returns statuses for this repository
1914
1914
1915 :param revisions: list of revisions to get statuses for
1915 :param revisions: list of revisions to get statuses for
1916 """
1916 """
1917 statuses = ChangesetStatus.query()\
1917 statuses = ChangesetStatus.query()\
1918 .filter(ChangesetStatus.repo == self)\
1918 .filter(ChangesetStatus.repo == self)\
1919 .filter(ChangesetStatus.version == 0)
1919 .filter(ChangesetStatus.version == 0)
1920
1920
1921 if revisions:
1921 if revisions:
1922 # Try doing the filtering in chunks to avoid hitting limits
1922 # Try doing the filtering in chunks to avoid hitting limits
1923 size = 500
1923 size = 500
1924 status_results = []
1924 status_results = []
1925 for chunk in xrange(0, len(revisions), size):
1925 for chunk in xrange(0, len(revisions), size):
1926 status_results += statuses.filter(
1926 status_results += statuses.filter(
1927 ChangesetStatus.revision.in_(
1927 ChangesetStatus.revision.in_(
1928 revisions[chunk: chunk+size])
1928 revisions[chunk: chunk+size])
1929 ).all()
1929 ).all()
1930 else:
1930 else:
1931 status_results = statuses.all()
1931 status_results = statuses.all()
1932
1932
1933 grouped = {}
1933 grouped = {}
1934
1934
1935 # maybe we have open new pullrequest without a status?
1935 # maybe we have open new pullrequest without a status?
1936 stat = ChangesetStatus.STATUS_UNDER_REVIEW
1936 stat = ChangesetStatus.STATUS_UNDER_REVIEW
1937 status_lbl = ChangesetStatus.get_status_lbl(stat)
1937 status_lbl = ChangesetStatus.get_status_lbl(stat)
1938 for pr in PullRequest.query().filter(PullRequest.source_repo == self).all():
1938 for pr in PullRequest.query().filter(PullRequest.source_repo == self).all():
1939 for rev in pr.revisions:
1939 for rev in pr.revisions:
1940 pr_id = pr.pull_request_id
1940 pr_id = pr.pull_request_id
1941 pr_repo = pr.target_repo.repo_name
1941 pr_repo = pr.target_repo.repo_name
1942 grouped[rev] = [stat, status_lbl, pr_id, pr_repo]
1942 grouped[rev] = [stat, status_lbl, pr_id, pr_repo]
1943
1943
1944 for stat in status_results:
1944 for stat in status_results:
1945 pr_id = pr_repo = None
1945 pr_id = pr_repo = None
1946 if stat.pull_request:
1946 if stat.pull_request:
1947 pr_id = stat.pull_request.pull_request_id
1947 pr_id = stat.pull_request.pull_request_id
1948 pr_repo = stat.pull_request.target_repo.repo_name
1948 pr_repo = stat.pull_request.target_repo.repo_name
1949 grouped[stat.revision] = [str(stat.status), stat.status_lbl,
1949 grouped[stat.revision] = [str(stat.status), stat.status_lbl,
1950 pr_id, pr_repo]
1950 pr_id, pr_repo]
1951 return grouped
1951 return grouped
1952
1952
1953 # ==========================================================================
1953 # ==========================================================================
1954 # SCM CACHE INSTANCE
1954 # SCM CACHE INSTANCE
1955 # ==========================================================================
1955 # ==========================================================================
1956
1956
1957 def scm_instance(self, **kwargs):
1957 def scm_instance(self, **kwargs):
1958 import rhodecode
1958 import rhodecode
1959
1959
1960 # Passing a config will not hit the cache currently only used
1960 # Passing a config will not hit the cache currently only used
1961 # for repo2dbmapper
1961 # for repo2dbmapper
1962 config = kwargs.pop('config', None)
1962 config = kwargs.pop('config', None)
1963 cache = kwargs.pop('cache', None)
1963 cache = kwargs.pop('cache', None)
1964 full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))
1964 full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))
1965 # if cache is NOT defined use default global, else we have a full
1965 # if cache is NOT defined use default global, else we have a full
1966 # control over cache behaviour
1966 # control over cache behaviour
1967 if cache is None and full_cache and not config:
1967 if cache is None and full_cache and not config:
1968 return self._get_instance_cached()
1968 return self._get_instance_cached()
1969 return self._get_instance(cache=bool(cache), config=config)
1969 return self._get_instance(cache=bool(cache), config=config)
1970
1970
1971 def _get_instance_cached(self):
1971 def _get_instance_cached(self):
1972 @cache_region('long_term')
1972 @cache_region('long_term')
1973 def _get_repo(cache_key):
1973 def _get_repo(cache_key):
1974 return self._get_instance()
1974 return self._get_instance()
1975
1975
1976 invalidator_context = CacheKey.repo_context_cache(
1976 invalidator_context = CacheKey.repo_context_cache(
1977 _get_repo, self.repo_name, None, thread_scoped=True)
1977 _get_repo, self.repo_name, None, thread_scoped=True)
1978
1978
1979 with invalidator_context as context:
1979 with invalidator_context as context:
1980 context.invalidate()
1980 context.invalidate()
1981 repo = context.compute()
1981 repo = context.compute()
1982
1982
1983 return repo
1983 return repo
1984
1984
1985 def _get_instance(self, cache=True, config=None):
1985 def _get_instance(self, cache=True, config=None):
1986 config = config or self._config
1986 config = config or self._config
1987 custom_wire = {
1987 custom_wire = {
1988 'cache': cache # controls the vcs.remote cache
1988 'cache': cache # controls the vcs.remote cache
1989 }
1989 }
1990
1990
1991 repo = get_vcs_instance(
1991 repo = get_vcs_instance(
1992 repo_path=safe_str(self.repo_full_path),
1992 repo_path=safe_str(self.repo_full_path),
1993 config=config,
1993 config=config,
1994 with_wire=custom_wire,
1994 with_wire=custom_wire,
1995 create=False)
1995 create=False)
1996
1996
1997 return repo
1997 return repo
1998
1998
1999 def __json__(self):
1999 def __json__(self):
2000 return {'landing_rev': self.landing_rev}
2000 return {'landing_rev': self.landing_rev}
2001
2001
2002 def get_dict(self):
2002 def get_dict(self):
2003
2003
2004 # Since we transformed `repo_name` to a hybrid property, we need to
2004 # Since we transformed `repo_name` to a hybrid property, we need to
2005 # keep compatibility with the code which uses `repo_name` field.
2005 # keep compatibility with the code which uses `repo_name` field.
2006
2006
2007 result = super(Repository, self).get_dict()
2007 result = super(Repository, self).get_dict()
2008 result['repo_name'] = result.pop('_repo_name', None)
2008 result['repo_name'] = result.pop('_repo_name', None)
2009 return result
2009 return result
2010
2010
2011
2011
2012 class RepoGroup(Base, BaseModel):
2012 class RepoGroup(Base, BaseModel):
2013 __tablename__ = 'groups'
2013 __tablename__ = 'groups'
2014 __table_args__ = (
2014 __table_args__ = (
2015 UniqueConstraint('group_name', 'group_parent_id'),
2015 UniqueConstraint('group_name', 'group_parent_id'),
2016 CheckConstraint('group_id != group_parent_id'),
2016 CheckConstraint('group_id != group_parent_id'),
2017 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2017 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2018 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2018 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2019 )
2019 )
2020 __mapper_args__ = {'order_by': 'group_name'}
2020 __mapper_args__ = {'order_by': 'group_name'}
2021
2021
2022 CHOICES_SEPARATOR = '/' # used to generate select2 choices for nested groups
2022 CHOICES_SEPARATOR = '/' # used to generate select2 choices for nested groups
2023
2023
2024 group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2024 group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2025 group_name = Column("group_name", String(255), nullable=False, unique=True, default=None)
2025 group_name = Column("group_name", String(255), nullable=False, unique=True, default=None)
2026 group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)
2026 group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)
2027 group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None)
2027 group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None)
2028 enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
2028 enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
2029 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
2029 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
2030 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
2030 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
2031
2031
2032 repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
2032 repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
2033 users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
2033 users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
2034 parent_group = relationship('RepoGroup', remote_side=group_id)
2034 parent_group = relationship('RepoGroup', remote_side=group_id)
2035 user = relationship('User')
2035 user = relationship('User')
2036 integrations = relationship('Integration',
2036 integrations = relationship('Integration',
2037 cascade="all, delete, delete-orphan")
2037 cascade="all, delete, delete-orphan")
2038
2038
2039 def __init__(self, group_name='', parent_group=None):
2039 def __init__(self, group_name='', parent_group=None):
2040 self.group_name = group_name
2040 self.group_name = group_name
2041 self.parent_group = parent_group
2041 self.parent_group = parent_group
2042
2042
2043 def __unicode__(self):
2043 def __unicode__(self):
2044 return u"<%s('id:%s:%s')>" % (self.__class__.__name__, self.group_id,
2044 return u"<%s('id:%s:%s')>" % (self.__class__.__name__, self.group_id,
2045 self.group_name)
2045 self.group_name)
2046
2046
2047 @classmethod
2047 @classmethod
2048 def _generate_choice(cls, repo_group):
2048 def _generate_choice(cls, repo_group):
2049 from webhelpers.html import literal as _literal
2049 from webhelpers.html import literal as _literal
2050 _name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k))
2050 _name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k))
2051 return repo_group.group_id, _name(repo_group.full_path_splitted)
2051 return repo_group.group_id, _name(repo_group.full_path_splitted)
2052
2052
2053 @classmethod
2053 @classmethod
2054 def groups_choices(cls, groups=None, show_empty_group=True):
2054 def groups_choices(cls, groups=None, show_empty_group=True):
2055 if not groups:
2055 if not groups:
2056 groups = cls.query().all()
2056 groups = cls.query().all()
2057
2057
2058 repo_groups = []
2058 repo_groups = []
2059 if show_empty_group:
2059 if show_empty_group:
2060 repo_groups = [('-1', u'-- %s --' % _('No parent'))]
2060 repo_groups = [('-1', u'-- %s --' % _('No parent'))]
2061
2061
2062 repo_groups.extend([cls._generate_choice(x) for x in groups])
2062 repo_groups.extend([cls._generate_choice(x) for x in groups])
2063
2063
2064 repo_groups = sorted(
2064 repo_groups = sorted(
2065 repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0])
2065 repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0])
2066 return repo_groups
2066 return repo_groups
2067
2067
2068 @classmethod
2068 @classmethod
2069 def url_sep(cls):
2069 def url_sep(cls):
2070 return URL_SEP
2070 return URL_SEP
2071
2071
2072 @classmethod
2072 @classmethod
2073 def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
2073 def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
2074 if case_insensitive:
2074 if case_insensitive:
2075 gr = cls.query().filter(func.lower(cls.group_name)
2075 gr = cls.query().filter(func.lower(cls.group_name)
2076 == func.lower(group_name))
2076 == func.lower(group_name))
2077 else:
2077 else:
2078 gr = cls.query().filter(cls.group_name == group_name)
2078 gr = cls.query().filter(cls.group_name == group_name)
2079 if cache:
2079 if cache:
2080 gr = gr.options(FromCache(
2080 gr = gr.options(FromCache(
2081 "sql_cache_short",
2081 "sql_cache_short",
2082 "get_group_%s" % _hash_key(group_name)))
2082 "get_group_%s" % _hash_key(group_name)))
2083 return gr.scalar()
2083 return gr.scalar()
2084
2084
2085 @classmethod
2085 @classmethod
2086 def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),
2086 def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),
2087 case_insensitive=True):
2087 case_insensitive=True):
2088 q = RepoGroup.query()
2088 q = RepoGroup.query()
2089
2089
2090 if not isinstance(user_id, Optional):
2090 if not isinstance(user_id, Optional):
2091 q = q.filter(RepoGroup.user_id == user_id)
2091 q = q.filter(RepoGroup.user_id == user_id)
2092
2092
2093 if not isinstance(group_id, Optional):
2093 if not isinstance(group_id, Optional):
2094 q = q.filter(RepoGroup.group_parent_id == group_id)
2094 q = q.filter(RepoGroup.group_parent_id == group_id)
2095
2095
2096 if case_insensitive:
2096 if case_insensitive:
2097 q = q.order_by(func.lower(RepoGroup.group_name))
2097 q = q.order_by(func.lower(RepoGroup.group_name))
2098 else:
2098 else:
2099 q = q.order_by(RepoGroup.group_name)
2099 q = q.order_by(RepoGroup.group_name)
2100 return q.all()
2100 return q.all()
2101
2101
2102 @property
2102 @property
2103 def parents(self):
2103 def parents(self):
2104 parents_recursion_limit = 10
2104 parents_recursion_limit = 10
2105 groups = []
2105 groups = []
2106 if self.parent_group is None:
2106 if self.parent_group is None:
2107 return groups
2107 return groups
2108 cur_gr = self.parent_group
2108 cur_gr = self.parent_group
2109 groups.insert(0, cur_gr)
2109 groups.insert(0, cur_gr)
2110 cnt = 0
2110 cnt = 0
2111 while 1:
2111 while 1:
2112 cnt += 1
2112 cnt += 1
2113 gr = getattr(cur_gr, 'parent_group', None)
2113 gr = getattr(cur_gr, 'parent_group', None)
2114 cur_gr = cur_gr.parent_group
2114 cur_gr = cur_gr.parent_group
2115 if gr is None:
2115 if gr is None:
2116 break
2116 break
2117 if cnt == parents_recursion_limit:
2117 if cnt == parents_recursion_limit:
2118 # this will prevent accidental infinit loops
2118 # this will prevent accidental infinit loops
2119 log.error(('more than %s parents found for group %s, stopping '
2119 log.error(('more than %s parents found for group %s, stopping '
2120 'recursive parent fetching' % (parents_recursion_limit, self)))
2120 'recursive parent fetching' % (parents_recursion_limit, self)))
2121 break
2121 break
2122
2122
2123 groups.insert(0, gr)
2123 groups.insert(0, gr)
2124 return groups
2124 return groups
2125
2125
2126 @property
2126 @property
2127 def children(self):
2127 def children(self):
2128 return RepoGroup.query().filter(RepoGroup.parent_group == self)
2128 return RepoGroup.query().filter(RepoGroup.parent_group == self)
2129
2129
2130 @property
2130 @property
2131 def name(self):
2131 def name(self):
2132 return self.group_name.split(RepoGroup.url_sep())[-1]
2132 return self.group_name.split(RepoGroup.url_sep())[-1]
2133
2133
2134 @property
2134 @property
2135 def full_path(self):
2135 def full_path(self):
2136 return self.group_name
2136 return self.group_name
2137
2137
2138 @property
2138 @property
2139 def full_path_splitted(self):
2139 def full_path_splitted(self):
2140 return self.group_name.split(RepoGroup.url_sep())
2140 return self.group_name.split(RepoGroup.url_sep())
2141
2141
2142 @property
2142 @property
2143 def repositories(self):
2143 def repositories(self):
2144 return Repository.query()\
2144 return Repository.query()\
2145 .filter(Repository.group == self)\
2145 .filter(Repository.group == self)\
2146 .order_by(Repository.repo_name)
2146 .order_by(Repository.repo_name)
2147
2147
2148 @property
2148 @property
2149 def repositories_recursive_count(self):
2149 def repositories_recursive_count(self):
2150 cnt = self.repositories.count()
2150 cnt = self.repositories.count()
2151
2151
2152 def children_count(group):
2152 def children_count(group):
2153 cnt = 0
2153 cnt = 0
2154 for child in group.children:
2154 for child in group.children:
2155 cnt += child.repositories.count()
2155 cnt += child.repositories.count()
2156 cnt += children_count(child)
2156 cnt += children_count(child)
2157 return cnt
2157 return cnt
2158
2158
2159 return cnt + children_count(self)
2159 return cnt + children_count(self)
2160
2160
2161 def _recursive_objects(self, include_repos=True):
2161 def _recursive_objects(self, include_repos=True):
2162 all_ = []
2162 all_ = []
2163
2163
2164 def _get_members(root_gr):
2164 def _get_members(root_gr):
2165 if include_repos:
2165 if include_repos:
2166 for r in root_gr.repositories:
2166 for r in root_gr.repositories:
2167 all_.append(r)
2167 all_.append(r)
2168 childs = root_gr.children.all()
2168 childs = root_gr.children.all()
2169 if childs:
2169 if childs:
2170 for gr in childs:
2170 for gr in childs:
2171 all_.append(gr)
2171 all_.append(gr)
2172 _get_members(gr)
2172 _get_members(gr)
2173
2173
2174 _get_members(self)
2174 _get_members(self)
2175 return [self] + all_
2175 return [self] + all_
2176
2176
2177 def recursive_groups_and_repos(self):
2177 def recursive_groups_and_repos(self):
2178 """
2178 """
2179 Recursive return all groups, with repositories in those groups
2179 Recursive return all groups, with repositories in those groups
2180 """
2180 """
2181 return self._recursive_objects()
2181 return self._recursive_objects()
2182
2182
2183 def recursive_groups(self):
2183 def recursive_groups(self):
2184 """
2184 """
2185 Returns all children groups for this group including children of children
2185 Returns all children groups for this group including children of children
2186 """
2186 """
2187 return self._recursive_objects(include_repos=False)
2187 return self._recursive_objects(include_repos=False)
2188
2188
2189 def get_new_name(self, group_name):
2189 def get_new_name(self, group_name):
2190 """
2190 """
2191 returns new full group name based on parent and new name
2191 returns new full group name based on parent and new name
2192
2192
2193 :param group_name:
2193 :param group_name:
2194 """
2194 """
2195 path_prefix = (self.parent_group.full_path_splitted if
2195 path_prefix = (self.parent_group.full_path_splitted if
2196 self.parent_group else [])
2196 self.parent_group else [])
2197 return RepoGroup.url_sep().join(path_prefix + [group_name])
2197 return RepoGroup.url_sep().join(path_prefix + [group_name])
2198
2198
2199 def permissions(self, with_admins=True, with_owner=True):
2199 def permissions(self, with_admins=True, with_owner=True):
2200 q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self)
2200 q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self)
2201 q = q.options(joinedload(UserRepoGroupToPerm.group),
2201 q = q.options(joinedload(UserRepoGroupToPerm.group),
2202 joinedload(UserRepoGroupToPerm.user),
2202 joinedload(UserRepoGroupToPerm.user),
2203 joinedload(UserRepoGroupToPerm.permission),)
2203 joinedload(UserRepoGroupToPerm.permission),)
2204
2204
2205 # get owners and admins and permissions. We do a trick of re-writing
2205 # get owners and admins and permissions. We do a trick of re-writing
2206 # objects from sqlalchemy to named-tuples due to sqlalchemy session
2206 # objects from sqlalchemy to named-tuples due to sqlalchemy session
2207 # has a global reference and changing one object propagates to all
2207 # has a global reference and changing one object propagates to all
2208 # others. This means if admin is also an owner admin_row that change
2208 # others. This means if admin is also an owner admin_row that change
2209 # would propagate to both objects
2209 # would propagate to both objects
2210 perm_rows = []
2210 perm_rows = []
2211 for _usr in q.all():
2211 for _usr in q.all():
2212 usr = AttributeDict(_usr.user.get_dict())
2212 usr = AttributeDict(_usr.user.get_dict())
2213 usr.permission = _usr.permission.permission_name
2213 usr.permission = _usr.permission.permission_name
2214 perm_rows.append(usr)
2214 perm_rows.append(usr)
2215
2215
2216 # filter the perm rows by 'default' first and then sort them by
2216 # filter the perm rows by 'default' first and then sort them by
2217 # admin,write,read,none permissions sorted again alphabetically in
2217 # admin,write,read,none permissions sorted again alphabetically in
2218 # each group
2218 # each group
2219 perm_rows = sorted(perm_rows, key=display_sort)
2219 perm_rows = sorted(perm_rows, key=display_sort)
2220
2220
2221 _admin_perm = 'group.admin'
2221 _admin_perm = 'group.admin'
2222 owner_row = []
2222 owner_row = []
2223 if with_owner:
2223 if with_owner:
2224 usr = AttributeDict(self.user.get_dict())
2224 usr = AttributeDict(self.user.get_dict())
2225 usr.owner_row = True
2225 usr.owner_row = True
2226 usr.permission = _admin_perm
2226 usr.permission = _admin_perm
2227 owner_row.append(usr)
2227 owner_row.append(usr)
2228
2228
2229 super_admin_rows = []
2229 super_admin_rows = []
2230 if with_admins:
2230 if with_admins:
2231 for usr in User.get_all_super_admins():
2231 for usr in User.get_all_super_admins():
2232 # if this admin is also owner, don't double the record
2232 # if this admin is also owner, don't double the record
2233 if usr.user_id == owner_row[0].user_id:
2233 if usr.user_id == owner_row[0].user_id:
2234 owner_row[0].admin_row = True
2234 owner_row[0].admin_row = True
2235 else:
2235 else:
2236 usr = AttributeDict(usr.get_dict())
2236 usr = AttributeDict(usr.get_dict())
2237 usr.admin_row = True
2237 usr.admin_row = True
2238 usr.permission = _admin_perm
2238 usr.permission = _admin_perm
2239 super_admin_rows.append(usr)
2239 super_admin_rows.append(usr)
2240
2240
2241 return super_admin_rows + owner_row + perm_rows
2241 return super_admin_rows + owner_row + perm_rows
2242
2242
2243 def permission_user_groups(self):
2243 def permission_user_groups(self):
2244 q = UserGroupRepoGroupToPerm.query().filter(UserGroupRepoGroupToPerm.group == self)
2244 q = UserGroupRepoGroupToPerm.query().filter(UserGroupRepoGroupToPerm.group == self)
2245 q = q.options(joinedload(UserGroupRepoGroupToPerm.group),
2245 q = q.options(joinedload(UserGroupRepoGroupToPerm.group),
2246 joinedload(UserGroupRepoGroupToPerm.users_group),
2246 joinedload(UserGroupRepoGroupToPerm.users_group),
2247 joinedload(UserGroupRepoGroupToPerm.permission),)
2247 joinedload(UserGroupRepoGroupToPerm.permission),)
2248
2248
2249 perm_rows = []
2249 perm_rows = []
2250 for _user_group in q.all():
2250 for _user_group in q.all():
2251 usr = AttributeDict(_user_group.users_group.get_dict())
2251 usr = AttributeDict(_user_group.users_group.get_dict())
2252 usr.permission = _user_group.permission.permission_name
2252 usr.permission = _user_group.permission.permission_name
2253 perm_rows.append(usr)
2253 perm_rows.append(usr)
2254
2254
2255 return perm_rows
2255 return perm_rows
2256
2256
2257 def get_api_data(self):
2257 def get_api_data(self):
2258 """
2258 """
2259 Common function for generating api data
2259 Common function for generating api data
2260
2260
2261 """
2261 """
2262 group = self
2262 group = self
2263 data = {
2263 data = {
2264 'group_id': group.group_id,
2264 'group_id': group.group_id,
2265 'group_name': group.group_name,
2265 'group_name': group.group_name,
2266 'group_description': group.group_description,
2266 'group_description': group.group_description,
2267 'parent_group': group.parent_group.group_name if group.parent_group else None,
2267 'parent_group': group.parent_group.group_name if group.parent_group else None,
2268 'repositories': [x.repo_name for x in group.repositories],
2268 'repositories': [x.repo_name for x in group.repositories],
2269 'owner': group.user.username,
2269 'owner': group.user.username,
2270 }
2270 }
2271 return data
2271 return data
2272
2272
2273
2273
2274 class Permission(Base, BaseModel):
2274 class Permission(Base, BaseModel):
2275 __tablename__ = 'permissions'
2275 __tablename__ = 'permissions'
2276 __table_args__ = (
2276 __table_args__ = (
2277 Index('p_perm_name_idx', 'permission_name'),
2277 Index('p_perm_name_idx', 'permission_name'),
2278 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2278 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2279 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2279 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2280 )
2280 )
2281 PERMS = [
2281 PERMS = [
2282 ('hg.admin', _('RhodeCode Super Administrator')),
2282 ('hg.admin', _('RhodeCode Super Administrator')),
2283
2283
2284 ('repository.none', _('Repository no access')),
2284 ('repository.none', _('Repository no access')),
2285 ('repository.read', _('Repository read access')),
2285 ('repository.read', _('Repository read access')),
2286 ('repository.write', _('Repository write access')),
2286 ('repository.write', _('Repository write access')),
2287 ('repository.admin', _('Repository admin access')),
2287 ('repository.admin', _('Repository admin access')),
2288
2288
2289 ('group.none', _('Repository group no access')),
2289 ('group.none', _('Repository group no access')),
2290 ('group.read', _('Repository group read access')),
2290 ('group.read', _('Repository group read access')),
2291 ('group.write', _('Repository group write access')),
2291 ('group.write', _('Repository group write access')),
2292 ('group.admin', _('Repository group admin access')),
2292 ('group.admin', _('Repository group admin access')),
2293
2293
2294 ('usergroup.none', _('User group no access')),
2294 ('usergroup.none', _('User group no access')),
2295 ('usergroup.read', _('User group read access')),
2295 ('usergroup.read', _('User group read access')),
2296 ('usergroup.write', _('User group write access')),
2296 ('usergroup.write', _('User group write access')),
2297 ('usergroup.admin', _('User group admin access')),
2297 ('usergroup.admin', _('User group admin access')),
2298
2298
2299 ('hg.repogroup.create.false', _('Repository Group creation disabled')),
2299 ('hg.repogroup.create.false', _('Repository Group creation disabled')),
2300 ('hg.repogroup.create.true', _('Repository Group creation enabled')),
2300 ('hg.repogroup.create.true', _('Repository Group creation enabled')),
2301
2301
2302 ('hg.usergroup.create.false', _('User Group creation disabled')),
2302 ('hg.usergroup.create.false', _('User Group creation disabled')),
2303 ('hg.usergroup.create.true', _('User Group creation enabled')),
2303 ('hg.usergroup.create.true', _('User Group creation enabled')),
2304
2304
2305 ('hg.create.none', _('Repository creation disabled')),
2305 ('hg.create.none', _('Repository creation disabled')),
2306 ('hg.create.repository', _('Repository creation enabled')),
2306 ('hg.create.repository', _('Repository creation enabled')),
2307 ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')),
2307 ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')),
2308 ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')),
2308 ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')),
2309
2309
2310 ('hg.fork.none', _('Repository forking disabled')),
2310 ('hg.fork.none', _('Repository forking disabled')),
2311 ('hg.fork.repository', _('Repository forking enabled')),
2311 ('hg.fork.repository', _('Repository forking enabled')),
2312
2312
2313 ('hg.register.none', _('Registration disabled')),
2313 ('hg.register.none', _('Registration disabled')),
2314 ('hg.register.manual_activate', _('User Registration with manual account activation')),
2314 ('hg.register.manual_activate', _('User Registration with manual account activation')),
2315 ('hg.register.auto_activate', _('User Registration with automatic account activation')),
2315 ('hg.register.auto_activate', _('User Registration with automatic account activation')),
2316
2316
2317 ('hg.password_reset.enabled', _('Password reset enabled')),
2317 ('hg.password_reset.enabled', _('Password reset enabled')),
2318 ('hg.password_reset.hidden', _('Password reset hidden')),
2318 ('hg.password_reset.hidden', _('Password reset hidden')),
2319 ('hg.password_reset.disabled', _('Password reset disabled')),
2319 ('hg.password_reset.disabled', _('Password reset disabled')),
2320
2320
2321 ('hg.extern_activate.manual', _('Manual activation of external account')),
2321 ('hg.extern_activate.manual', _('Manual activation of external account')),
2322 ('hg.extern_activate.auto', _('Automatic activation of external account')),
2322 ('hg.extern_activate.auto', _('Automatic activation of external account')),
2323
2323
2324 ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')),
2324 ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')),
2325 ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')),
2325 ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')),
2326 ]
2326 ]
2327
2327
2328 # definition of system default permissions for DEFAULT user
2328 # definition of system default permissions for DEFAULT user
2329 DEFAULT_USER_PERMISSIONS = [
2329 DEFAULT_USER_PERMISSIONS = [
2330 'repository.read',
2330 'repository.read',
2331 'group.read',
2331 'group.read',
2332 'usergroup.read',
2332 'usergroup.read',
2333 'hg.create.repository',
2333 'hg.create.repository',
2334 'hg.repogroup.create.false',
2334 'hg.repogroup.create.false',
2335 'hg.usergroup.create.false',
2335 'hg.usergroup.create.false',
2336 'hg.create.write_on_repogroup.true',
2336 'hg.create.write_on_repogroup.true',
2337 'hg.fork.repository',
2337 'hg.fork.repository',
2338 'hg.register.manual_activate',
2338 'hg.register.manual_activate',
2339 'hg.password_reset.enabled',
2339 'hg.password_reset.enabled',
2340 'hg.extern_activate.auto',
2340 'hg.extern_activate.auto',
2341 'hg.inherit_default_perms.true',
2341 'hg.inherit_default_perms.true',
2342 ]
2342 ]
2343
2343
2344 # defines which permissions are more important higher the more important
2344 # defines which permissions are more important higher the more important
2345 # Weight defines which permissions are more important.
2345 # Weight defines which permissions are more important.
2346 # The higher number the more important.
2346 # The higher number the more important.
2347 PERM_WEIGHTS = {
2347 PERM_WEIGHTS = {
2348 'repository.none': 0,
2348 'repository.none': 0,
2349 'repository.read': 1,
2349 'repository.read': 1,
2350 'repository.write': 3,
2350 'repository.write': 3,
2351 'repository.admin': 4,
2351 'repository.admin': 4,
2352
2352
2353 'group.none': 0,
2353 'group.none': 0,
2354 'group.read': 1,
2354 'group.read': 1,
2355 'group.write': 3,
2355 'group.write': 3,
2356 'group.admin': 4,
2356 'group.admin': 4,
2357
2357
2358 'usergroup.none': 0,
2358 'usergroup.none': 0,
2359 'usergroup.read': 1,
2359 'usergroup.read': 1,
2360 'usergroup.write': 3,
2360 'usergroup.write': 3,
2361 'usergroup.admin': 4,
2361 'usergroup.admin': 4,
2362
2362
2363 'hg.repogroup.create.false': 0,
2363 'hg.repogroup.create.false': 0,
2364 'hg.repogroup.create.true': 1,
2364 'hg.repogroup.create.true': 1,
2365
2365
2366 'hg.usergroup.create.false': 0,
2366 'hg.usergroup.create.false': 0,
2367 'hg.usergroup.create.true': 1,
2367 'hg.usergroup.create.true': 1,
2368
2368
2369 'hg.fork.none': 0,
2369 'hg.fork.none': 0,
2370 'hg.fork.repository': 1,
2370 'hg.fork.repository': 1,
2371 'hg.create.none': 0,
2371 'hg.create.none': 0,
2372 'hg.create.repository': 1
2372 'hg.create.repository': 1
2373 }
2373 }
2374
2374
2375 permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2375 permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2376 permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)
2376 permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)
2377 permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)
2377 permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)
2378
2378
2379 def __unicode__(self):
2379 def __unicode__(self):
2380 return u"<%s('%s:%s')>" % (
2380 return u"<%s('%s:%s')>" % (
2381 self.__class__.__name__, self.permission_id, self.permission_name
2381 self.__class__.__name__, self.permission_id, self.permission_name
2382 )
2382 )
2383
2383
2384 @classmethod
2384 @classmethod
2385 def get_by_key(cls, key):
2385 def get_by_key(cls, key):
2386 return cls.query().filter(cls.permission_name == key).scalar()
2386 return cls.query().filter(cls.permission_name == key).scalar()
2387
2387
2388 @classmethod
2388 @classmethod
2389 def get_default_repo_perms(cls, user_id, repo_id=None):
2389 def get_default_repo_perms(cls, user_id, repo_id=None):
2390 q = Session().query(UserRepoToPerm, Repository, Permission)\
2390 q = Session().query(UserRepoToPerm, Repository, Permission)\
2391 .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\
2391 .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\
2392 .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\
2392 .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\
2393 .filter(UserRepoToPerm.user_id == user_id)
2393 .filter(UserRepoToPerm.user_id == user_id)
2394 if repo_id:
2394 if repo_id:
2395 q = q.filter(UserRepoToPerm.repository_id == repo_id)
2395 q = q.filter(UserRepoToPerm.repository_id == repo_id)
2396 return q.all()
2396 return q.all()
2397
2397
2398 @classmethod
2398 @classmethod
2399 def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None):
2399 def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None):
2400 q = Session().query(UserGroupRepoToPerm, Repository, Permission)\
2400 q = Session().query(UserGroupRepoToPerm, Repository, Permission)\
2401 .join(
2401 .join(
2402 Permission,
2402 Permission,
2403 UserGroupRepoToPerm.permission_id == Permission.permission_id)\
2403 UserGroupRepoToPerm.permission_id == Permission.permission_id)\
2404 .join(
2404 .join(
2405 Repository,
2405 Repository,
2406 UserGroupRepoToPerm.repository_id == Repository.repo_id)\
2406 UserGroupRepoToPerm.repository_id == Repository.repo_id)\
2407 .join(
2407 .join(
2408 UserGroup,
2408 UserGroup,
2409 UserGroupRepoToPerm.users_group_id ==
2409 UserGroupRepoToPerm.users_group_id ==
2410 UserGroup.users_group_id)\
2410 UserGroup.users_group_id)\
2411 .join(
2411 .join(
2412 UserGroupMember,
2412 UserGroupMember,
2413 UserGroupRepoToPerm.users_group_id ==
2413 UserGroupRepoToPerm.users_group_id ==
2414 UserGroupMember.users_group_id)\
2414 UserGroupMember.users_group_id)\
2415 .filter(
2415 .filter(
2416 UserGroupMember.user_id == user_id,
2416 UserGroupMember.user_id == user_id,
2417 UserGroup.users_group_active == true())
2417 UserGroup.users_group_active == true())
2418 if repo_id:
2418 if repo_id:
2419 q = q.filter(UserGroupRepoToPerm.repository_id == repo_id)
2419 q = q.filter(UserGroupRepoToPerm.repository_id == repo_id)
2420 return q.all()
2420 return q.all()
2421
2421
2422 @classmethod
2422 @classmethod
2423 def get_default_group_perms(cls, user_id, repo_group_id=None):
2423 def get_default_group_perms(cls, user_id, repo_group_id=None):
2424 q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\
2424 q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\
2425 .join((Permission, UserRepoGroupToPerm.permission_id == Permission.permission_id))\
2425 .join((Permission, UserRepoGroupToPerm.permission_id == Permission.permission_id))\
2426 .join((RepoGroup, UserRepoGroupToPerm.group_id == RepoGroup.group_id))\
2426 .join((RepoGroup, UserRepoGroupToPerm.group_id == RepoGroup.group_id))\
2427 .filter(UserRepoGroupToPerm.user_id == user_id)
2427 .filter(UserRepoGroupToPerm.user_id == user_id)
2428 if repo_group_id:
2428 if repo_group_id:
2429 q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id)
2429 q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id)
2430 return q.all()
2430 return q.all()
2431
2431
2432 @classmethod
2432 @classmethod
2433 def get_default_group_perms_from_user_group(
2433 def get_default_group_perms_from_user_group(
2434 cls, user_id, repo_group_id=None):
2434 cls, user_id, repo_group_id=None):
2435 q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\
2435 q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\
2436 .join(
2436 .join(
2437 Permission,
2437 Permission,
2438 UserGroupRepoGroupToPerm.permission_id ==
2438 UserGroupRepoGroupToPerm.permission_id ==
2439 Permission.permission_id)\
2439 Permission.permission_id)\
2440 .join(
2440 .join(
2441 RepoGroup,
2441 RepoGroup,
2442 UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\
2442 UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\
2443 .join(
2443 .join(
2444 UserGroup,
2444 UserGroup,
2445 UserGroupRepoGroupToPerm.users_group_id ==
2445 UserGroupRepoGroupToPerm.users_group_id ==
2446 UserGroup.users_group_id)\
2446 UserGroup.users_group_id)\
2447 .join(
2447 .join(
2448 UserGroupMember,
2448 UserGroupMember,
2449 UserGroupRepoGroupToPerm.users_group_id ==
2449 UserGroupRepoGroupToPerm.users_group_id ==
2450 UserGroupMember.users_group_id)\
2450 UserGroupMember.users_group_id)\
2451 .filter(
2451 .filter(
2452 UserGroupMember.user_id == user_id,
2452 UserGroupMember.user_id == user_id,
2453 UserGroup.users_group_active == true())
2453 UserGroup.users_group_active == true())
2454 if repo_group_id:
2454 if repo_group_id:
2455 q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id)
2455 q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id)
2456 return q.all()
2456 return q.all()
2457
2457
2458 @classmethod
2458 @classmethod
2459 def get_default_user_group_perms(cls, user_id, user_group_id=None):
2459 def get_default_user_group_perms(cls, user_id, user_group_id=None):
2460 q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\
2460 q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\
2461 .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\
2461 .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\
2462 .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\
2462 .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\
2463 .filter(UserUserGroupToPerm.user_id == user_id)
2463 .filter(UserUserGroupToPerm.user_id == user_id)
2464 if user_group_id:
2464 if user_group_id:
2465 q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id)
2465 q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id)
2466 return q.all()
2466 return q.all()
2467
2467
2468 @classmethod
2468 @classmethod
2469 def get_default_user_group_perms_from_user_group(
2469 def get_default_user_group_perms_from_user_group(
2470 cls, user_id, user_group_id=None):
2470 cls, user_id, user_group_id=None):
2471 TargetUserGroup = aliased(UserGroup, name='target_user_group')
2471 TargetUserGroup = aliased(UserGroup, name='target_user_group')
2472 q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\
2472 q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\
2473 .join(
2473 .join(
2474 Permission,
2474 Permission,
2475 UserGroupUserGroupToPerm.permission_id ==
2475 UserGroupUserGroupToPerm.permission_id ==
2476 Permission.permission_id)\
2476 Permission.permission_id)\
2477 .join(
2477 .join(
2478 TargetUserGroup,
2478 TargetUserGroup,
2479 UserGroupUserGroupToPerm.target_user_group_id ==
2479 UserGroupUserGroupToPerm.target_user_group_id ==
2480 TargetUserGroup.users_group_id)\
2480 TargetUserGroup.users_group_id)\
2481 .join(
2481 .join(
2482 UserGroup,
2482 UserGroup,
2483 UserGroupUserGroupToPerm.user_group_id ==
2483 UserGroupUserGroupToPerm.user_group_id ==
2484 UserGroup.users_group_id)\
2484 UserGroup.users_group_id)\
2485 .join(
2485 .join(
2486 UserGroupMember,
2486 UserGroupMember,
2487 UserGroupUserGroupToPerm.user_group_id ==
2487 UserGroupUserGroupToPerm.user_group_id ==
2488 UserGroupMember.users_group_id)\
2488 UserGroupMember.users_group_id)\
2489 .filter(
2489 .filter(
2490 UserGroupMember.user_id == user_id,
2490 UserGroupMember.user_id == user_id,
2491 UserGroup.users_group_active == true())
2491 UserGroup.users_group_active == true())
2492 if user_group_id:
2492 if user_group_id:
2493 q = q.filter(
2493 q = q.filter(
2494 UserGroupUserGroupToPerm.user_group_id == user_group_id)
2494 UserGroupUserGroupToPerm.user_group_id == user_group_id)
2495
2495
2496 return q.all()
2496 return q.all()
2497
2497
2498
2498
2499 class UserRepoToPerm(Base, BaseModel):
2499 class UserRepoToPerm(Base, BaseModel):
2500 __tablename__ = 'repo_to_perm'
2500 __tablename__ = 'repo_to_perm'
2501 __table_args__ = (
2501 __table_args__ = (
2502 UniqueConstraint('user_id', 'repository_id', 'permission_id'),
2502 UniqueConstraint('user_id', 'repository_id', 'permission_id'),
2503 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2503 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2504 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2504 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2505 )
2505 )
2506 repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2506 repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2507 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2507 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2508 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2508 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2509 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
2509 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
2510
2510
2511 user = relationship('User')
2511 user = relationship('User')
2512 repository = relationship('Repository')
2512 repository = relationship('Repository')
2513 permission = relationship('Permission')
2513 permission = relationship('Permission')
2514
2514
2515 @classmethod
2515 @classmethod
2516 def create(cls, user, repository, permission):
2516 def create(cls, user, repository, permission):
2517 n = cls()
2517 n = cls()
2518 n.user = user
2518 n.user = user
2519 n.repository = repository
2519 n.repository = repository
2520 n.permission = permission
2520 n.permission = permission
2521 Session().add(n)
2521 Session().add(n)
2522 return n
2522 return n
2523
2523
2524 def __unicode__(self):
2524 def __unicode__(self):
2525 return u'<%s => %s >' % (self.user, self.repository)
2525 return u'<%s => %s >' % (self.user, self.repository)
2526
2526
2527
2527
2528 class UserUserGroupToPerm(Base, BaseModel):
2528 class UserUserGroupToPerm(Base, BaseModel):
2529 __tablename__ = 'user_user_group_to_perm'
2529 __tablename__ = 'user_user_group_to_perm'
2530 __table_args__ = (
2530 __table_args__ = (
2531 UniqueConstraint('user_id', 'user_group_id', 'permission_id'),
2531 UniqueConstraint('user_id', 'user_group_id', 'permission_id'),
2532 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2532 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2533 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2533 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2534 )
2534 )
2535 user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2535 user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2536 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2536 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2537 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2537 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2538 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2538 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2539
2539
2540 user = relationship('User')
2540 user = relationship('User')
2541 user_group = relationship('UserGroup')
2541 user_group = relationship('UserGroup')
2542 permission = relationship('Permission')
2542 permission = relationship('Permission')
2543
2543
2544 @classmethod
2544 @classmethod
2545 def create(cls, user, user_group, permission):
2545 def create(cls, user, user_group, permission):
2546 n = cls()
2546 n = cls()
2547 n.user = user
2547 n.user = user
2548 n.user_group = user_group
2548 n.user_group = user_group
2549 n.permission = permission
2549 n.permission = permission
2550 Session().add(n)
2550 Session().add(n)
2551 return n
2551 return n
2552
2552
2553 def __unicode__(self):
2553 def __unicode__(self):
2554 return u'<%s => %s >' % (self.user, self.user_group)
2554 return u'<%s => %s >' % (self.user, self.user_group)
2555
2555
2556
2556
2557 class UserToPerm(Base, BaseModel):
2557 class UserToPerm(Base, BaseModel):
2558 __tablename__ = 'user_to_perm'
2558 __tablename__ = 'user_to_perm'
2559 __table_args__ = (
2559 __table_args__ = (
2560 UniqueConstraint('user_id', 'permission_id'),
2560 UniqueConstraint('user_id', 'permission_id'),
2561 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2561 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2562 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2562 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2563 )
2563 )
2564 user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2564 user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2565 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2565 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2566 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2566 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2567
2567
2568 user = relationship('User')
2568 user = relationship('User')
2569 permission = relationship('Permission', lazy='joined')
2569 permission = relationship('Permission', lazy='joined')
2570
2570
2571 def __unicode__(self):
2571 def __unicode__(self):
2572 return u'<%s => %s >' % (self.user, self.permission)
2572 return u'<%s => %s >' % (self.user, self.permission)
2573
2573
2574
2574
2575 class UserGroupRepoToPerm(Base, BaseModel):
2575 class UserGroupRepoToPerm(Base, BaseModel):
2576 __tablename__ = 'users_group_repo_to_perm'
2576 __tablename__ = 'users_group_repo_to_perm'
2577 __table_args__ = (
2577 __table_args__ = (
2578 UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
2578 UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
2579 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2579 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2580 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2580 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2581 )
2581 )
2582 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2582 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2583 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2583 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2584 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2584 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2585 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
2585 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
2586
2586
2587 users_group = relationship('UserGroup')
2587 users_group = relationship('UserGroup')
2588 permission = relationship('Permission')
2588 permission = relationship('Permission')
2589 repository = relationship('Repository')
2589 repository = relationship('Repository')
2590
2590
2591 @classmethod
2591 @classmethod
2592 def create(cls, users_group, repository, permission):
2592 def create(cls, users_group, repository, permission):
2593 n = cls()
2593 n = cls()
2594 n.users_group = users_group
2594 n.users_group = users_group
2595 n.repository = repository
2595 n.repository = repository
2596 n.permission = permission
2596 n.permission = permission
2597 Session().add(n)
2597 Session().add(n)
2598 return n
2598 return n
2599
2599
2600 def __unicode__(self):
2600 def __unicode__(self):
2601 return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)
2601 return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)
2602
2602
2603
2603
2604 class UserGroupUserGroupToPerm(Base, BaseModel):
2604 class UserGroupUserGroupToPerm(Base, BaseModel):
2605 __tablename__ = 'user_group_user_group_to_perm'
2605 __tablename__ = 'user_group_user_group_to_perm'
2606 __table_args__ = (
2606 __table_args__ = (
2607 UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),
2607 UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),
2608 CheckConstraint('target_user_group_id != user_group_id'),
2608 CheckConstraint('target_user_group_id != user_group_id'),
2609 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2609 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2610 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2610 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2611 )
2611 )
2612 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)
2612 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)
2613 target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2613 target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2614 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2614 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2615 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2615 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2616
2616
2617 target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')
2617 target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')
2618 user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')
2618 user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')
2619 permission = relationship('Permission')
2619 permission = relationship('Permission')
2620
2620
2621 @classmethod
2621 @classmethod
2622 def create(cls, target_user_group, user_group, permission):
2622 def create(cls, target_user_group, user_group, permission):
2623 n = cls()
2623 n = cls()
2624 n.target_user_group = target_user_group
2624 n.target_user_group = target_user_group
2625 n.user_group = user_group
2625 n.user_group = user_group
2626 n.permission = permission
2626 n.permission = permission
2627 Session().add(n)
2627 Session().add(n)
2628 return n
2628 return n
2629
2629
2630 def __unicode__(self):
2630 def __unicode__(self):
2631 return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)
2631 return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)
2632
2632
2633
2633
2634 class UserGroupToPerm(Base, BaseModel):
2634 class UserGroupToPerm(Base, BaseModel):
2635 __tablename__ = 'users_group_to_perm'
2635 __tablename__ = 'users_group_to_perm'
2636 __table_args__ = (
2636 __table_args__ = (
2637 UniqueConstraint('users_group_id', 'permission_id',),
2637 UniqueConstraint('users_group_id', 'permission_id',),
2638 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2638 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2639 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2639 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2640 )
2640 )
2641 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2641 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2642 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2642 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2643 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2643 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2644
2644
2645 users_group = relationship('UserGroup')
2645 users_group = relationship('UserGroup')
2646 permission = relationship('Permission')
2646 permission = relationship('Permission')
2647
2647
2648
2648
2649 class UserRepoGroupToPerm(Base, BaseModel):
2649 class UserRepoGroupToPerm(Base, BaseModel):
2650 __tablename__ = 'user_repo_group_to_perm'
2650 __tablename__ = 'user_repo_group_to_perm'
2651 __table_args__ = (
2651 __table_args__ = (
2652 UniqueConstraint('user_id', 'group_id', 'permission_id'),
2652 UniqueConstraint('user_id', 'group_id', 'permission_id'),
2653 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2653 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2654 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2654 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2655 )
2655 )
2656
2656
2657 group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2657 group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2658 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2658 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2659 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
2659 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
2660 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2660 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2661
2661
2662 user = relationship('User')
2662 user = relationship('User')
2663 group = relationship('RepoGroup')
2663 group = relationship('RepoGroup')
2664 permission = relationship('Permission')
2664 permission = relationship('Permission')
2665
2665
2666 @classmethod
2666 @classmethod
2667 def create(cls, user, repository_group, permission):
2667 def create(cls, user, repository_group, permission):
2668 n = cls()
2668 n = cls()
2669 n.user = user
2669 n.user = user
2670 n.group = repository_group
2670 n.group = repository_group
2671 n.permission = permission
2671 n.permission = permission
2672 Session().add(n)
2672 Session().add(n)
2673 return n
2673 return n
2674
2674
2675
2675
2676 class UserGroupRepoGroupToPerm(Base, BaseModel):
2676 class UserGroupRepoGroupToPerm(Base, BaseModel):
2677 __tablename__ = 'users_group_repo_group_to_perm'
2677 __tablename__ = 'users_group_repo_group_to_perm'
2678 __table_args__ = (
2678 __table_args__ = (
2679 UniqueConstraint('users_group_id', 'group_id'),
2679 UniqueConstraint('users_group_id', 'group_id'),
2680 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2680 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2681 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2681 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2682 )
2682 )
2683
2683
2684 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)
2684 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)
2685 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2685 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2686 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
2686 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
2687 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2687 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2688
2688
2689 users_group = relationship('UserGroup')
2689 users_group = relationship('UserGroup')
2690 permission = relationship('Permission')
2690 permission = relationship('Permission')
2691 group = relationship('RepoGroup')
2691 group = relationship('RepoGroup')
2692
2692
2693 @classmethod
2693 @classmethod
2694 def create(cls, user_group, repository_group, permission):
2694 def create(cls, user_group, repository_group, permission):
2695 n = cls()
2695 n = cls()
2696 n.users_group = user_group
2696 n.users_group = user_group
2697 n.group = repository_group
2697 n.group = repository_group
2698 n.permission = permission
2698 n.permission = permission
2699 Session().add(n)
2699 Session().add(n)
2700 return n
2700 return n
2701
2701
2702 def __unicode__(self):
2702 def __unicode__(self):
2703 return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)
2703 return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)
2704
2704
2705
2705
2706 class Statistics(Base, BaseModel):
2706 class Statistics(Base, BaseModel):
2707 __tablename__ = 'statistics'
2707 __tablename__ = 'statistics'
2708 __table_args__ = (
2708 __table_args__ = (
2709 UniqueConstraint('repository_id'),
2709 UniqueConstraint('repository_id'),
2710 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2710 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2711 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2711 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2712 )
2712 )
2713 stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2713 stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2714 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)
2714 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)
2715 stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)
2715 stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)
2716 commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data
2716 commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data
2717 commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data
2717 commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data
2718 languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data
2718 languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data
2719
2719
2720 repository = relationship('Repository', single_parent=True)
2720 repository = relationship('Repository', single_parent=True)
2721
2721
2722
2722
2723 class UserFollowing(Base, BaseModel):
2723 class UserFollowing(Base, BaseModel):
2724 __tablename__ = 'user_followings'
2724 __tablename__ = 'user_followings'
2725 __table_args__ = (
2725 __table_args__ = (
2726 UniqueConstraint('user_id', 'follows_repository_id'),
2726 UniqueConstraint('user_id', 'follows_repository_id'),
2727 UniqueConstraint('user_id', 'follows_user_id'),
2727 UniqueConstraint('user_id', 'follows_user_id'),
2728 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2728 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2729 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2729 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2730 )
2730 )
2731
2731
2732 user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2732 user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2733 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2733 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2734 follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)
2734 follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)
2735 follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
2735 follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
2736 follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
2736 follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
2737
2737
2738 user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')
2738 user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')
2739
2739
2740 follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')
2740 follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')
2741 follows_repository = relationship('Repository', order_by='Repository.repo_name')
2741 follows_repository = relationship('Repository', order_by='Repository.repo_name')
2742
2742
2743 @classmethod
2743 @classmethod
2744 def get_repo_followers(cls, repo_id):
2744 def get_repo_followers(cls, repo_id):
2745 return cls.query().filter(cls.follows_repo_id == repo_id)
2745 return cls.query().filter(cls.follows_repo_id == repo_id)
2746
2746
2747
2747
2748 class CacheKey(Base, BaseModel):
2748 class CacheKey(Base, BaseModel):
2749 __tablename__ = 'cache_invalidation'
2749 __tablename__ = 'cache_invalidation'
2750 __table_args__ = (
2750 __table_args__ = (
2751 UniqueConstraint('cache_key'),
2751 UniqueConstraint('cache_key'),
2752 Index('key_idx', 'cache_key'),
2752 Index('key_idx', 'cache_key'),
2753 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2753 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2754 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2754 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2755 )
2755 )
2756 CACHE_TYPE_ATOM = 'ATOM'
2756 CACHE_TYPE_ATOM = 'ATOM'
2757 CACHE_TYPE_RSS = 'RSS'
2757 CACHE_TYPE_RSS = 'RSS'
2758 CACHE_TYPE_README = 'README'
2758 CACHE_TYPE_README = 'README'
2759
2759
2760 cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2760 cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2761 cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None)
2761 cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None)
2762 cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None)
2762 cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None)
2763 cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)
2763 cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)
2764
2764
2765 def __init__(self, cache_key, cache_args=''):
2765 def __init__(self, cache_key, cache_args=''):
2766 self.cache_key = cache_key
2766 self.cache_key = cache_key
2767 self.cache_args = cache_args
2767 self.cache_args = cache_args
2768 self.cache_active = False
2768 self.cache_active = False
2769
2769
2770 def __unicode__(self):
2770 def __unicode__(self):
2771 return u"<%s('%s:%s[%s]')>" % (
2771 return u"<%s('%s:%s[%s]')>" % (
2772 self.__class__.__name__,
2772 self.__class__.__name__,
2773 self.cache_id, self.cache_key, self.cache_active)
2773 self.cache_id, self.cache_key, self.cache_active)
2774
2774
2775 def _cache_key_partition(self):
2775 def _cache_key_partition(self):
2776 prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)
2776 prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)
2777 return prefix, repo_name, suffix
2777 return prefix, repo_name, suffix
2778
2778
2779 def get_prefix(self):
2779 def get_prefix(self):
2780 """
2780 """
2781 Try to extract prefix from existing cache key. The key could consist
2781 Try to extract prefix from existing cache key. The key could consist
2782 of prefix, repo_name, suffix
2782 of prefix, repo_name, suffix
2783 """
2783 """
2784 # this returns prefix, repo_name, suffix
2784 # this returns prefix, repo_name, suffix
2785 return self._cache_key_partition()[0]
2785 return self._cache_key_partition()[0]
2786
2786
2787 def get_suffix(self):
2787 def get_suffix(self):
2788 """
2788 """
2789 get suffix that might have been used in _get_cache_key to
2789 get suffix that might have been used in _get_cache_key to
2790 generate self.cache_key. Only used for informational purposes
2790 generate self.cache_key. Only used for informational purposes
2791 in repo_edit.html.
2791 in repo_edit.html.
2792 """
2792 """
2793 # prefix, repo_name, suffix
2793 # prefix, repo_name, suffix
2794 return self._cache_key_partition()[2]
2794 return self._cache_key_partition()[2]
2795
2795
2796 @classmethod
2796 @classmethod
2797 def delete_all_cache(cls):
2797 def delete_all_cache(cls):
2798 """
2798 """
2799 Delete all cache keys from database.
2799 Delete all cache keys from database.
2800 Should only be run when all instances are down and all entries
2800 Should only be run when all instances are down and all entries
2801 thus stale.
2801 thus stale.
2802 """
2802 """
2803 cls.query().delete()
2803 cls.query().delete()
2804 Session().commit()
2804 Session().commit()
2805
2805
2806 @classmethod
2806 @classmethod
2807 def get_cache_key(cls, repo_name, cache_type):
2807 def get_cache_key(cls, repo_name, cache_type):
2808 """
2808 """
2809
2809
2810 Generate a cache key for this process of RhodeCode instance.
2810 Generate a cache key for this process of RhodeCode instance.
2811 Prefix most likely will be process id or maybe explicitly set
2811 Prefix most likely will be process id or maybe explicitly set
2812 instance_id from .ini file.
2812 instance_id from .ini file.
2813 """
2813 """
2814 import rhodecode
2814 import rhodecode
2815 prefix = safe_unicode(rhodecode.CONFIG.get('instance_id') or '')
2815 prefix = safe_unicode(rhodecode.CONFIG.get('instance_id') or '')
2816
2816
2817 repo_as_unicode = safe_unicode(repo_name)
2817 repo_as_unicode = safe_unicode(repo_name)
2818 key = u'{}_{}'.format(repo_as_unicode, cache_type) \
2818 key = u'{}_{}'.format(repo_as_unicode, cache_type) \
2819 if cache_type else repo_as_unicode
2819 if cache_type else repo_as_unicode
2820
2820
2821 return u'{}{}'.format(prefix, key)
2821 return u'{}{}'.format(prefix, key)
2822
2822
2823 @classmethod
2823 @classmethod
2824 def set_invalidate(cls, repo_name, delete=False):
2824 def set_invalidate(cls, repo_name, delete=False):
2825 """
2825 """
2826 Mark all caches of a repo as invalid in the database.
2826 Mark all caches of a repo as invalid in the database.
2827 """
2827 """
2828
2828
2829 try:
2829 try:
2830 qry = Session().query(cls).filter(cls.cache_args == repo_name)
2830 qry = Session().query(cls).filter(cls.cache_args == repo_name)
2831 if delete:
2831 if delete:
2832 log.debug('cache objects deleted for repo %s',
2832 log.debug('cache objects deleted for repo %s',
2833 safe_str(repo_name))
2833 safe_str(repo_name))
2834 qry.delete()
2834 qry.delete()
2835 else:
2835 else:
2836 log.debug('cache objects marked as invalid for repo %s',
2836 log.debug('cache objects marked as invalid for repo %s',
2837 safe_str(repo_name))
2837 safe_str(repo_name))
2838 qry.update({"cache_active": False})
2838 qry.update({"cache_active": False})
2839
2839
2840 Session().commit()
2840 Session().commit()
2841 except Exception:
2841 except Exception:
2842 log.exception(
2842 log.exception(
2843 'Cache key invalidation failed for repository %s',
2843 'Cache key invalidation failed for repository %s',
2844 safe_str(repo_name))
2844 safe_str(repo_name))
2845 Session().rollback()
2845 Session().rollback()
2846
2846
2847 @classmethod
2847 @classmethod
2848 def get_active_cache(cls, cache_key):
2848 def get_active_cache(cls, cache_key):
2849 inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()
2849 inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()
2850 if inv_obj:
2850 if inv_obj:
2851 return inv_obj
2851 return inv_obj
2852 return None
2852 return None
2853
2853
2854 @classmethod
2854 @classmethod
2855 def repo_context_cache(cls, compute_func, repo_name, cache_type,
2855 def repo_context_cache(cls, compute_func, repo_name, cache_type,
2856 thread_scoped=False):
2856 thread_scoped=False):
2857 """
2857 """
2858 @cache_region('long_term')
2858 @cache_region('long_term')
2859 def _heavy_calculation(cache_key):
2859 def _heavy_calculation(cache_key):
2860 return 'result'
2860 return 'result'
2861
2861
2862 cache_context = CacheKey.repo_context_cache(
2862 cache_context = CacheKey.repo_context_cache(
2863 _heavy_calculation, repo_name, cache_type)
2863 _heavy_calculation, repo_name, cache_type)
2864
2864
2865 with cache_context as context:
2865 with cache_context as context:
2866 context.invalidate()
2866 context.invalidate()
2867 computed = context.compute()
2867 computed = context.compute()
2868
2868
2869 assert computed == 'result'
2869 assert computed == 'result'
2870 """
2870 """
2871 from rhodecode.lib import caches
2871 from rhodecode.lib import caches
2872 return caches.InvalidationContext(
2872 return caches.InvalidationContext(
2873 compute_func, repo_name, cache_type, thread_scoped=thread_scoped)
2873 compute_func, repo_name, cache_type, thread_scoped=thread_scoped)
2874
2874
2875
2875
2876 class ChangesetComment(Base, BaseModel):
2876 class ChangesetComment(Base, BaseModel):
2877 __tablename__ = 'changeset_comments'
2877 __tablename__ = 'changeset_comments'
2878 __table_args__ = (
2878 __table_args__ = (
2879 Index('cc_revision_idx', 'revision'),
2879 Index('cc_revision_idx', 'revision'),
2880 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2880 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2881 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2881 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2882 )
2882 )
2883
2883
2884 COMMENT_OUTDATED = u'comment_outdated'
2884 COMMENT_OUTDATED = u'comment_outdated'
2885
2885
2886 comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)
2886 comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)
2887 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
2887 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
2888 revision = Column('revision', String(40), nullable=True)
2888 revision = Column('revision', String(40), nullable=True)
2889 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
2889 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
2890 pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True)
2890 pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True)
2891 line_no = Column('line_no', Unicode(10), nullable=True)
2891 line_no = Column('line_no', Unicode(10), nullable=True)
2892 hl_lines = Column('hl_lines', Unicode(512), nullable=True)
2892 hl_lines = Column('hl_lines', Unicode(512), nullable=True)
2893 f_path = Column('f_path', Unicode(1000), nullable=True)
2893 f_path = Column('f_path', Unicode(1000), nullable=True)
2894 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
2894 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
2895 text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)
2895 text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)
2896 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
2896 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
2897 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
2897 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
2898 renderer = Column('renderer', Unicode(64), nullable=True)
2898 renderer = Column('renderer', Unicode(64), nullable=True)
2899 display_state = Column('display_state', Unicode(128), nullable=True)
2899 display_state = Column('display_state', Unicode(128), nullable=True)
2900
2900
2901 author = relationship('User', lazy='joined')
2901 author = relationship('User', lazy='joined')
2902 repo = relationship('Repository')
2902 repo = relationship('Repository')
2903 status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan")
2903 status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan")
2904 pull_request = relationship('PullRequest', lazy='joined')
2904 pull_request = relationship('PullRequest', lazy='joined')
2905 pull_request_version = relationship('PullRequestVersion')
2905 pull_request_version = relationship('PullRequestVersion')
2906
2906
2907 @classmethod
2907 @classmethod
2908 def get_users(cls, revision=None, pull_request_id=None):
2908 def get_users(cls, revision=None, pull_request_id=None):
2909 """
2909 """
2910 Returns user associated with this ChangesetComment. ie those
2910 Returns user associated with this ChangesetComment. ie those
2911 who actually commented
2911 who actually commented
2912
2912
2913 :param cls:
2913 :param cls:
2914 :param revision:
2914 :param revision:
2915 """
2915 """
2916 q = Session().query(User)\
2916 q = Session().query(User)\
2917 .join(ChangesetComment.author)
2917 .join(ChangesetComment.author)
2918 if revision:
2918 if revision:
2919 q = q.filter(cls.revision == revision)
2919 q = q.filter(cls.revision == revision)
2920 elif pull_request_id:
2920 elif pull_request_id:
2921 q = q.filter(cls.pull_request_id == pull_request_id)
2921 q = q.filter(cls.pull_request_id == pull_request_id)
2922 return q.all()
2922 return q.all()
2923
2923
2924 def render(self, mentions=False):
2924 def render(self, mentions=False):
2925 from rhodecode.lib import helpers as h
2925 from rhodecode.lib import helpers as h
2926 return h.render(self.text, renderer=self.renderer, mentions=mentions)
2926 return h.render(self.text, renderer=self.renderer, mentions=mentions)
2927
2927
2928 def __repr__(self):
2928 def __repr__(self):
2929 if self.comment_id:
2929 if self.comment_id:
2930 return '<DB:ChangesetComment #%s>' % self.comment_id
2930 return '<DB:ChangesetComment #%s>' % self.comment_id
2931 else:
2931 else:
2932 return '<DB:ChangesetComment at %#x>' % id(self)
2932 return '<DB:ChangesetComment at %#x>' % id(self)
2933
2933
2934
2934
2935 class ChangesetStatus(Base, BaseModel):
2935 class ChangesetStatus(Base, BaseModel):
2936 __tablename__ = 'changeset_statuses'
2936 __tablename__ = 'changeset_statuses'
2937 __table_args__ = (
2937 __table_args__ = (
2938 Index('cs_revision_idx', 'revision'),
2938 Index('cs_revision_idx', 'revision'),
2939 Index('cs_version_idx', 'version'),
2939 Index('cs_version_idx', 'version'),
2940 UniqueConstraint('repo_id', 'revision', 'version'),
2940 UniqueConstraint('repo_id', 'revision', 'version'),
2941 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2941 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2942 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2942 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2943 )
2943 )
2944 STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'
2944 STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'
2945 STATUS_APPROVED = 'approved'
2945 STATUS_APPROVED = 'approved'
2946 STATUS_REJECTED = 'rejected'
2946 STATUS_REJECTED = 'rejected'
2947 STATUS_UNDER_REVIEW = 'under_review'
2947 STATUS_UNDER_REVIEW = 'under_review'
2948
2948
2949 STATUSES = [
2949 STATUSES = [
2950 (STATUS_NOT_REVIEWED, _("Not Reviewed")), # (no icon) and default
2950 (STATUS_NOT_REVIEWED, _("Not Reviewed")), # (no icon) and default
2951 (STATUS_APPROVED, _("Approved")),
2951 (STATUS_APPROVED, _("Approved")),
2952 (STATUS_REJECTED, _("Rejected")),
2952 (STATUS_REJECTED, _("Rejected")),
2953 (STATUS_UNDER_REVIEW, _("Under Review")),
2953 (STATUS_UNDER_REVIEW, _("Under Review")),
2954 ]
2954 ]
2955
2955
2956 changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)
2956 changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)
2957 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
2957 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
2958 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)
2958 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)
2959 revision = Column('revision', String(40), nullable=False)
2959 revision = Column('revision', String(40), nullable=False)
2960 status = Column('status', String(128), nullable=False, default=DEFAULT)
2960 status = Column('status', String(128), nullable=False, default=DEFAULT)
2961 changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))
2961 changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))
2962 modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)
2962 modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)
2963 version = Column('version', Integer(), nullable=False, default=0)
2963 version = Column('version', Integer(), nullable=False, default=0)
2964 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
2964 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
2965
2965
2966 author = relationship('User', lazy='joined')
2966 author = relationship('User', lazy='joined')
2967 repo = relationship('Repository')
2967 repo = relationship('Repository')
2968 comment = relationship('ChangesetComment', lazy='joined')
2968 comment = relationship('ChangesetComment', lazy='joined')
2969 pull_request = relationship('PullRequest', lazy='joined')
2969 pull_request = relationship('PullRequest', lazy='joined')
2970
2970
2971 def __unicode__(self):
2971 def __unicode__(self):
2972 return u"<%s('%s[%s]:%s')>" % (
2972 return u"<%s('%s[%s]:%s')>" % (
2973 self.__class__.__name__,
2973 self.__class__.__name__,
2974 self.status, self.version, self.author
2974 self.status, self.version, self.author
2975 )
2975 )
2976
2976
2977 @classmethod
2977 @classmethod
2978 def get_status_lbl(cls, value):
2978 def get_status_lbl(cls, value):
2979 return dict(cls.STATUSES).get(value)
2979 return dict(cls.STATUSES).get(value)
2980
2980
2981 @property
2981 @property
2982 def status_lbl(self):
2982 def status_lbl(self):
2983 return ChangesetStatus.get_status_lbl(self.status)
2983 return ChangesetStatus.get_status_lbl(self.status)
2984
2984
2985
2985
2986 class _PullRequestBase(BaseModel):
2986 class _PullRequestBase(BaseModel):
2987 """
2987 """
2988 Common attributes of pull request and version entries.
2988 Common attributes of pull request and version entries.
2989 """
2989 """
2990
2990
2991 # .status values
2991 # .status values
2992 STATUS_NEW = u'new'
2992 STATUS_NEW = u'new'
2993 STATUS_OPEN = u'open'
2993 STATUS_OPEN = u'open'
2994 STATUS_CLOSED = u'closed'
2994 STATUS_CLOSED = u'closed'
2995
2995
2996 title = Column('title', Unicode(255), nullable=True)
2996 title = Column('title', Unicode(255), nullable=True)
2997 description = Column(
2997 description = Column(
2998 'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),
2998 'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),
2999 nullable=True)
2999 nullable=True)
3000 # new/open/closed status of pull request (not approve/reject/etc)
3000 # new/open/closed status of pull request (not approve/reject/etc)
3001 status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW)
3001 status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW)
3002 created_on = Column(
3002 created_on = Column(
3003 'created_on', DateTime(timezone=False), nullable=False,
3003 'created_on', DateTime(timezone=False), nullable=False,
3004 default=datetime.datetime.now)
3004 default=datetime.datetime.now)
3005 updated_on = Column(
3005 updated_on = Column(
3006 'updated_on', DateTime(timezone=False), nullable=False,
3006 'updated_on', DateTime(timezone=False), nullable=False,
3007 default=datetime.datetime.now)
3007 default=datetime.datetime.now)
3008
3008
3009 @declared_attr
3009 @declared_attr
3010 def user_id(cls):
3010 def user_id(cls):
3011 return Column(
3011 return Column(
3012 "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
3012 "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
3013 unique=None)
3013 unique=None)
3014
3014
3015 # 500 revisions max
3015 # 500 revisions max
3016 _revisions = Column(
3016 _revisions = Column(
3017 'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql'))
3017 'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql'))
3018
3018
3019 @declared_attr
3019 @declared_attr
3020 def source_repo_id(cls):
3020 def source_repo_id(cls):
3021 # TODO: dan: rename column to source_repo_id
3021 # TODO: dan: rename column to source_repo_id
3022 return Column(
3022 return Column(
3023 'org_repo_id', Integer(), ForeignKey('repositories.repo_id'),
3023 'org_repo_id', Integer(), ForeignKey('repositories.repo_id'),
3024 nullable=False)
3024 nullable=False)
3025
3025
3026 source_ref = Column('org_ref', Unicode(255), nullable=False)
3026 source_ref = Column('org_ref', Unicode(255), nullable=False)
3027
3027
3028 @declared_attr
3028 @declared_attr
3029 def target_repo_id(cls):
3029 def target_repo_id(cls):
3030 # TODO: dan: rename column to target_repo_id
3030 # TODO: dan: rename column to target_repo_id
3031 return Column(
3031 return Column(
3032 'other_repo_id', Integer(), ForeignKey('repositories.repo_id'),
3032 'other_repo_id', Integer(), ForeignKey('repositories.repo_id'),
3033 nullable=False)
3033 nullable=False)
3034
3034
3035 target_ref = Column('other_ref', Unicode(255), nullable=False)
3035 target_ref = Column('other_ref', Unicode(255), nullable=False)
3036 _shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True)
3036
3037
3037 # TODO: dan: rename column to last_merge_source_rev
3038 # TODO: dan: rename column to last_merge_source_rev
3038 _last_merge_source_rev = Column(
3039 _last_merge_source_rev = Column(
3039 'last_merge_org_rev', String(40), nullable=True)
3040 'last_merge_org_rev', String(40), nullable=True)
3040 # TODO: dan: rename column to last_merge_target_rev
3041 # TODO: dan: rename column to last_merge_target_rev
3041 _last_merge_target_rev = Column(
3042 _last_merge_target_rev = Column(
3042 'last_merge_other_rev', String(40), nullable=True)
3043 'last_merge_other_rev', String(40), nullable=True)
3043 _last_merge_status = Column('merge_status', Integer(), nullable=True)
3044 _last_merge_status = Column('merge_status', Integer(), nullable=True)
3044 last_merge_rev = Column('last_merge_rev', String(40), nullable=True)
3045 merge_rev = Column('merge_rev', String(40), nullable=True)
3045 merge_rev = Column('merge_rev', String(40), nullable=True)
3046
3046
3047 @hybrid_property
3047 @hybrid_property
3048 def revisions(self):
3048 def revisions(self):
3049 return self._revisions.split(':') if self._revisions else []
3049 return self._revisions.split(':') if self._revisions else []
3050
3050
3051 @revisions.setter
3051 @revisions.setter
3052 def revisions(self, val):
3052 def revisions(self, val):
3053 self._revisions = ':'.join(val)
3053 self._revisions = ':'.join(val)
3054
3054
3055 @declared_attr
3055 @declared_attr
3056 def author(cls):
3056 def author(cls):
3057 return relationship('User', lazy='joined')
3057 return relationship('User', lazy='joined')
3058
3058
3059 @declared_attr
3059 @declared_attr
3060 def source_repo(cls):
3060 def source_repo(cls):
3061 return relationship(
3061 return relationship(
3062 'Repository',
3062 'Repository',
3063 primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__)
3063 primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__)
3064
3064
3065 @property
3065 @property
3066 def source_ref_parts(self):
3066 def source_ref_parts(self):
3067 return self.unicode_to_reference(self.source_ref)
3067 return self.unicode_to_reference(self.source_ref)
3068
3068
3069 @declared_attr
3069 @declared_attr
3070 def target_repo(cls):
3070 def target_repo(cls):
3071 return relationship(
3071 return relationship(
3072 'Repository',
3072 'Repository',
3073 primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__)
3073 primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__)
3074
3074
3075 @property
3075 @property
3076 def target_ref_parts(self):
3076 def target_ref_parts(self):
3077 return self.unicode_to_reference(self.target_ref)
3077 return self.unicode_to_reference(self.target_ref)
3078
3078
3079 @property
3080 def shadow_merge_ref(self):
3081 return self.unicode_to_reference(self._shadow_merge_ref)
3082
3083 @shadow_merge_ref.setter
3084 def shadow_merge_ref(self, ref):
3085 self._shadow_merge_ref = self.reference_to_unicode(ref)
3086
3079 def unicode_to_reference(self, raw):
3087 def unicode_to_reference(self, raw):
3080 """
3088 """
3081 Convert a unicode (or string) to a reference object.
3089 Convert a unicode (or string) to a reference object.
3082 If unicode evaluates to False it returns None.
3090 If unicode evaluates to False it returns None.
3083 """
3091 """
3084 if raw:
3092 if raw:
3085 refs = raw.split(':')
3093 refs = raw.split(':')
3086 return Reference(*refs)
3094 return Reference(*refs)
3087 else:
3095 else:
3088 return None
3096 return None
3089
3097
3090 def reference_to_unicode(self, ref):
3098 def reference_to_unicode(self, ref):
3091 """
3099 """
3092 Convert a reference object to unicode.
3100 Convert a reference object to unicode.
3093 If reference is None it returns None.
3101 If reference is None it returns None.
3094 """
3102 """
3095 if ref:
3103 if ref:
3096 return u':'.join(ref)
3104 return u':'.join(ref)
3097 else:
3105 else:
3098 return None
3106 return None
3099
3107
3100
3108
3101 class PullRequest(Base, _PullRequestBase):
3109 class PullRequest(Base, _PullRequestBase):
3102 __tablename__ = 'pull_requests'
3110 __tablename__ = 'pull_requests'
3103 __table_args__ = (
3111 __table_args__ = (
3104 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3112 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3105 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3113 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3106 )
3114 )
3107
3115
3108 pull_request_id = Column(
3116 pull_request_id = Column(
3109 'pull_request_id', Integer(), nullable=False, primary_key=True)
3117 'pull_request_id', Integer(), nullable=False, primary_key=True)
3110
3118
3111 def __repr__(self):
3119 def __repr__(self):
3112 if self.pull_request_id:
3120 if self.pull_request_id:
3113 return '<DB:PullRequest #%s>' % self.pull_request_id
3121 return '<DB:PullRequest #%s>' % self.pull_request_id
3114 else:
3122 else:
3115 return '<DB:PullRequest at %#x>' % id(self)
3123 return '<DB:PullRequest at %#x>' % id(self)
3116
3124
3117 reviewers = relationship('PullRequestReviewers',
3125 reviewers = relationship('PullRequestReviewers',
3118 cascade="all, delete, delete-orphan")
3126 cascade="all, delete, delete-orphan")
3119 statuses = relationship('ChangesetStatus')
3127 statuses = relationship('ChangesetStatus')
3120 comments = relationship('ChangesetComment',
3128 comments = relationship('ChangesetComment',
3121 cascade="all, delete, delete-orphan")
3129 cascade="all, delete, delete-orphan")
3122 versions = relationship('PullRequestVersion',
3130 versions = relationship('PullRequestVersion',
3123 cascade="all, delete, delete-orphan")
3131 cascade="all, delete, delete-orphan")
3124
3132
3125 def is_closed(self):
3133 def is_closed(self):
3126 return self.status == self.STATUS_CLOSED
3134 return self.status == self.STATUS_CLOSED
3127
3135
3128 def get_api_data(self):
3136 def get_api_data(self):
3129 from rhodecode.model.pull_request import PullRequestModel
3137 from rhodecode.model.pull_request import PullRequestModel
3130 pull_request = self
3138 pull_request = self
3131 merge_status = PullRequestModel().merge_status(pull_request)
3139 merge_status = PullRequestModel().merge_status(pull_request)
3132 pull_request_url = url(
3140 pull_request_url = url(
3133 'pullrequest_show', repo_name=self.target_repo.repo_name,
3141 'pullrequest_show', repo_name=self.target_repo.repo_name,
3134 pull_request_id=self.pull_request_id, qualified=True)
3142 pull_request_id=self.pull_request_id, qualified=True)
3135 data = {
3143 data = {
3136 'pull_request_id': pull_request.pull_request_id,
3144 'pull_request_id': pull_request.pull_request_id,
3137 'url': pull_request_url,
3145 'url': pull_request_url,
3138 'title': pull_request.title,
3146 'title': pull_request.title,
3139 'description': pull_request.description,
3147 'description': pull_request.description,
3140 'status': pull_request.status,
3148 'status': pull_request.status,
3141 'created_on': pull_request.created_on,
3149 'created_on': pull_request.created_on,
3142 'updated_on': pull_request.updated_on,
3150 'updated_on': pull_request.updated_on,
3143 'commit_ids': pull_request.revisions,
3151 'commit_ids': pull_request.revisions,
3144 'review_status': pull_request.calculated_review_status(),
3152 'review_status': pull_request.calculated_review_status(),
3145 'mergeable': {
3153 'mergeable': {
3146 'status': merge_status[0],
3154 'status': merge_status[0],
3147 'message': unicode(merge_status[1]),
3155 'message': unicode(merge_status[1]),
3148 },
3156 },
3149 'source': {
3157 'source': {
3150 'clone_url': pull_request.source_repo.clone_url(),
3158 'clone_url': pull_request.source_repo.clone_url(),
3151 'repository': pull_request.source_repo.repo_name,
3159 'repository': pull_request.source_repo.repo_name,
3152 'reference': {
3160 'reference': {
3153 'name': pull_request.source_ref_parts.name,
3161 'name': pull_request.source_ref_parts.name,
3154 'type': pull_request.source_ref_parts.type,
3162 'type': pull_request.source_ref_parts.type,
3155 'commit_id': pull_request.source_ref_parts.commit_id,
3163 'commit_id': pull_request.source_ref_parts.commit_id,
3156 },
3164 },
3157 },
3165 },
3158 'target': {
3166 'target': {
3159 'clone_url': pull_request.target_repo.clone_url(),
3167 'clone_url': pull_request.target_repo.clone_url(),
3160 'repository': pull_request.target_repo.repo_name,
3168 'repository': pull_request.target_repo.repo_name,
3161 'reference': {
3169 'reference': {
3162 'name': pull_request.target_ref_parts.name,
3170 'name': pull_request.target_ref_parts.name,
3163 'type': pull_request.target_ref_parts.type,
3171 'type': pull_request.target_ref_parts.type,
3164 'commit_id': pull_request.target_ref_parts.commit_id,
3172 'commit_id': pull_request.target_ref_parts.commit_id,
3165 },
3173 },
3166 },
3174 },
3167 'shadow': {
3175 'shadow': {
3168 'clone_url': PullRequestModel().get_shadow_clone_url(
3176 'clone_url': PullRequestModel().get_shadow_clone_url(
3169 pull_request),
3177 pull_request),
3170 },
3178 },
3171 'author': pull_request.author.get_api_data(include_secrets=False,
3179 'author': pull_request.author.get_api_data(include_secrets=False,
3172 details='basic'),
3180 details='basic'),
3173 'reviewers': [
3181 'reviewers': [
3174 {
3182 {
3175 'user': reviewer.get_api_data(include_secrets=False,
3183 'user': reviewer.get_api_data(include_secrets=False,
3176 details='basic'),
3184 details='basic'),
3177 'reasons': reasons,
3185 'reasons': reasons,
3178 'review_status': st[0][1].status if st else 'not_reviewed',
3186 'review_status': st[0][1].status if st else 'not_reviewed',
3179 }
3187 }
3180 for reviewer, reasons, st in pull_request.reviewers_statuses()
3188 for reviewer, reasons, st in pull_request.reviewers_statuses()
3181 ]
3189 ]
3182 }
3190 }
3183
3191
3184 return data
3192 return data
3185
3193
3186 def __json__(self):
3194 def __json__(self):
3187 return {
3195 return {
3188 'revisions': self.revisions,
3196 'revisions': self.revisions,
3189 }
3197 }
3190
3198
3191 def calculated_review_status(self):
3199 def calculated_review_status(self):
3192 # TODO: anderson: 13.05.15 Used only on templates/my_account_pullrequests.html
3200 # TODO: anderson: 13.05.15 Used only on templates/my_account_pullrequests.html
3193 # because it's tricky on how to use ChangesetStatusModel from there
3201 # because it's tricky on how to use ChangesetStatusModel from there
3194 warnings.warn("Use calculated_review_status from ChangesetStatusModel", DeprecationWarning)
3202 warnings.warn("Use calculated_review_status from ChangesetStatusModel", DeprecationWarning)
3195 from rhodecode.model.changeset_status import ChangesetStatusModel
3203 from rhodecode.model.changeset_status import ChangesetStatusModel
3196 return ChangesetStatusModel().calculated_review_status(self)
3204 return ChangesetStatusModel().calculated_review_status(self)
3197
3205
3198 def reviewers_statuses(self):
3206 def reviewers_statuses(self):
3199 warnings.warn("Use reviewers_statuses from ChangesetStatusModel", DeprecationWarning)
3207 warnings.warn("Use reviewers_statuses from ChangesetStatusModel", DeprecationWarning)
3200 from rhodecode.model.changeset_status import ChangesetStatusModel
3208 from rhodecode.model.changeset_status import ChangesetStatusModel
3201 return ChangesetStatusModel().reviewers_statuses(self)
3209 return ChangesetStatusModel().reviewers_statuses(self)
3202
3210
3203
3211
3204 class PullRequestVersion(Base, _PullRequestBase):
3212 class PullRequestVersion(Base, _PullRequestBase):
3205 __tablename__ = 'pull_request_versions'
3213 __tablename__ = 'pull_request_versions'
3206 __table_args__ = (
3214 __table_args__ = (
3207 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3215 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3208 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3216 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3209 )
3217 )
3210
3218
3211 pull_request_version_id = Column(
3219 pull_request_version_id = Column(
3212 'pull_request_version_id', Integer(), nullable=False, primary_key=True)
3220 'pull_request_version_id', Integer(), nullable=False, primary_key=True)
3213 pull_request_id = Column(
3221 pull_request_id = Column(
3214 'pull_request_id', Integer(),
3222 'pull_request_id', Integer(),
3215 ForeignKey('pull_requests.pull_request_id'), nullable=False)
3223 ForeignKey('pull_requests.pull_request_id'), nullable=False)
3216 pull_request = relationship('PullRequest')
3224 pull_request = relationship('PullRequest')
3217
3225
3218 def __repr__(self):
3226 def __repr__(self):
3219 if self.pull_request_version_id:
3227 if self.pull_request_version_id:
3220 return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id
3228 return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id
3221 else:
3229 else:
3222 return '<DB:PullRequestVersion at %#x>' % id(self)
3230 return '<DB:PullRequestVersion at %#x>' % id(self)
3223
3231
3224
3232
3225 class PullRequestReviewers(Base, BaseModel):
3233 class PullRequestReviewers(Base, BaseModel):
3226 __tablename__ = 'pull_request_reviewers'
3234 __tablename__ = 'pull_request_reviewers'
3227 __table_args__ = (
3235 __table_args__ = (
3228 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3236 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3229 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3237 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3230 )
3238 )
3231
3239
3232 def __init__(self, user=None, pull_request=None, reasons=None):
3240 def __init__(self, user=None, pull_request=None, reasons=None):
3233 self.user = user
3241 self.user = user
3234 self.pull_request = pull_request
3242 self.pull_request = pull_request
3235 self.reasons = reasons or []
3243 self.reasons = reasons or []
3236
3244
3237 @hybrid_property
3245 @hybrid_property
3238 def reasons(self):
3246 def reasons(self):
3239 if not self._reasons:
3247 if not self._reasons:
3240 return []
3248 return []
3241 return self._reasons
3249 return self._reasons
3242
3250
3243 @reasons.setter
3251 @reasons.setter
3244 def reasons(self, val):
3252 def reasons(self, val):
3245 val = val or []
3253 val = val or []
3246 if any(not isinstance(x, basestring) for x in val):
3254 if any(not isinstance(x, basestring) for x in val):
3247 raise Exception('invalid reasons type, must be list of strings')
3255 raise Exception('invalid reasons type, must be list of strings')
3248 self._reasons = val
3256 self._reasons = val
3249
3257
3250 pull_requests_reviewers_id = Column(
3258 pull_requests_reviewers_id = Column(
3251 'pull_requests_reviewers_id', Integer(), nullable=False,
3259 'pull_requests_reviewers_id', Integer(), nullable=False,
3252 primary_key=True)
3260 primary_key=True)
3253 pull_request_id = Column(
3261 pull_request_id = Column(
3254 "pull_request_id", Integer(),
3262 "pull_request_id", Integer(),
3255 ForeignKey('pull_requests.pull_request_id'), nullable=False)
3263 ForeignKey('pull_requests.pull_request_id'), nullable=False)
3256 user_id = Column(
3264 user_id = Column(
3257 "user_id", Integer(), ForeignKey('users.user_id'), nullable=True)
3265 "user_id", Integer(), ForeignKey('users.user_id'), nullable=True)
3258 _reasons = Column(
3266 _reasons = Column(
3259 'reason', MutationList.as_mutable(
3267 'reason', MutationList.as_mutable(
3260 JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))
3268 JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))
3261
3269
3262 user = relationship('User')
3270 user = relationship('User')
3263 pull_request = relationship('PullRequest')
3271 pull_request = relationship('PullRequest')
3264
3272
3265
3273
3266 class Notification(Base, BaseModel):
3274 class Notification(Base, BaseModel):
3267 __tablename__ = 'notifications'
3275 __tablename__ = 'notifications'
3268 __table_args__ = (
3276 __table_args__ = (
3269 Index('notification_type_idx', 'type'),
3277 Index('notification_type_idx', 'type'),
3270 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3278 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3271 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3279 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3272 )
3280 )
3273
3281
3274 TYPE_CHANGESET_COMMENT = u'cs_comment'
3282 TYPE_CHANGESET_COMMENT = u'cs_comment'
3275 TYPE_MESSAGE = u'message'
3283 TYPE_MESSAGE = u'message'
3276 TYPE_MENTION = u'mention'
3284 TYPE_MENTION = u'mention'
3277 TYPE_REGISTRATION = u'registration'
3285 TYPE_REGISTRATION = u'registration'
3278 TYPE_PULL_REQUEST = u'pull_request'
3286 TYPE_PULL_REQUEST = u'pull_request'
3279 TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'
3287 TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'
3280
3288
3281 notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)
3289 notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)
3282 subject = Column('subject', Unicode(512), nullable=True)
3290 subject = Column('subject', Unicode(512), nullable=True)
3283 body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)
3291 body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)
3284 created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)
3292 created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)
3285 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3293 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3286 type_ = Column('type', Unicode(255))
3294 type_ = Column('type', Unicode(255))
3287
3295
3288 created_by_user = relationship('User')
3296 created_by_user = relationship('User')
3289 notifications_to_users = relationship('UserNotification', lazy='joined',
3297 notifications_to_users = relationship('UserNotification', lazy='joined',
3290 cascade="all, delete, delete-orphan")
3298 cascade="all, delete, delete-orphan")
3291
3299
3292 @property
3300 @property
3293 def recipients(self):
3301 def recipients(self):
3294 return [x.user for x in UserNotification.query()\
3302 return [x.user for x in UserNotification.query()\
3295 .filter(UserNotification.notification == self)\
3303 .filter(UserNotification.notification == self)\
3296 .order_by(UserNotification.user_id.asc()).all()]
3304 .order_by(UserNotification.user_id.asc()).all()]
3297
3305
3298 @classmethod
3306 @classmethod
3299 def create(cls, created_by, subject, body, recipients, type_=None):
3307 def create(cls, created_by, subject, body, recipients, type_=None):
3300 if type_ is None:
3308 if type_ is None:
3301 type_ = Notification.TYPE_MESSAGE
3309 type_ = Notification.TYPE_MESSAGE
3302
3310
3303 notification = cls()
3311 notification = cls()
3304 notification.created_by_user = created_by
3312 notification.created_by_user = created_by
3305 notification.subject = subject
3313 notification.subject = subject
3306 notification.body = body
3314 notification.body = body
3307 notification.type_ = type_
3315 notification.type_ = type_
3308 notification.created_on = datetime.datetime.now()
3316 notification.created_on = datetime.datetime.now()
3309
3317
3310 for u in recipients:
3318 for u in recipients:
3311 assoc = UserNotification()
3319 assoc = UserNotification()
3312 assoc.notification = notification
3320 assoc.notification = notification
3313
3321
3314 # if created_by is inside recipients mark his notification
3322 # if created_by is inside recipients mark his notification
3315 # as read
3323 # as read
3316 if u.user_id == created_by.user_id:
3324 if u.user_id == created_by.user_id:
3317 assoc.read = True
3325 assoc.read = True
3318
3326
3319 u.notifications.append(assoc)
3327 u.notifications.append(assoc)
3320 Session().add(notification)
3328 Session().add(notification)
3321
3329
3322 return notification
3330 return notification
3323
3331
3324 @property
3332 @property
3325 def description(self):
3333 def description(self):
3326 from rhodecode.model.notification import NotificationModel
3334 from rhodecode.model.notification import NotificationModel
3327 return NotificationModel().make_description(self)
3335 return NotificationModel().make_description(self)
3328
3336
3329
3337
3330 class UserNotification(Base, BaseModel):
3338 class UserNotification(Base, BaseModel):
3331 __tablename__ = 'user_to_notification'
3339 __tablename__ = 'user_to_notification'
3332 __table_args__ = (
3340 __table_args__ = (
3333 UniqueConstraint('user_id', 'notification_id'),
3341 UniqueConstraint('user_id', 'notification_id'),
3334 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3342 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3335 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3343 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3336 )
3344 )
3337 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
3345 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
3338 notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)
3346 notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)
3339 read = Column('read', Boolean, default=False)
3347 read = Column('read', Boolean, default=False)
3340 sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)
3348 sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)
3341
3349
3342 user = relationship('User', lazy="joined")
3350 user = relationship('User', lazy="joined")
3343 notification = relationship('Notification', lazy="joined",
3351 notification = relationship('Notification', lazy="joined",
3344 order_by=lambda: Notification.created_on.desc(),)
3352 order_by=lambda: Notification.created_on.desc(),)
3345
3353
3346 def mark_as_read(self):
3354 def mark_as_read(self):
3347 self.read = True
3355 self.read = True
3348 Session().add(self)
3356 Session().add(self)
3349
3357
3350
3358
3351 class Gist(Base, BaseModel):
3359 class Gist(Base, BaseModel):
3352 __tablename__ = 'gists'
3360 __tablename__ = 'gists'
3353 __table_args__ = (
3361 __table_args__ = (
3354 Index('g_gist_access_id_idx', 'gist_access_id'),
3362 Index('g_gist_access_id_idx', 'gist_access_id'),
3355 Index('g_created_on_idx', 'created_on'),
3363 Index('g_created_on_idx', 'created_on'),
3356 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3364 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3357 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3365 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3358 )
3366 )
3359 GIST_PUBLIC = u'public'
3367 GIST_PUBLIC = u'public'
3360 GIST_PRIVATE = u'private'
3368 GIST_PRIVATE = u'private'
3361 DEFAULT_FILENAME = u'gistfile1.txt'
3369 DEFAULT_FILENAME = u'gistfile1.txt'
3362
3370
3363 ACL_LEVEL_PUBLIC = u'acl_public'
3371 ACL_LEVEL_PUBLIC = u'acl_public'
3364 ACL_LEVEL_PRIVATE = u'acl_private'
3372 ACL_LEVEL_PRIVATE = u'acl_private'
3365
3373
3366 gist_id = Column('gist_id', Integer(), primary_key=True)
3374 gist_id = Column('gist_id', Integer(), primary_key=True)
3367 gist_access_id = Column('gist_access_id', Unicode(250))
3375 gist_access_id = Column('gist_access_id', Unicode(250))
3368 gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
3376 gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
3369 gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True)
3377 gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True)
3370 gist_expires = Column('gist_expires', Float(53), nullable=False)
3378 gist_expires = Column('gist_expires', Float(53), nullable=False)
3371 gist_type = Column('gist_type', Unicode(128), nullable=False)
3379 gist_type = Column('gist_type', Unicode(128), nullable=False)
3372 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3380 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3373 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3381 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3374 acl_level = Column('acl_level', Unicode(128), nullable=True)
3382 acl_level = Column('acl_level', Unicode(128), nullable=True)
3375
3383
3376 owner = relationship('User')
3384 owner = relationship('User')
3377
3385
3378 def __repr__(self):
3386 def __repr__(self):
3379 return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)
3387 return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)
3380
3388
3381 @classmethod
3389 @classmethod
3382 def get_or_404(cls, id_):
3390 def get_or_404(cls, id_):
3383 res = cls.query().filter(cls.gist_access_id == id_).scalar()
3391 res = cls.query().filter(cls.gist_access_id == id_).scalar()
3384 if not res:
3392 if not res:
3385 raise HTTPNotFound
3393 raise HTTPNotFound
3386 return res
3394 return res
3387
3395
3388 @classmethod
3396 @classmethod
3389 def get_by_access_id(cls, gist_access_id):
3397 def get_by_access_id(cls, gist_access_id):
3390 return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()
3398 return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()
3391
3399
3392 def gist_url(self):
3400 def gist_url(self):
3393 import rhodecode
3401 import rhodecode
3394 alias_url = rhodecode.CONFIG.get('gist_alias_url')
3402 alias_url = rhodecode.CONFIG.get('gist_alias_url')
3395 if alias_url:
3403 if alias_url:
3396 return alias_url.replace('{gistid}', self.gist_access_id)
3404 return alias_url.replace('{gistid}', self.gist_access_id)
3397
3405
3398 return url('gist', gist_id=self.gist_access_id, qualified=True)
3406 return url('gist', gist_id=self.gist_access_id, qualified=True)
3399
3407
3400 @classmethod
3408 @classmethod
3401 def base_path(cls):
3409 def base_path(cls):
3402 """
3410 """
3403 Returns base path when all gists are stored
3411 Returns base path when all gists are stored
3404
3412
3405 :param cls:
3413 :param cls:
3406 """
3414 """
3407 from rhodecode.model.gist import GIST_STORE_LOC
3415 from rhodecode.model.gist import GIST_STORE_LOC
3408 q = Session().query(RhodeCodeUi)\
3416 q = Session().query(RhodeCodeUi)\
3409 .filter(RhodeCodeUi.ui_key == URL_SEP)
3417 .filter(RhodeCodeUi.ui_key == URL_SEP)
3410 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
3418 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
3411 return os.path.join(q.one().ui_value, GIST_STORE_LOC)
3419 return os.path.join(q.one().ui_value, GIST_STORE_LOC)
3412
3420
3413 def get_api_data(self):
3421 def get_api_data(self):
3414 """
3422 """
3415 Common function for generating gist related data for API
3423 Common function for generating gist related data for API
3416 """
3424 """
3417 gist = self
3425 gist = self
3418 data = {
3426 data = {
3419 'gist_id': gist.gist_id,
3427 'gist_id': gist.gist_id,
3420 'type': gist.gist_type,
3428 'type': gist.gist_type,
3421 'access_id': gist.gist_access_id,
3429 'access_id': gist.gist_access_id,
3422 'description': gist.gist_description,
3430 'description': gist.gist_description,
3423 'url': gist.gist_url(),
3431 'url': gist.gist_url(),
3424 'expires': gist.gist_expires,
3432 'expires': gist.gist_expires,
3425 'created_on': gist.created_on,
3433 'created_on': gist.created_on,
3426 'modified_at': gist.modified_at,
3434 'modified_at': gist.modified_at,
3427 'content': None,
3435 'content': None,
3428 'acl_level': gist.acl_level,
3436 'acl_level': gist.acl_level,
3429 }
3437 }
3430 return data
3438 return data
3431
3439
3432 def __json__(self):
3440 def __json__(self):
3433 data = dict(
3441 data = dict(
3434 )
3442 )
3435 data.update(self.get_api_data())
3443 data.update(self.get_api_data())
3436 return data
3444 return data
3437 # SCM functions
3445 # SCM functions
3438
3446
3439 def scm_instance(self, **kwargs):
3447 def scm_instance(self, **kwargs):
3440 full_repo_path = os.path.join(self.base_path(), self.gist_access_id)
3448 full_repo_path = os.path.join(self.base_path(), self.gist_access_id)
3441 return get_vcs_instance(
3449 return get_vcs_instance(
3442 repo_path=safe_str(full_repo_path), create=False)
3450 repo_path=safe_str(full_repo_path), create=False)
3443
3451
3444
3452
3445 class DbMigrateVersion(Base, BaseModel):
3453 class DbMigrateVersion(Base, BaseModel):
3446 __tablename__ = 'db_migrate_version'
3454 __tablename__ = 'db_migrate_version'
3447 __table_args__ = (
3455 __table_args__ = (
3448 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3456 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3449 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3457 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3450 )
3458 )
3451 repository_id = Column('repository_id', String(250), primary_key=True)
3459 repository_id = Column('repository_id', String(250), primary_key=True)
3452 repository_path = Column('repository_path', Text)
3460 repository_path = Column('repository_path', Text)
3453 version = Column('version', Integer)
3461 version = Column('version', Integer)
3454
3462
3455
3463
3456 class ExternalIdentity(Base, BaseModel):
3464 class ExternalIdentity(Base, BaseModel):
3457 __tablename__ = 'external_identities'
3465 __tablename__ = 'external_identities'
3458 __table_args__ = (
3466 __table_args__ = (
3459 Index('local_user_id_idx', 'local_user_id'),
3467 Index('local_user_id_idx', 'local_user_id'),
3460 Index('external_id_idx', 'external_id'),
3468 Index('external_id_idx', 'external_id'),
3461 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3469 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3462 'mysql_charset': 'utf8'})
3470 'mysql_charset': 'utf8'})
3463
3471
3464 external_id = Column('external_id', Unicode(255), default=u'',
3472 external_id = Column('external_id', Unicode(255), default=u'',
3465 primary_key=True)
3473 primary_key=True)
3466 external_username = Column('external_username', Unicode(1024), default=u'')
3474 external_username = Column('external_username', Unicode(1024), default=u'')
3467 local_user_id = Column('local_user_id', Integer(),
3475 local_user_id = Column('local_user_id', Integer(),
3468 ForeignKey('users.user_id'), primary_key=True)
3476 ForeignKey('users.user_id'), primary_key=True)
3469 provider_name = Column('provider_name', Unicode(255), default=u'',
3477 provider_name = Column('provider_name', Unicode(255), default=u'',
3470 primary_key=True)
3478 primary_key=True)
3471 access_token = Column('access_token', String(1024), default=u'')
3479 access_token = Column('access_token', String(1024), default=u'')
3472 alt_token = Column('alt_token', String(1024), default=u'')
3480 alt_token = Column('alt_token', String(1024), default=u'')
3473 token_secret = Column('token_secret', String(1024), default=u'')
3481 token_secret = Column('token_secret', String(1024), default=u'')
3474
3482
3475 @classmethod
3483 @classmethod
3476 def by_external_id_and_provider(cls, external_id, provider_name,
3484 def by_external_id_and_provider(cls, external_id, provider_name,
3477 local_user_id=None):
3485 local_user_id=None):
3478 """
3486 """
3479 Returns ExternalIdentity instance based on search params
3487 Returns ExternalIdentity instance based on search params
3480
3488
3481 :param external_id:
3489 :param external_id:
3482 :param provider_name:
3490 :param provider_name:
3483 :return: ExternalIdentity
3491 :return: ExternalIdentity
3484 """
3492 """
3485 query = cls.query()
3493 query = cls.query()
3486 query = query.filter(cls.external_id == external_id)
3494 query = query.filter(cls.external_id == external_id)
3487 query = query.filter(cls.provider_name == provider_name)
3495 query = query.filter(cls.provider_name == provider_name)
3488 if local_user_id:
3496 if local_user_id:
3489 query = query.filter(cls.local_user_id == local_user_id)
3497 query = query.filter(cls.local_user_id == local_user_id)
3490 return query.first()
3498 return query.first()
3491
3499
3492 @classmethod
3500 @classmethod
3493 def user_by_external_id_and_provider(cls, external_id, provider_name):
3501 def user_by_external_id_and_provider(cls, external_id, provider_name):
3494 """
3502 """
3495 Returns User instance based on search params
3503 Returns User instance based on search params
3496
3504
3497 :param external_id:
3505 :param external_id:
3498 :param provider_name:
3506 :param provider_name:
3499 :return: User
3507 :return: User
3500 """
3508 """
3501 query = User.query()
3509 query = User.query()
3502 query = query.filter(cls.external_id == external_id)
3510 query = query.filter(cls.external_id == external_id)
3503 query = query.filter(cls.provider_name == provider_name)
3511 query = query.filter(cls.provider_name == provider_name)
3504 query = query.filter(User.user_id == cls.local_user_id)
3512 query = query.filter(User.user_id == cls.local_user_id)
3505 return query.first()
3513 return query.first()
3506
3514
3507 @classmethod
3515 @classmethod
3508 def by_local_user_id(cls, local_user_id):
3516 def by_local_user_id(cls, local_user_id):
3509 """
3517 """
3510 Returns all tokens for user
3518 Returns all tokens for user
3511
3519
3512 :param local_user_id:
3520 :param local_user_id:
3513 :return: ExternalIdentity
3521 :return: ExternalIdentity
3514 """
3522 """
3515 query = cls.query()
3523 query = cls.query()
3516 query = query.filter(cls.local_user_id == local_user_id)
3524 query = query.filter(cls.local_user_id == local_user_id)
3517 return query
3525 return query
3518
3526
3519
3527
3520 class Integration(Base, BaseModel):
3528 class Integration(Base, BaseModel):
3521 __tablename__ = 'integrations'
3529 __tablename__ = 'integrations'
3522 __table_args__ = (
3530 __table_args__ = (
3523 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3531 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3524 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3532 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3525 )
3533 )
3526
3534
3527 integration_id = Column('integration_id', Integer(), primary_key=True)
3535 integration_id = Column('integration_id', Integer(), primary_key=True)
3528 integration_type = Column('integration_type', String(255))
3536 integration_type = Column('integration_type', String(255))
3529 enabled = Column('enabled', Boolean(), nullable=False)
3537 enabled = Column('enabled', Boolean(), nullable=False)
3530 name = Column('name', String(255), nullable=False)
3538 name = Column('name', String(255), nullable=False)
3531 child_repos_only = Column('child_repos_only', Boolean(), nullable=False,
3539 child_repos_only = Column('child_repos_only', Boolean(), nullable=False,
3532 default=False)
3540 default=False)
3533
3541
3534 settings = Column(
3542 settings = Column(
3535 'settings_json', MutationObj.as_mutable(
3543 'settings_json', MutationObj.as_mutable(
3536 JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
3544 JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
3537 repo_id = Column(
3545 repo_id = Column(
3538 'repo_id', Integer(), ForeignKey('repositories.repo_id'),
3546 'repo_id', Integer(), ForeignKey('repositories.repo_id'),
3539 nullable=True, unique=None, default=None)
3547 nullable=True, unique=None, default=None)
3540 repo = relationship('Repository', lazy='joined')
3548 repo = relationship('Repository', lazy='joined')
3541
3549
3542 repo_group_id = Column(
3550 repo_group_id = Column(
3543 'repo_group_id', Integer(), ForeignKey('groups.group_id'),
3551 'repo_group_id', Integer(), ForeignKey('groups.group_id'),
3544 nullable=True, unique=None, default=None)
3552 nullable=True, unique=None, default=None)
3545 repo_group = relationship('RepoGroup', lazy='joined')
3553 repo_group = relationship('RepoGroup', lazy='joined')
3546
3554
3547 @property
3555 @property
3548 def scope(self):
3556 def scope(self):
3549 if self.repo:
3557 if self.repo:
3550 return repr(self.repo)
3558 return repr(self.repo)
3551 if self.repo_group:
3559 if self.repo_group:
3552 if self.child_repos_only:
3560 if self.child_repos_only:
3553 return repr(self.repo_group) + ' (child repos only)'
3561 return repr(self.repo_group) + ' (child repos only)'
3554 else:
3562 else:
3555 return repr(self.repo_group) + ' (recursive)'
3563 return repr(self.repo_group) + ' (recursive)'
3556 if self.child_repos_only:
3564 if self.child_repos_only:
3557 return 'root_repos'
3565 return 'root_repos'
3558 return 'global'
3566 return 'global'
3559
3567
3560 def __repr__(self):
3568 def __repr__(self):
3561 return '<Integration(%r, %r)>' % (self.integration_type, self.scope)
3569 return '<Integration(%r, %r)>' % (self.integration_type, self.scope)
3562
3570
3563
3571
3564 class RepoReviewRuleUser(Base, BaseModel):
3572 class RepoReviewRuleUser(Base, BaseModel):
3565 __tablename__ = 'repo_review_rules_users'
3573 __tablename__ = 'repo_review_rules_users'
3566 __table_args__ = (
3574 __table_args__ = (
3567 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3575 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3568 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
3576 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
3569 )
3577 )
3570 repo_review_rule_user_id = Column(
3578 repo_review_rule_user_id = Column(
3571 'repo_review_rule_user_id', Integer(), primary_key=True)
3579 'repo_review_rule_user_id', Integer(), primary_key=True)
3572 repo_review_rule_id = Column("repo_review_rule_id",
3580 repo_review_rule_id = Column("repo_review_rule_id",
3573 Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
3581 Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
3574 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'),
3582 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'),
3575 nullable=False)
3583 nullable=False)
3576 user = relationship('User')
3584 user = relationship('User')
3577
3585
3578
3586
3579 class RepoReviewRuleUserGroup(Base, BaseModel):
3587 class RepoReviewRuleUserGroup(Base, BaseModel):
3580 __tablename__ = 'repo_review_rules_users_groups'
3588 __tablename__ = 'repo_review_rules_users_groups'
3581 __table_args__ = (
3589 __table_args__ = (
3582 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3590 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3583 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
3591 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
3584 )
3592 )
3585 repo_review_rule_users_group_id = Column(
3593 repo_review_rule_users_group_id = Column(
3586 'repo_review_rule_users_group_id', Integer(), primary_key=True)
3594 'repo_review_rule_users_group_id', Integer(), primary_key=True)
3587 repo_review_rule_id = Column("repo_review_rule_id",
3595 repo_review_rule_id = Column("repo_review_rule_id",
3588 Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
3596 Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
3589 users_group_id = Column("users_group_id", Integer(),
3597 users_group_id = Column("users_group_id", Integer(),
3590 ForeignKey('users_groups.users_group_id'), nullable=False)
3598 ForeignKey('users_groups.users_group_id'), nullable=False)
3591 users_group = relationship('UserGroup')
3599 users_group = relationship('UserGroup')
3592
3600
3593
3601
3594 class RepoReviewRule(Base, BaseModel):
3602 class RepoReviewRule(Base, BaseModel):
3595 __tablename__ = 'repo_review_rules'
3603 __tablename__ = 'repo_review_rules'
3596 __table_args__ = (
3604 __table_args__ = (
3597 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3605 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3598 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
3606 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
3599 )
3607 )
3600
3608
3601 repo_review_rule_id = Column(
3609 repo_review_rule_id = Column(
3602 'repo_review_rule_id', Integer(), primary_key=True)
3610 'repo_review_rule_id', Integer(), primary_key=True)
3603 repo_id = Column(
3611 repo_id = Column(
3604 "repo_id", Integer(), ForeignKey('repositories.repo_id'))
3612 "repo_id", Integer(), ForeignKey('repositories.repo_id'))
3605 repo = relationship('Repository', backref='review_rules')
3613 repo = relationship('Repository', backref='review_rules')
3606
3614
3607 _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),
3615 _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),
3608 default=u'*') # glob
3616 default=u'*') # glob
3609 _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),
3617 _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),
3610 default=u'*') # glob
3618 default=u'*') # glob
3611
3619
3612 use_authors_for_review = Column("use_authors_for_review", Boolean(),
3620 use_authors_for_review = Column("use_authors_for_review", Boolean(),
3613 nullable=False, default=False)
3621 nullable=False, default=False)
3614 rule_users = relationship('RepoReviewRuleUser')
3622 rule_users = relationship('RepoReviewRuleUser')
3615 rule_user_groups = relationship('RepoReviewRuleUserGroup')
3623 rule_user_groups = relationship('RepoReviewRuleUserGroup')
3616
3624
3617 @hybrid_property
3625 @hybrid_property
3618 def branch_pattern(self):
3626 def branch_pattern(self):
3619 return self._branch_pattern or '*'
3627 return self._branch_pattern or '*'
3620
3628
3621 def _validate_glob(self, value):
3629 def _validate_glob(self, value):
3622 re.compile('^' + glob2re(value) + '$')
3630 re.compile('^' + glob2re(value) + '$')
3623
3631
3624 @branch_pattern.setter
3632 @branch_pattern.setter
3625 def branch_pattern(self, value):
3633 def branch_pattern(self, value):
3626 self._validate_glob(value)
3634 self._validate_glob(value)
3627 self._branch_pattern = value or '*'
3635 self._branch_pattern = value or '*'
3628
3636
3629 @hybrid_property
3637 @hybrid_property
3630 def file_pattern(self):
3638 def file_pattern(self):
3631 return self._file_pattern or '*'
3639 return self._file_pattern or '*'
3632
3640
3633 @file_pattern.setter
3641 @file_pattern.setter
3634 def file_pattern(self, value):
3642 def file_pattern(self, value):
3635 self._validate_glob(value)
3643 self._validate_glob(value)
3636 self._file_pattern = value or '*'
3644 self._file_pattern = value or '*'
3637
3645
3638 def matches(self, branch, files_changed):
3646 def matches(self, branch, files_changed):
3639 """
3647 """
3640 Check if this review rule matches a branch/files in a pull request
3648 Check if this review rule matches a branch/files in a pull request
3641
3649
3642 :param branch: branch name for the commit
3650 :param branch: branch name for the commit
3643 :param files_changed: list of file paths changed in the pull request
3651 :param files_changed: list of file paths changed in the pull request
3644 """
3652 """
3645
3653
3646 branch = branch or ''
3654 branch = branch or ''
3647 files_changed = files_changed or []
3655 files_changed = files_changed or []
3648
3656
3649 branch_matches = True
3657 branch_matches = True
3650 if branch:
3658 if branch:
3651 branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$')
3659 branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$')
3652 branch_matches = bool(branch_regex.search(branch))
3660 branch_matches = bool(branch_regex.search(branch))
3653
3661
3654 files_matches = True
3662 files_matches = True
3655 if self.file_pattern != '*':
3663 if self.file_pattern != '*':
3656 files_matches = False
3664 files_matches = False
3657 file_regex = re.compile(glob2re(self.file_pattern))
3665 file_regex = re.compile(glob2re(self.file_pattern))
3658 for filename in files_changed:
3666 for filename in files_changed:
3659 if file_regex.search(filename):
3667 if file_regex.search(filename):
3660 files_matches = True
3668 files_matches = True
3661 break
3669 break
3662
3670
3663 return branch_matches and files_matches
3671 return branch_matches and files_matches
3664
3672
3665 @property
3673 @property
3666 def review_users(self):
3674 def review_users(self):
3667 """ Returns the users which this rule applies to """
3675 """ Returns the users which this rule applies to """
3668
3676
3669 users = set()
3677 users = set()
3670 users |= set([
3678 users |= set([
3671 rule_user.user for rule_user in self.rule_users
3679 rule_user.user for rule_user in self.rule_users
3672 if rule_user.user.active])
3680 if rule_user.user.active])
3673 users |= set(
3681 users |= set(
3674 member.user
3682 member.user
3675 for rule_user_group in self.rule_user_groups
3683 for rule_user_group in self.rule_user_groups
3676 for member in rule_user_group.users_group.members
3684 for member in rule_user_group.users_group.members
3677 if member.user.active
3685 if member.user.active
3678 )
3686 )
3679 return users
3687 return users
3680
3688
3681 def __repr__(self):
3689 def __repr__(self):
3682 return '<RepoReviewerRule(id=%r, repo=%r)>' % (
3690 return '<RepoReviewerRule(id=%r, repo=%r)>' % (
3683 self.repo_review_rule_id, self.repo)
3691 self.repo_review_rule_id, self.repo)
General Comments 0
You need to be logged in to leave comments. Login now