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