##// END OF EJS Templates
u » pc » rhodecode-enterprise-ce-fork-pc
RSS

Fork of rhodecode-enterprise-ce

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