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