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