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