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