##// END OF EJS Templates
repo-settings: converted repo settings to pyramid...
marcink -
r1716:24a2983a default
parent child Browse files
Show More
@@ -0,0 +1,178 b''
1 # -*- coding: utf-8 -*-
2
3 # Copyright (C) 2011-2017 RhodeCode GmbH
4 #
5 # This program is free software: you can redistribute it and/or modify
6 # it under the terms of the GNU Affero General Public License, version 3
7 # (only), as published by the Free Software Foundation.
8 #
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 # GNU General Public License for more details.
13 #
14 # You should have received a copy of the GNU Affero General Public License
15 # along with this program. If not, see <http://www.gnu.org/licenses/>.
16 #
17 # This program is dual-licensed. If you wish to learn more about the
18 # RhodeCode Enterprise Edition, including its added features, Support services,
19 # and proprietary license terms, please see https://rhodecode.com/licenses/
20
21 import logging
22
23 import deform
24 from pyramid.httpexceptions import HTTPFound
25 from pyramid.view import view_config
26
27 from rhodecode.apps._base import RepoAppView
28 from rhodecode.forms import RcForm
29 from rhodecode.lib import helpers as h
30 from rhodecode.lib import audit_logger
31 from rhodecode.lib.auth import (
32 LoginRequired, HasRepoPermissionAnyDecorator,
33 HasRepoPermissionAllDecorator, CSRFRequired)
34 from rhodecode.model.db import RepositoryField, RepoGroup
35 from rhodecode.model.meta import Session
36 from rhodecode.model.repo import RepoModel
37 from rhodecode.model.scm import RepoGroupList, ScmModel
38 from rhodecode.model.validation_schema.schemas import repo_schema
39
40 log = logging.getLogger(__name__)
41
42
43 class RepoSettingsView(RepoAppView):
44
45 def load_default_context(self):
46 c = self._get_local_tmpl_context()
47
48 # TODO(marcink): remove repo_info and use c.rhodecode_db_repo instead
49 c.repo_info = self.db_repo
50
51 acl_groups = RepoGroupList(
52 RepoGroup.query().all(),
53 perm_set=['group.write', 'group.admin'])
54 c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)
55 c.repo_groups_choices = map(lambda k: k[0], c.repo_groups)
56
57 # in case someone no longer have a group.write access to a repository
58 # pre fill the list with this entry, we don't care if this is the same
59 # but it will allow saving repo data properly.
60 repo_group = self.db_repo.group
61 if repo_group and repo_group.group_id not in c.repo_groups_choices:
62 c.repo_groups_choices.append(repo_group.group_id)
63 c.repo_groups.append(RepoGroup._generate_choice(repo_group))
64
65 if c.repository_requirements_missing or self.rhodecode_vcs_repo is None:
66 # we might be in missing requirement state, so we load things
67 # without touching scm_instance()
68 c.landing_revs_choices, c.landing_revs = \
69 ScmModel().get_repo_landing_revs()
70 else:
71 c.landing_revs_choices, c.landing_revs = \
72 ScmModel().get_repo_landing_revs(self.db_repo)
73
74 c.personal_repo_group = c.auth_user.personal_repo_group
75 c.repo_fields = RepositoryField.query()\
76 .filter(RepositoryField.repository == self.db_repo).all()
77
78 self._register_global_c(c)
79 return c
80
81 def _get_schema(self, c, old_values=None):
82 return repo_schema.RepoSettingsSchema().bind(
83 repo_type_options=[self.db_repo.repo_type],
84 repo_ref_options=c.landing_revs_choices,
85 repo_ref_items=c.landing_revs,
86 repo_repo_group_options=c.repo_groups_choices,
87 repo_repo_group_items=c.repo_groups,
88 # user caller
89 user=self._rhodecode_user,
90 old_values=old_values
91 )
92
93 @LoginRequired()
94 @HasRepoPermissionAnyDecorator('repository.admin')
95 @view_config(
96 route_name='edit_repo', request_method='GET',
97 renderer='rhodecode:templates/admin/repos/repo_edit.mako')
98 def edit_settings(self):
99 c = self.load_default_context()
100 c.active = 'settings'
101
102 defaults = RepoModel()._get_defaults(self.db_repo_name)
103 defaults['repo_owner'] = defaults['user']
104 defaults['repo_landing_commit_ref'] = defaults['repo_landing_rev']
105
106 schema = self._get_schema(c)
107 c.form = RcForm(schema, appstruct=defaults)
108 return self._get_template_context(c)
109
110 @LoginRequired()
111 @HasRepoPermissionAllDecorator('repository.admin')
112 @CSRFRequired()
113 @view_config(
114 route_name='edit_repo', request_method='POST',
115 renderer='rhodecode:templates/admin/repos/repo_edit.mako')
116 def edit_settings_update(self):
117 _ = self.request.translate
118 c = self.load_default_context()
119 c.active = 'settings'
120 old_repo_name = self.db_repo_name
121
122 old_values = self.db_repo.get_api_data()
123 schema = self._get_schema(c, old_values=old_values)
124
125 c.form = RcForm(schema)
126 pstruct = self.request.POST.items()
127 pstruct.append(('repo_type', self.db_repo.repo_type))
128 try:
129 schema_data = c.form.validate(pstruct)
130 except deform.ValidationFailure as err_form:
131 return self._get_template_context(c)
132
133 # data is now VALID, proceed with updates
134 # save validated data back into the updates dict
135 validated_updates = dict(
136 repo_name=schema_data['repo_group']['repo_name_without_group'],
137 repo_group=schema_data['repo_group']['repo_group_id'],
138
139 user=schema_data['repo_owner'],
140 repo_description=schema_data['repo_description'],
141 repo_private=schema_data['repo_private'],
142 clone_uri=schema_data['repo_clone_uri'],
143 repo_landing_rev=schema_data['repo_landing_commit_ref'],
144 repo_enable_statistics=schema_data['repo_enable_statistics'],
145 repo_enable_locking=schema_data['repo_enable_locking'],
146 repo_enable_downloads=schema_data['repo_enable_downloads'],
147 )
148 # detect if CLONE URI changed, if we get OLD means we keep old values
149 if schema_data['repo_clone_uri_change'] == 'OLD':
150 validated_updates['clone_uri'] = self.db_repo.clone_uri
151
152 # use the new full name for redirect
153 new_repo_name = schema_data['repo_group']['repo_name_with_group']
154
155 # save extra fields into our validated data
156 for key, value in pstruct:
157 if key.startswith(RepositoryField.PREFIX):
158 validated_updates[key] = value
159
160 try:
161 RepoModel().update(self.db_repo, **validated_updates)
162 ScmModel().mark_for_invalidation(new_repo_name)
163
164 audit_logger.store(
165 'repo.edit', action_data={'old_data': old_values},
166 user=self._rhodecode_user, repo=self.db_repo)
167
168 Session().commit()
169
170 h.flash(_('Repository {} updated successfully').format(
171 old_repo_name), category='success')
172 except Exception:
173 log.exception("Exception during update of repository")
174 h.flash(_('Error occurred during update of repository {}').format(
175 old_repo_name), category='error')
176
177 raise HTTPFound(
178 self.request.route_path('edit_repo', repo_name=new_repo_name))
@@ -1,46 +1,50 b''
1 1 # -*- coding: utf-8 -*-
2 2
3 3 # Copyright (C) 2016-2017 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 def includeme(config):
23 23
24 # Settings
25 config.add_route(
26 name='edit_repo',
27 pattern='/{repo_name:.*?[^/]}/settings', repo_route=True)
28
24 29 config.add_route(
25 30 name='repo_maintenance',
26 31 pattern='/{repo_name:.*?[^/]}/maintenance', repo_route=True)
27 32
28 33 config.add_route(
29 34 name='repo_maintenance_execute',
30 35 pattern='/{repo_name:.*?[^/]}/maintenance/execute', repo_route=True)
31 36
32
33 37 # Strip
34 38 config.add_route(
35 39 name='strip',
36 40 pattern='/{repo_name:.*?[^/]}/strip', repo_route=True)
37 41
38 42 config.add_route(
39 43 name='strip_check',
40 44 pattern='/{repo_name:.*?[^/]}/strip_check', repo_route=True)
41 45
42 46 config.add_route(
43 47 name='strip_execute',
44 48 pattern='/{repo_name:.*?[^/]}/strip_execute', repo_route=True)
45 49 # Scan module for configuration decorators.
46 50 config.scan()
@@ -1,1116 +1,1107 b''
1 1 # -*- coding: utf-8 -*-
2 2
3 3 # Copyright (C) 2010-2017 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 Routes configuration
23 23
24 24 The more specific and detailed routes should be defined first so they
25 25 may take precedent over the more generic routes. For more information
26 26 refer to the routes manual at http://routes.groovie.org/docs/
27 27
28 28 IMPORTANT: if you change any routing here, make sure to take a look at lib/base.py
29 29 and _route_name variable which uses some of stored naming here to do redirects.
30 30 """
31 31 import os
32 32 import re
33 33 from routes import Mapper
34 34
35 35 # prefix for non repository related links needs to be prefixed with `/`
36 36 ADMIN_PREFIX = '/_admin'
37 37 STATIC_FILE_PREFIX = '/_static'
38 38
39 39 # Default requirements for URL parts
40 40 URL_NAME_REQUIREMENTS = {
41 41 # group name can have a slash in them, but they must not end with a slash
42 42 'group_name': r'.*?[^/]',
43 43 'repo_group_name': r'.*?[^/]',
44 44 # repo names can have a slash in them, but they must not end with a slash
45 45 'repo_name': r'.*?[^/]',
46 46 # file path eats up everything at the end
47 47 'f_path': r'.*',
48 48 # reference types
49 49 'source_ref_type': '(branch|book|tag|rev|\%\(source_ref_type\)s)',
50 50 'target_ref_type': '(branch|book|tag|rev|\%\(target_ref_type\)s)',
51 51 }
52 52
53 53
54 54 def add_route_requirements(route_path, requirements):
55 55 """
56 56 Adds regex requirements to pyramid routes using a mapping dict
57 57
58 58 >>> add_route_requirements('/{action}/{id}', {'id': r'\d+'})
59 59 '/{action}/{id:\d+}'
60 60
61 61 """
62 62 for key, regex in requirements.items():
63 63 route_path = route_path.replace('{%s}' % key, '{%s:%s}' % (key, regex))
64 64 return route_path
65 65
66 66
67 67 class JSRoutesMapper(Mapper):
68 68 """
69 69 Wrapper for routes.Mapper to make pyroutes compatible url definitions
70 70 """
71 71 _named_route_regex = re.compile(r'^[a-z-_0-9A-Z]+$')
72 72 _argument_prog = re.compile('\{(.*?)\}|:\((.*)\)')
73 73 def __init__(self, *args, **kw):
74 74 super(JSRoutesMapper, self).__init__(*args, **kw)
75 75 self._jsroutes = []
76 76
77 77 def connect(self, *args, **kw):
78 78 """
79 79 Wrapper for connect to take an extra argument jsroute=True
80 80
81 81 :param jsroute: boolean, if True will add the route to the pyroutes list
82 82 """
83 83 if kw.pop('jsroute', False):
84 84 if not self._named_route_regex.match(args[0]):
85 85 raise Exception('only named routes can be added to pyroutes')
86 86 self._jsroutes.append(args[0])
87 87
88 88 super(JSRoutesMapper, self).connect(*args, **kw)
89 89
90 90 def _extract_route_information(self, route):
91 91 """
92 92 Convert a route into tuple(name, path, args), eg:
93 93 ('show_user', '/profile/%(username)s', ['username'])
94 94 """
95 95 routepath = route.routepath
96 96 def replace(matchobj):
97 97 if matchobj.group(1):
98 98 return "%%(%s)s" % matchobj.group(1).split(':')[0]
99 99 else:
100 100 return "%%(%s)s" % matchobj.group(2)
101 101
102 102 routepath = self._argument_prog.sub(replace, routepath)
103 103 return (
104 104 route.name,
105 105 routepath,
106 106 [(arg[0].split(':')[0] if arg[0] != '' else arg[1])
107 107 for arg in self._argument_prog.findall(route.routepath)]
108 108 )
109 109
110 110 def jsroutes(self):
111 111 """
112 112 Return a list of pyroutes.js compatible routes
113 113 """
114 114 for route_name in self._jsroutes:
115 115 yield self._extract_route_information(self._routenames[route_name])
116 116
117 117
118 118 def make_map(config):
119 119 """Create, configure and return the routes Mapper"""
120 120 rmap = JSRoutesMapper(directory=config['pylons.paths']['controllers'],
121 121 always_scan=config['debug'])
122 122 rmap.minimization = False
123 123 rmap.explicit = False
124 124
125 125 from rhodecode.lib.utils2 import str2bool
126 126 from rhodecode.model import repo, repo_group
127 127
128 128 def check_repo(environ, match_dict):
129 129 """
130 130 check for valid repository for proper 404 handling
131 131
132 132 :param environ:
133 133 :param match_dict:
134 134 """
135 135 repo_name = match_dict.get('repo_name')
136 136
137 137 if match_dict.get('f_path'):
138 138 # fix for multiple initial slashes that causes errors
139 139 match_dict['f_path'] = match_dict['f_path'].lstrip('/')
140 140 repo_model = repo.RepoModel()
141 141 by_name_match = repo_model.get_by_repo_name(repo_name)
142 142 # if we match quickly from database, short circuit the operation,
143 143 # and validate repo based on the type.
144 144 if by_name_match:
145 145 return True
146 146
147 147 by_id_match = repo_model.get_repo_by_id(repo_name)
148 148 if by_id_match:
149 149 repo_name = by_id_match.repo_name
150 150 match_dict['repo_name'] = repo_name
151 151 return True
152 152
153 153 return False
154 154
155 155 def check_group(environ, match_dict):
156 156 """
157 157 check for valid repository group path for proper 404 handling
158 158
159 159 :param environ:
160 160 :param match_dict:
161 161 """
162 162 repo_group_name = match_dict.get('group_name')
163 163 repo_group_model = repo_group.RepoGroupModel()
164 164 by_name_match = repo_group_model.get_by_group_name(repo_group_name)
165 165 if by_name_match:
166 166 return True
167 167
168 168 return False
169 169
170 170 def check_user_group(environ, match_dict):
171 171 """
172 172 check for valid user group for proper 404 handling
173 173
174 174 :param environ:
175 175 :param match_dict:
176 176 """
177 177 return True
178 178
179 179 def check_int(environ, match_dict):
180 180 return match_dict.get('id').isdigit()
181 181
182 182
183 183 #==========================================================================
184 184 # CUSTOM ROUTES HERE
185 185 #==========================================================================
186 186
187 187 # MAIN PAGE
188 188 rmap.connect('home', '/', controller='home', action='index', jsroute=True)
189 189
190 190 # ping and pylons error test
191 191 rmap.connect('ping', '%s/ping' % (ADMIN_PREFIX,), controller='home', action='ping')
192 192 rmap.connect('error_test', '%s/error_test' % (ADMIN_PREFIX,), controller='home', action='error_test')
193 193
194 194 # ADMIN REPOSITORY ROUTES
195 195 with rmap.submapper(path_prefix=ADMIN_PREFIX,
196 196 controller='admin/repos') as m:
197 197 m.connect('repos', '/repos',
198 198 action='create', conditions={'method': ['POST']})
199 199 m.connect('repos', '/repos',
200 200 action='index', conditions={'method': ['GET']})
201 201 m.connect('new_repo', '/create_repository', jsroute=True,
202 202 action='create_repository', conditions={'method': ['GET']})
203 m.connect('/repos/{repo_name}',
204 action='update', conditions={'method': ['PUT'],
205 'function': check_repo},
206 requirements=URL_NAME_REQUIREMENTS)
207 203 m.connect('delete_repo', '/repos/{repo_name}',
208 204 action='delete', conditions={'method': ['DELETE']},
209 205 requirements=URL_NAME_REQUIREMENTS)
210 206 m.connect('repo', '/repos/{repo_name}',
211 207 action='show', conditions={'method': ['GET'],
212 208 'function': check_repo},
213 209 requirements=URL_NAME_REQUIREMENTS)
214 210
215 211 # ADMIN REPOSITORY GROUPS ROUTES
216 212 with rmap.submapper(path_prefix=ADMIN_PREFIX,
217 213 controller='admin/repo_groups') as m:
218 214 m.connect('repo_groups', '/repo_groups',
219 215 action='create', conditions={'method': ['POST']})
220 216 m.connect('repo_groups', '/repo_groups',
221 217 action='index', conditions={'method': ['GET']})
222 218 m.connect('new_repo_group', '/repo_groups/new',
223 219 action='new', conditions={'method': ['GET']})
224 220 m.connect('update_repo_group', '/repo_groups/{group_name}',
225 221 action='update', conditions={'method': ['PUT'],
226 222 'function': check_group},
227 223 requirements=URL_NAME_REQUIREMENTS)
228 224
229 225 # EXTRAS REPO GROUP ROUTES
230 226 m.connect('edit_repo_group', '/repo_groups/{group_name}/edit',
231 227 action='edit',
232 228 conditions={'method': ['GET'], 'function': check_group},
233 229 requirements=URL_NAME_REQUIREMENTS)
234 230 m.connect('edit_repo_group', '/repo_groups/{group_name}/edit',
235 231 action='edit',
236 232 conditions={'method': ['PUT'], 'function': check_group},
237 233 requirements=URL_NAME_REQUIREMENTS)
238 234
239 235 m.connect('edit_repo_group_advanced', '/repo_groups/{group_name}/edit/advanced',
240 236 action='edit_repo_group_advanced',
241 237 conditions={'method': ['GET'], 'function': check_group},
242 238 requirements=URL_NAME_REQUIREMENTS)
243 239 m.connect('edit_repo_group_advanced', '/repo_groups/{group_name}/edit/advanced',
244 240 action='edit_repo_group_advanced',
245 241 conditions={'method': ['PUT'], 'function': check_group},
246 242 requirements=URL_NAME_REQUIREMENTS)
247 243
248 244 m.connect('edit_repo_group_perms', '/repo_groups/{group_name}/edit/permissions',
249 245 action='edit_repo_group_perms',
250 246 conditions={'method': ['GET'], 'function': check_group},
251 247 requirements=URL_NAME_REQUIREMENTS)
252 248 m.connect('edit_repo_group_perms', '/repo_groups/{group_name}/edit/permissions',
253 249 action='update_perms',
254 250 conditions={'method': ['PUT'], 'function': check_group},
255 251 requirements=URL_NAME_REQUIREMENTS)
256 252
257 253 m.connect('delete_repo_group', '/repo_groups/{group_name}',
258 254 action='delete', conditions={'method': ['DELETE'],
259 255 'function': check_group},
260 256 requirements=URL_NAME_REQUIREMENTS)
261 257
262 258 # ADMIN USER ROUTES
263 259 with rmap.submapper(path_prefix=ADMIN_PREFIX,
264 260 controller='admin/users') as m:
265 261 m.connect('users', '/users',
266 262 action='create', conditions={'method': ['POST']})
267 263 m.connect('new_user', '/users/new',
268 264 action='new', conditions={'method': ['GET']})
269 265 m.connect('update_user', '/users/{user_id}',
270 266 action='update', conditions={'method': ['PUT']})
271 267 m.connect('delete_user', '/users/{user_id}',
272 268 action='delete', conditions={'method': ['DELETE']})
273 269 m.connect('edit_user', '/users/{user_id}/edit',
274 270 action='edit', conditions={'method': ['GET']}, jsroute=True)
275 271 m.connect('user', '/users/{user_id}',
276 272 action='show', conditions={'method': ['GET']})
277 273 m.connect('force_password_reset_user', '/users/{user_id}/password_reset',
278 274 action='reset_password', conditions={'method': ['POST']})
279 275 m.connect('create_personal_repo_group', '/users/{user_id}/create_repo_group',
280 276 action='create_personal_repo_group', conditions={'method': ['POST']})
281 277
282 278 # EXTRAS USER ROUTES
283 279 m.connect('edit_user_advanced', '/users/{user_id}/edit/advanced',
284 280 action='edit_advanced', conditions={'method': ['GET']})
285 281 m.connect('edit_user_advanced', '/users/{user_id}/edit/advanced',
286 282 action='update_advanced', conditions={'method': ['PUT']})
287 283
288 284 m.connect('edit_user_global_perms', '/users/{user_id}/edit/global_permissions',
289 285 action='edit_global_perms', conditions={'method': ['GET']})
290 286 m.connect('edit_user_global_perms', '/users/{user_id}/edit/global_permissions',
291 287 action='update_global_perms', conditions={'method': ['PUT']})
292 288
293 289 m.connect('edit_user_perms_summary', '/users/{user_id}/edit/permissions_summary',
294 290 action='edit_perms_summary', conditions={'method': ['GET']})
295 291
296 292 m.connect('edit_user_emails', '/users/{user_id}/edit/emails',
297 293 action='edit_emails', conditions={'method': ['GET']})
298 294 m.connect('edit_user_emails', '/users/{user_id}/edit/emails',
299 295 action='add_email', conditions={'method': ['PUT']})
300 296 m.connect('edit_user_emails', '/users/{user_id}/edit/emails',
301 297 action='delete_email', conditions={'method': ['DELETE']})
302 298
303 299 m.connect('edit_user_ips', '/users/{user_id}/edit/ips',
304 300 action='edit_ips', conditions={'method': ['GET']})
305 301 m.connect('edit_user_ips', '/users/{user_id}/edit/ips',
306 302 action='add_ip', conditions={'method': ['PUT']})
307 303 m.connect('edit_user_ips', '/users/{user_id}/edit/ips',
308 304 action='delete_ip', conditions={'method': ['DELETE']})
309 305
310 306 # ADMIN USER GROUPS REST ROUTES
311 307 with rmap.submapper(path_prefix=ADMIN_PREFIX,
312 308 controller='admin/user_groups') as m:
313 309 m.connect('users_groups', '/user_groups',
314 310 action='create', conditions={'method': ['POST']})
315 311 m.connect('users_groups', '/user_groups',
316 312 action='index', conditions={'method': ['GET']})
317 313 m.connect('new_users_group', '/user_groups/new',
318 314 action='new', conditions={'method': ['GET']})
319 315 m.connect('update_users_group', '/user_groups/{user_group_id}',
320 316 action='update', conditions={'method': ['PUT']})
321 317 m.connect('delete_users_group', '/user_groups/{user_group_id}',
322 318 action='delete', conditions={'method': ['DELETE']})
323 319 m.connect('edit_users_group', '/user_groups/{user_group_id}/edit',
324 320 action='edit', conditions={'method': ['GET']},
325 321 function=check_user_group)
326 322
327 323 # EXTRAS USER GROUP ROUTES
328 324 m.connect('edit_user_group_global_perms',
329 325 '/user_groups/{user_group_id}/edit/global_permissions',
330 326 action='edit_global_perms', conditions={'method': ['GET']})
331 327 m.connect('edit_user_group_global_perms',
332 328 '/user_groups/{user_group_id}/edit/global_permissions',
333 329 action='update_global_perms', conditions={'method': ['PUT']})
334 330 m.connect('edit_user_group_perms_summary',
335 331 '/user_groups/{user_group_id}/edit/permissions_summary',
336 332 action='edit_perms_summary', conditions={'method': ['GET']})
337 333
338 334 m.connect('edit_user_group_perms',
339 335 '/user_groups/{user_group_id}/edit/permissions',
340 336 action='edit_perms', conditions={'method': ['GET']})
341 337 m.connect('edit_user_group_perms',
342 338 '/user_groups/{user_group_id}/edit/permissions',
343 339 action='update_perms', conditions={'method': ['PUT']})
344 340
345 341 m.connect('edit_user_group_advanced',
346 342 '/user_groups/{user_group_id}/edit/advanced',
347 343 action='edit_advanced', conditions={'method': ['GET']})
348 344
349 345 m.connect('edit_user_group_advanced_sync',
350 346 '/user_groups/{user_group_id}/edit/advanced/sync',
351 347 action='edit_advanced_set_synchronization', conditions={'method': ['POST']})
352 348
353 349 m.connect('edit_user_group_members',
354 350 '/user_groups/{user_group_id}/edit/members', jsroute=True,
355 351 action='user_group_members', conditions={'method': ['GET']})
356 352
357 353 # ADMIN PERMISSIONS ROUTES
358 354 with rmap.submapper(path_prefix=ADMIN_PREFIX,
359 355 controller='admin/permissions') as m:
360 356 m.connect('admin_permissions_application', '/permissions/application',
361 357 action='permission_application_update', conditions={'method': ['POST']})
362 358 m.connect('admin_permissions_application', '/permissions/application',
363 359 action='permission_application', conditions={'method': ['GET']})
364 360
365 361 m.connect('admin_permissions_global', '/permissions/global',
366 362 action='permission_global_update', conditions={'method': ['POST']})
367 363 m.connect('admin_permissions_global', '/permissions/global',
368 364 action='permission_global', conditions={'method': ['GET']})
369 365
370 366 m.connect('admin_permissions_object', '/permissions/object',
371 367 action='permission_objects_update', conditions={'method': ['POST']})
372 368 m.connect('admin_permissions_object', '/permissions/object',
373 369 action='permission_objects', conditions={'method': ['GET']})
374 370
375 371 m.connect('admin_permissions_ips', '/permissions/ips',
376 372 action='permission_ips', conditions={'method': ['POST']})
377 373 m.connect('admin_permissions_ips', '/permissions/ips',
378 374 action='permission_ips', conditions={'method': ['GET']})
379 375
380 376 m.connect('admin_permissions_overview', '/permissions/overview',
381 377 action='permission_perms', conditions={'method': ['GET']})
382 378
383 379 # ADMIN DEFAULTS REST ROUTES
384 380 with rmap.submapper(path_prefix=ADMIN_PREFIX,
385 381 controller='admin/defaults') as m:
386 382 m.connect('admin_defaults_repositories', '/defaults/repositories',
387 383 action='update_repository_defaults', conditions={'method': ['POST']})
388 384 m.connect('admin_defaults_repositories', '/defaults/repositories',
389 385 action='index', conditions={'method': ['GET']})
390 386
391 387 # ADMIN DEBUG STYLE ROUTES
392 388 if str2bool(config.get('debug_style')):
393 389 with rmap.submapper(path_prefix=ADMIN_PREFIX + '/debug_style',
394 390 controller='debug_style') as m:
395 391 m.connect('debug_style_home', '',
396 392 action='index', conditions={'method': ['GET']})
397 393 m.connect('debug_style_template', '/t/{t_path}',
398 394 action='template', conditions={'method': ['GET']})
399 395
400 396 # ADMIN SETTINGS ROUTES
401 397 with rmap.submapper(path_prefix=ADMIN_PREFIX,
402 398 controller='admin/settings') as m:
403 399
404 400 # default
405 401 m.connect('admin_settings', '/settings',
406 402 action='settings_global_update',
407 403 conditions={'method': ['POST']})
408 404 m.connect('admin_settings', '/settings',
409 405 action='settings_global', conditions={'method': ['GET']})
410 406
411 407 m.connect('admin_settings_vcs', '/settings/vcs',
412 408 action='settings_vcs_update',
413 409 conditions={'method': ['POST']})
414 410 m.connect('admin_settings_vcs', '/settings/vcs',
415 411 action='settings_vcs',
416 412 conditions={'method': ['GET']})
417 413 m.connect('admin_settings_vcs', '/settings/vcs',
418 414 action='delete_svn_pattern',
419 415 conditions={'method': ['DELETE']})
420 416
421 417 m.connect('admin_settings_mapping', '/settings/mapping',
422 418 action='settings_mapping_update',
423 419 conditions={'method': ['POST']})
424 420 m.connect('admin_settings_mapping', '/settings/mapping',
425 421 action='settings_mapping', conditions={'method': ['GET']})
426 422
427 423 m.connect('admin_settings_global', '/settings/global',
428 424 action='settings_global_update',
429 425 conditions={'method': ['POST']})
430 426 m.connect('admin_settings_global', '/settings/global',
431 427 action='settings_global', conditions={'method': ['GET']})
432 428
433 429 m.connect('admin_settings_visual', '/settings/visual',
434 430 action='settings_visual_update',
435 431 conditions={'method': ['POST']})
436 432 m.connect('admin_settings_visual', '/settings/visual',
437 433 action='settings_visual', conditions={'method': ['GET']})
438 434
439 435 m.connect('admin_settings_issuetracker',
440 436 '/settings/issue-tracker', action='settings_issuetracker',
441 437 conditions={'method': ['GET']})
442 438 m.connect('admin_settings_issuetracker_save',
443 439 '/settings/issue-tracker/save',
444 440 action='settings_issuetracker_save',
445 441 conditions={'method': ['POST']})
446 442 m.connect('admin_issuetracker_test', '/settings/issue-tracker/test',
447 443 action='settings_issuetracker_test',
448 444 conditions={'method': ['POST']})
449 445 m.connect('admin_issuetracker_delete',
450 446 '/settings/issue-tracker/delete',
451 447 action='settings_issuetracker_delete',
452 448 conditions={'method': ['DELETE']})
453 449
454 450 m.connect('admin_settings_email', '/settings/email',
455 451 action='settings_email_update',
456 452 conditions={'method': ['POST']})
457 453 m.connect('admin_settings_email', '/settings/email',
458 454 action='settings_email', conditions={'method': ['GET']})
459 455
460 456 m.connect('admin_settings_hooks', '/settings/hooks',
461 457 action='settings_hooks_update',
462 458 conditions={'method': ['POST', 'DELETE']})
463 459 m.connect('admin_settings_hooks', '/settings/hooks',
464 460 action='settings_hooks', conditions={'method': ['GET']})
465 461
466 462 m.connect('admin_settings_search', '/settings/search',
467 463 action='settings_search', conditions={'method': ['GET']})
468 464
469 465 m.connect('admin_settings_supervisor', '/settings/supervisor',
470 466 action='settings_supervisor', conditions={'method': ['GET']})
471 467 m.connect('admin_settings_supervisor_log', '/settings/supervisor/{procid}/log',
472 468 action='settings_supervisor_log', conditions={'method': ['GET']})
473 469
474 470 m.connect('admin_settings_labs', '/settings/labs',
475 471 action='settings_labs_update',
476 472 conditions={'method': ['POST']})
477 473 m.connect('admin_settings_labs', '/settings/labs',
478 474 action='settings_labs', conditions={'method': ['GET']})
479 475
480 476 # ADMIN MY ACCOUNT
481 477 with rmap.submapper(path_prefix=ADMIN_PREFIX,
482 478 controller='admin/my_account') as m:
483 479
484 480 m.connect('my_account_edit', '/my_account/edit',
485 481 action='my_account_edit', conditions={'method': ['GET']})
486 482 m.connect('my_account', '/my_account/update',
487 483 action='my_account_update', conditions={'method': ['POST']})
488 484
489 485 # NOTE(marcink): this needs to be kept for password force flag to be
490 486 # handler, remove after migration to pyramid
491 487 m.connect('my_account_password', '/my_account/password',
492 488 action='my_account_password', conditions={'method': ['GET']})
493 489
494 490 m.connect('my_account_repos', '/my_account/repos',
495 491 action='my_account_repos', conditions={'method': ['GET']})
496 492
497 493 m.connect('my_account_watched', '/my_account/watched',
498 494 action='my_account_watched', conditions={'method': ['GET']})
499 495
500 496 m.connect('my_account_pullrequests', '/my_account/pull_requests',
501 497 action='my_account_pullrequests', conditions={'method': ['GET']})
502 498
503 499 m.connect('my_account_perms', '/my_account/perms',
504 500 action='my_account_perms', conditions={'method': ['GET']})
505 501
506 502 m.connect('my_account_emails', '/my_account/emails',
507 503 action='my_account_emails', conditions={'method': ['GET']})
508 504 m.connect('my_account_emails', '/my_account/emails',
509 505 action='my_account_emails_add', conditions={'method': ['POST']})
510 506 m.connect('my_account_emails', '/my_account/emails',
511 507 action='my_account_emails_delete', conditions={'method': ['DELETE']})
512 508
513 509 m.connect('my_account_notifications', '/my_account/notifications',
514 510 action='my_notifications',
515 511 conditions={'method': ['GET']})
516 512 m.connect('my_account_notifications_toggle_visibility',
517 513 '/my_account/toggle_visibility',
518 514 action='my_notifications_toggle_visibility',
519 515 conditions={'method': ['POST']})
520 516 m.connect('my_account_notifications_test_channelstream',
521 517 '/my_account/test_channelstream',
522 518 action='my_account_notifications_test_channelstream',
523 519 conditions={'method': ['POST']})
524 520
525 521 # NOTIFICATION REST ROUTES
526 522 with rmap.submapper(path_prefix=ADMIN_PREFIX,
527 523 controller='admin/notifications') as m:
528 524 m.connect('notifications', '/notifications',
529 525 action='index', conditions={'method': ['GET']})
530 526 m.connect('notifications_mark_all_read', '/notifications/mark_all_read',
531 527 action='mark_all_read', conditions={'method': ['POST']})
532 528 m.connect('/notifications/{notification_id}',
533 529 action='update', conditions={'method': ['PUT']})
534 530 m.connect('/notifications/{notification_id}',
535 531 action='delete', conditions={'method': ['DELETE']})
536 532 m.connect('notification', '/notifications/{notification_id}',
537 533 action='show', conditions={'method': ['GET']})
538 534
539 535 # ADMIN GIST
540 536 with rmap.submapper(path_prefix=ADMIN_PREFIX,
541 537 controller='admin/gists') as m:
542 538 m.connect('gists', '/gists',
543 539 action='create', conditions={'method': ['POST']})
544 540 m.connect('gists', '/gists', jsroute=True,
545 541 action='index', conditions={'method': ['GET']})
546 542 m.connect('new_gist', '/gists/new', jsroute=True,
547 543 action='new', conditions={'method': ['GET']})
548 544
549 545 m.connect('/gists/{gist_id}',
550 546 action='delete', conditions={'method': ['DELETE']})
551 547 m.connect('edit_gist', '/gists/{gist_id}/edit',
552 548 action='edit_form', conditions={'method': ['GET']})
553 549 m.connect('edit_gist', '/gists/{gist_id}/edit',
554 550 action='edit', conditions={'method': ['POST']})
555 551 m.connect(
556 552 'edit_gist_check_revision', '/gists/{gist_id}/edit/check_revision',
557 553 action='check_revision', conditions={'method': ['GET']})
558 554
559 555 m.connect('gist', '/gists/{gist_id}',
560 556 action='show', conditions={'method': ['GET']})
561 557 m.connect('gist_rev', '/gists/{gist_id}/{revision}',
562 558 revision='tip',
563 559 action='show', conditions={'method': ['GET']})
564 560 m.connect('formatted_gist', '/gists/{gist_id}/{revision}/{format}',
565 561 revision='tip',
566 562 action='show', conditions={'method': ['GET']})
567 563 m.connect('formatted_gist_file', '/gists/{gist_id}/{revision}/{format}/{f_path}',
568 564 revision='tip',
569 565 action='show', conditions={'method': ['GET']},
570 566 requirements=URL_NAME_REQUIREMENTS)
571 567
572 568 # ADMIN MAIN PAGES
573 569 with rmap.submapper(path_prefix=ADMIN_PREFIX,
574 570 controller='admin/admin') as m:
575 571 m.connect('admin_home', '', action='index')
576 572 m.connect('admin_add_repo', '/add_repo/{new_repo:[a-z0-9\. _-]*}',
577 573 action='add_repo')
578 574 m.connect(
579 575 'pull_requests_global_0', '/pull_requests/{pull_request_id:[0-9]+}',
580 576 action='pull_requests')
581 577 m.connect(
582 578 'pull_requests_global_1', '/pull-requests/{pull_request_id:[0-9]+}',
583 579 action='pull_requests')
584 580 m.connect(
585 581 'pull_requests_global', '/pull-request/{pull_request_id:[0-9]+}',
586 582 action='pull_requests')
587 583
588 584 # USER JOURNAL
589 585 rmap.connect('journal', '%s/journal' % (ADMIN_PREFIX,),
590 586 controller='journal', action='index')
591 587 rmap.connect('journal_rss', '%s/journal/rss' % (ADMIN_PREFIX,),
592 588 controller='journal', action='journal_rss')
593 589 rmap.connect('journal_atom', '%s/journal/atom' % (ADMIN_PREFIX,),
594 590 controller='journal', action='journal_atom')
595 591
596 592 rmap.connect('public_journal', '%s/public_journal' % (ADMIN_PREFIX,),
597 593 controller='journal', action='public_journal')
598 594
599 595 rmap.connect('public_journal_rss', '%s/public_journal/rss' % (ADMIN_PREFIX,),
600 596 controller='journal', action='public_journal_rss')
601 597
602 598 rmap.connect('public_journal_rss_old', '%s/public_journal_rss' % (ADMIN_PREFIX,),
603 599 controller='journal', action='public_journal_rss')
604 600
605 601 rmap.connect('public_journal_atom',
606 602 '%s/public_journal/atom' % (ADMIN_PREFIX,), controller='journal',
607 603 action='public_journal_atom')
608 604
609 605 rmap.connect('public_journal_atom_old',
610 606 '%s/public_journal_atom' % (ADMIN_PREFIX,), controller='journal',
611 607 action='public_journal_atom')
612 608
613 609 rmap.connect('toggle_following', '%s/toggle_following' % (ADMIN_PREFIX,),
614 610 controller='journal', action='toggle_following', jsroute=True,
615 611 conditions={'method': ['POST']})
616 612
617 613 # FEEDS
618 614 rmap.connect('rss_feed_home', '/{repo_name}/feed/rss',
619 615 controller='feed', action='rss',
620 616 conditions={'function': check_repo},
621 617 requirements=URL_NAME_REQUIREMENTS)
622 618
623 619 rmap.connect('atom_feed_home', '/{repo_name}/feed/atom',
624 620 controller='feed', action='atom',
625 621 conditions={'function': check_repo},
626 622 requirements=URL_NAME_REQUIREMENTS)
627 623
628 624 #==========================================================================
629 625 # REPOSITORY ROUTES
630 626 #==========================================================================
631 627
632 628 rmap.connect('repo_creating_home', '/{repo_name}/repo_creating',
633 629 controller='admin/repos', action='repo_creating',
634 630 requirements=URL_NAME_REQUIREMENTS)
635 631 rmap.connect('repo_check_home', '/{repo_name}/crepo_check',
636 632 controller='admin/repos', action='repo_check',
637 633 requirements=URL_NAME_REQUIREMENTS)
638 634
639 635 rmap.connect('repo_stats', '/{repo_name}/repo_stats/{commit_id}',
640 636 controller='summary', action='repo_stats',
641 637 conditions={'function': check_repo},
642 638 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
643 639
644 640 rmap.connect('repo_refs_data', '/{repo_name}/refs-data',
645 641 controller='summary', action='repo_refs_data',
646 642 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
647 643 rmap.connect('repo_refs_changelog_data', '/{repo_name}/refs-data-changelog',
648 644 controller='summary', action='repo_refs_changelog_data',
649 645 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
650 646 rmap.connect('repo_default_reviewers_data', '/{repo_name}/default-reviewers',
651 647 controller='summary', action='repo_default_reviewers_data',
652 648 jsroute=True, requirements=URL_NAME_REQUIREMENTS)
653 649
654 650 rmap.connect('changeset_home', '/{repo_name}/changeset/{revision}',
655 651 controller='changeset', revision='tip',
656 652 conditions={'function': check_repo},
657 653 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
658 654 rmap.connect('changeset_children', '/{repo_name}/changeset_children/{revision}',
659 655 controller='changeset', revision='tip', action='changeset_children',
660 656 conditions={'function': check_repo},
661 657 requirements=URL_NAME_REQUIREMENTS)
662 658 rmap.connect('changeset_parents', '/{repo_name}/changeset_parents/{revision}',
663 659 controller='changeset', revision='tip', action='changeset_parents',
664 660 conditions={'function': check_repo},
665 661 requirements=URL_NAME_REQUIREMENTS)
666 662
667 663 # repo edit options
668 rmap.connect('edit_repo', '/{repo_name}/settings', jsroute=True,
669 controller='admin/repos', action='edit',
670 conditions={'method': ['GET'], 'function': check_repo},
671 requirements=URL_NAME_REQUIREMENTS)
672
673 664 rmap.connect('edit_repo_perms', '/{repo_name}/settings/permissions',
674 665 jsroute=True,
675 666 controller='admin/repos', action='edit_permissions',
676 667 conditions={'method': ['GET'], 'function': check_repo},
677 668 requirements=URL_NAME_REQUIREMENTS)
678 669 rmap.connect('edit_repo_perms_update', '/{repo_name}/settings/permissions',
679 670 controller='admin/repos', action='edit_permissions_update',
680 671 conditions={'method': ['PUT'], 'function': check_repo},
681 672 requirements=URL_NAME_REQUIREMENTS)
682 673
683 674 rmap.connect('edit_repo_fields', '/{repo_name}/settings/fields',
684 675 controller='admin/repos', action='edit_fields',
685 676 conditions={'method': ['GET'], 'function': check_repo},
686 677 requirements=URL_NAME_REQUIREMENTS)
687 678 rmap.connect('create_repo_fields', '/{repo_name}/settings/fields/new',
688 679 controller='admin/repos', action='create_repo_field',
689 680 conditions={'method': ['PUT'], 'function': check_repo},
690 681 requirements=URL_NAME_REQUIREMENTS)
691 682 rmap.connect('delete_repo_fields', '/{repo_name}/settings/fields/{field_id}',
692 683 controller='admin/repos', action='delete_repo_field',
693 684 conditions={'method': ['DELETE'], 'function': check_repo},
694 685 requirements=URL_NAME_REQUIREMENTS)
695 686
696 687 rmap.connect('edit_repo_advanced', '/{repo_name}/settings/advanced',
697 688 controller='admin/repos', action='edit_advanced',
698 689 conditions={'method': ['GET'], 'function': check_repo},
699 690 requirements=URL_NAME_REQUIREMENTS)
700 691
701 692 rmap.connect('edit_repo_advanced_locking', '/{repo_name}/settings/advanced/locking',
702 693 controller='admin/repos', action='edit_advanced_locking',
703 694 conditions={'method': ['PUT'], 'function': check_repo},
704 695 requirements=URL_NAME_REQUIREMENTS)
705 696 rmap.connect('toggle_locking', '/{repo_name}/settings/advanced/locking_toggle',
706 697 controller='admin/repos', action='toggle_locking',
707 698 conditions={'method': ['GET'], 'function': check_repo},
708 699 requirements=URL_NAME_REQUIREMENTS)
709 700
710 701 rmap.connect('edit_repo_advanced_journal', '/{repo_name}/settings/advanced/journal',
711 702 controller='admin/repos', action='edit_advanced_journal',
712 703 conditions={'method': ['PUT'], 'function': check_repo},
713 704 requirements=URL_NAME_REQUIREMENTS)
714 705
715 706 rmap.connect('edit_repo_advanced_fork', '/{repo_name}/settings/advanced/fork',
716 707 controller='admin/repos', action='edit_advanced_fork',
717 708 conditions={'method': ['PUT'], 'function': check_repo},
718 709 requirements=URL_NAME_REQUIREMENTS)
719 710
720 711 rmap.connect('edit_repo_caches', '/{repo_name}/settings/caches',
721 712 controller='admin/repos', action='edit_caches_form',
722 713 conditions={'method': ['GET'], 'function': check_repo},
723 714 requirements=URL_NAME_REQUIREMENTS)
724 715 rmap.connect('edit_repo_caches', '/{repo_name}/settings/caches',
725 716 controller='admin/repos', action='edit_caches',
726 717 conditions={'method': ['PUT'], 'function': check_repo},
727 718 requirements=URL_NAME_REQUIREMENTS)
728 719
729 720 rmap.connect('edit_repo_remote', '/{repo_name}/settings/remote',
730 721 controller='admin/repos', action='edit_remote_form',
731 722 conditions={'method': ['GET'], 'function': check_repo},
732 723 requirements=URL_NAME_REQUIREMENTS)
733 724 rmap.connect('edit_repo_remote', '/{repo_name}/settings/remote',
734 725 controller='admin/repos', action='edit_remote',
735 726 conditions={'method': ['PUT'], 'function': check_repo},
736 727 requirements=URL_NAME_REQUIREMENTS)
737 728
738 729 rmap.connect('edit_repo_statistics', '/{repo_name}/settings/statistics',
739 730 controller='admin/repos', action='edit_statistics_form',
740 731 conditions={'method': ['GET'], 'function': check_repo},
741 732 requirements=URL_NAME_REQUIREMENTS)
742 733 rmap.connect('edit_repo_statistics', '/{repo_name}/settings/statistics',
743 734 controller='admin/repos', action='edit_statistics',
744 735 conditions={'method': ['PUT'], 'function': check_repo},
745 736 requirements=URL_NAME_REQUIREMENTS)
746 737 rmap.connect('repo_settings_issuetracker',
747 738 '/{repo_name}/settings/issue-tracker',
748 739 controller='admin/repos', action='repo_issuetracker',
749 740 conditions={'method': ['GET'], 'function': check_repo},
750 741 requirements=URL_NAME_REQUIREMENTS)
751 742 rmap.connect('repo_issuetracker_test',
752 743 '/{repo_name}/settings/issue-tracker/test',
753 744 controller='admin/repos', action='repo_issuetracker_test',
754 745 conditions={'method': ['POST'], 'function': check_repo},
755 746 requirements=URL_NAME_REQUIREMENTS)
756 747 rmap.connect('repo_issuetracker_delete',
757 748 '/{repo_name}/settings/issue-tracker/delete',
758 749 controller='admin/repos', action='repo_issuetracker_delete',
759 750 conditions={'method': ['DELETE'], 'function': check_repo},
760 751 requirements=URL_NAME_REQUIREMENTS)
761 752 rmap.connect('repo_issuetracker_save',
762 753 '/{repo_name}/settings/issue-tracker/save',
763 754 controller='admin/repos', action='repo_issuetracker_save',
764 755 conditions={'method': ['POST'], 'function': check_repo},
765 756 requirements=URL_NAME_REQUIREMENTS)
766 757 rmap.connect('repo_vcs_settings', '/{repo_name}/settings/vcs',
767 758 controller='admin/repos', action='repo_settings_vcs_update',
768 759 conditions={'method': ['POST'], 'function': check_repo},
769 760 requirements=URL_NAME_REQUIREMENTS)
770 761 rmap.connect('repo_vcs_settings', '/{repo_name}/settings/vcs',
771 762 controller='admin/repos', action='repo_settings_vcs',
772 763 conditions={'method': ['GET'], 'function': check_repo},
773 764 requirements=URL_NAME_REQUIREMENTS)
774 765 rmap.connect('repo_vcs_settings', '/{repo_name}/settings/vcs',
775 766 controller='admin/repos', action='repo_delete_svn_pattern',
776 767 conditions={'method': ['DELETE'], 'function': check_repo},
777 768 requirements=URL_NAME_REQUIREMENTS)
778 769 rmap.connect('repo_pullrequest_settings', '/{repo_name}/settings/pullrequest',
779 770 controller='admin/repos', action='repo_settings_pullrequest',
780 771 conditions={'method': ['GET', 'POST'], 'function': check_repo},
781 772 requirements=URL_NAME_REQUIREMENTS)
782 773
783 774 # still working url for backward compat.
784 775 rmap.connect('raw_changeset_home_depraced',
785 776 '/{repo_name}/raw-changeset/{revision}',
786 777 controller='changeset', action='changeset_raw',
787 778 revision='tip', conditions={'function': check_repo},
788 779 requirements=URL_NAME_REQUIREMENTS)
789 780
790 781 # new URLs
791 782 rmap.connect('changeset_raw_home',
792 783 '/{repo_name}/changeset-diff/{revision}',
793 784 controller='changeset', action='changeset_raw',
794 785 revision='tip', conditions={'function': check_repo},
795 786 requirements=URL_NAME_REQUIREMENTS)
796 787
797 788 rmap.connect('changeset_patch_home',
798 789 '/{repo_name}/changeset-patch/{revision}',
799 790 controller='changeset', action='changeset_patch',
800 791 revision='tip', conditions={'function': check_repo},
801 792 requirements=URL_NAME_REQUIREMENTS)
802 793
803 794 rmap.connect('changeset_download_home',
804 795 '/{repo_name}/changeset-download/{revision}',
805 796 controller='changeset', action='changeset_download',
806 797 revision='tip', conditions={'function': check_repo},
807 798 requirements=URL_NAME_REQUIREMENTS)
808 799
809 800 rmap.connect('changeset_comment',
810 801 '/{repo_name}/changeset/{revision}/comment', jsroute=True,
811 802 controller='changeset', revision='tip', action='comment',
812 803 conditions={'function': check_repo},
813 804 requirements=URL_NAME_REQUIREMENTS)
814 805
815 806 rmap.connect('changeset_comment_preview',
816 807 '/{repo_name}/changeset/comment/preview', jsroute=True,
817 808 controller='changeset', action='preview_comment',
818 809 conditions={'function': check_repo, 'method': ['POST']},
819 810 requirements=URL_NAME_REQUIREMENTS)
820 811
821 812 rmap.connect('changeset_comment_delete',
822 813 '/{repo_name}/changeset/comment/{comment_id}/delete',
823 814 controller='changeset', action='delete_comment',
824 815 conditions={'function': check_repo, 'method': ['DELETE']},
825 816 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
826 817
827 818 rmap.connect('changeset_info', '/{repo_name}/changeset_info/{revision}',
828 819 controller='changeset', action='changeset_info',
829 820 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
830 821
831 822 rmap.connect('compare_home',
832 823 '/{repo_name}/compare',
833 824 controller='compare', action='index',
834 825 conditions={'function': check_repo},
835 826 requirements=URL_NAME_REQUIREMENTS)
836 827
837 828 rmap.connect('compare_url',
838 829 '/{repo_name}/compare/{source_ref_type}@{source_ref:.*?}...{target_ref_type}@{target_ref:.*?}',
839 830 controller='compare', action='compare',
840 831 conditions={'function': check_repo},
841 832 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
842 833
843 834 rmap.connect('pullrequest_home',
844 835 '/{repo_name}/pull-request/new', controller='pullrequests',
845 836 action='index', conditions={'function': check_repo,
846 837 'method': ['GET']},
847 838 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
848 839
849 840 rmap.connect('pullrequest',
850 841 '/{repo_name}/pull-request/new', controller='pullrequests',
851 842 action='create', conditions={'function': check_repo,
852 843 'method': ['POST']},
853 844 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
854 845
855 846 rmap.connect('pullrequest_repo_refs',
856 847 '/{repo_name}/pull-request/refs/{target_repo_name:.*?[^/]}',
857 848 controller='pullrequests',
858 849 action='get_repo_refs',
859 850 conditions={'function': check_repo, 'method': ['GET']},
860 851 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
861 852
862 853 rmap.connect('pullrequest_repo_destinations',
863 854 '/{repo_name}/pull-request/repo-destinations',
864 855 controller='pullrequests',
865 856 action='get_repo_destinations',
866 857 conditions={'function': check_repo, 'method': ['GET']},
867 858 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
868 859
869 860 rmap.connect('pullrequest_show',
870 861 '/{repo_name}/pull-request/{pull_request_id}',
871 862 controller='pullrequests',
872 863 action='show', conditions={'function': check_repo,
873 864 'method': ['GET']},
874 865 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
875 866
876 867 rmap.connect('pullrequest_update',
877 868 '/{repo_name}/pull-request/{pull_request_id}',
878 869 controller='pullrequests',
879 870 action='update', conditions={'function': check_repo,
880 871 'method': ['PUT']},
881 872 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
882 873
883 874 rmap.connect('pullrequest_merge',
884 875 '/{repo_name}/pull-request/{pull_request_id}',
885 876 controller='pullrequests',
886 877 action='merge', conditions={'function': check_repo,
887 878 'method': ['POST']},
888 879 requirements=URL_NAME_REQUIREMENTS)
889 880
890 881 rmap.connect('pullrequest_delete',
891 882 '/{repo_name}/pull-request/{pull_request_id}',
892 883 controller='pullrequests',
893 884 action='delete', conditions={'function': check_repo,
894 885 'method': ['DELETE']},
895 886 requirements=URL_NAME_REQUIREMENTS)
896 887
897 888 rmap.connect('pullrequest_show_all',
898 889 '/{repo_name}/pull-request',
899 890 controller='pullrequests',
900 891 action='show_all', conditions={'function': check_repo,
901 892 'method': ['GET']},
902 893 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
903 894
904 895 rmap.connect('pullrequest_comment',
905 896 '/{repo_name}/pull-request-comment/{pull_request_id}',
906 897 controller='pullrequests',
907 898 action='comment', conditions={'function': check_repo,
908 899 'method': ['POST']},
909 900 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
910 901
911 902 rmap.connect('pullrequest_comment_delete',
912 903 '/{repo_name}/pull-request-comment/{comment_id}/delete',
913 904 controller='pullrequests', action='delete_comment',
914 905 conditions={'function': check_repo, 'method': ['DELETE']},
915 906 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
916 907
917 908 rmap.connect('summary_home_explicit', '/{repo_name}/summary',
918 909 controller='summary', conditions={'function': check_repo},
919 910 requirements=URL_NAME_REQUIREMENTS)
920 911
921 912 rmap.connect('branches_home', '/{repo_name}/branches',
922 913 controller='branches', conditions={'function': check_repo},
923 914 requirements=URL_NAME_REQUIREMENTS)
924 915
925 916 rmap.connect('tags_home', '/{repo_name}/tags',
926 917 controller='tags', conditions={'function': check_repo},
927 918 requirements=URL_NAME_REQUIREMENTS)
928 919
929 920 rmap.connect('bookmarks_home', '/{repo_name}/bookmarks',
930 921 controller='bookmarks', conditions={'function': check_repo},
931 922 requirements=URL_NAME_REQUIREMENTS)
932 923
933 924 rmap.connect('changelog_home', '/{repo_name}/changelog', jsroute=True,
934 925 controller='changelog', conditions={'function': check_repo},
935 926 requirements=URL_NAME_REQUIREMENTS)
936 927
937 928 rmap.connect('changelog_summary_home', '/{repo_name}/changelog_summary',
938 929 controller='changelog', action='changelog_summary',
939 930 conditions={'function': check_repo},
940 931 requirements=URL_NAME_REQUIREMENTS)
941 932
942 933 rmap.connect('changelog_file_home',
943 934 '/{repo_name}/changelog/{revision}/{f_path}',
944 935 controller='changelog', f_path=None,
945 936 conditions={'function': check_repo},
946 937 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
947 938
948 939 rmap.connect('changelog_elements', '/{repo_name}/changelog_details',
949 940 controller='changelog', action='changelog_elements',
950 941 conditions={'function': check_repo},
951 942 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
952 943
953 944 rmap.connect('files_home', '/{repo_name}/files/{revision}/{f_path}',
954 945 controller='files', revision='tip', f_path='',
955 946 conditions={'function': check_repo},
956 947 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
957 948
958 949 rmap.connect('files_home_simple_catchrev',
959 950 '/{repo_name}/files/{revision}',
960 951 controller='files', revision='tip', f_path='',
961 952 conditions={'function': check_repo},
962 953 requirements=URL_NAME_REQUIREMENTS)
963 954
964 955 rmap.connect('files_home_simple_catchall',
965 956 '/{repo_name}/files',
966 957 controller='files', revision='tip', f_path='',
967 958 conditions={'function': check_repo},
968 959 requirements=URL_NAME_REQUIREMENTS)
969 960
970 961 rmap.connect('files_history_home',
971 962 '/{repo_name}/history/{revision}/{f_path}',
972 963 controller='files', action='history', revision='tip', f_path='',
973 964 conditions={'function': check_repo},
974 965 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
975 966
976 967 rmap.connect('files_authors_home',
977 968 '/{repo_name}/authors/{revision}/{f_path}',
978 969 controller='files', action='authors', revision='tip', f_path='',
979 970 conditions={'function': check_repo},
980 971 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
981 972
982 973 rmap.connect('files_diff_home', '/{repo_name}/diff/{f_path}',
983 974 controller='files', action='diff', f_path='',
984 975 conditions={'function': check_repo},
985 976 requirements=URL_NAME_REQUIREMENTS)
986 977
987 978 rmap.connect('files_diff_2way_home',
988 979 '/{repo_name}/diff-2way/{f_path}',
989 980 controller='files', action='diff_2way', f_path='',
990 981 conditions={'function': check_repo},
991 982 requirements=URL_NAME_REQUIREMENTS)
992 983
993 984 rmap.connect('files_rawfile_home',
994 985 '/{repo_name}/rawfile/{revision}/{f_path}',
995 986 controller='files', action='rawfile', revision='tip',
996 987 f_path='', conditions={'function': check_repo},
997 988 requirements=URL_NAME_REQUIREMENTS)
998 989
999 990 rmap.connect('files_raw_home',
1000 991 '/{repo_name}/raw/{revision}/{f_path}',
1001 992 controller='files', action='raw', revision='tip', f_path='',
1002 993 conditions={'function': check_repo},
1003 994 requirements=URL_NAME_REQUIREMENTS)
1004 995
1005 996 rmap.connect('files_render_home',
1006 997 '/{repo_name}/render/{revision}/{f_path}',
1007 998 controller='files', action='index', revision='tip', f_path='',
1008 999 rendered=True, conditions={'function': check_repo},
1009 1000 requirements=URL_NAME_REQUIREMENTS)
1010 1001
1011 1002 rmap.connect('files_annotate_home',
1012 1003 '/{repo_name}/annotate/{revision}/{f_path}',
1013 1004 controller='files', action='index', revision='tip',
1014 1005 f_path='', annotate=True, conditions={'function': check_repo},
1015 1006 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
1016 1007
1017 1008 rmap.connect('files_annotate_previous',
1018 1009 '/{repo_name}/annotate-previous/{revision}/{f_path}',
1019 1010 controller='files', action='annotate_previous', revision='tip',
1020 1011 f_path='', annotate=True, conditions={'function': check_repo},
1021 1012 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
1022 1013
1023 1014 rmap.connect('files_edit',
1024 1015 '/{repo_name}/edit/{revision}/{f_path}',
1025 1016 controller='files', action='edit', revision='tip',
1026 1017 f_path='',
1027 1018 conditions={'function': check_repo, 'method': ['POST']},
1028 1019 requirements=URL_NAME_REQUIREMENTS)
1029 1020
1030 1021 rmap.connect('files_edit_home',
1031 1022 '/{repo_name}/edit/{revision}/{f_path}',
1032 1023 controller='files', action='edit_home', revision='tip',
1033 1024 f_path='', conditions={'function': check_repo},
1034 1025 requirements=URL_NAME_REQUIREMENTS)
1035 1026
1036 1027 rmap.connect('files_add',
1037 1028 '/{repo_name}/add/{revision}/{f_path}',
1038 1029 controller='files', action='add', revision='tip',
1039 1030 f_path='',
1040 1031 conditions={'function': check_repo, 'method': ['POST']},
1041 1032 requirements=URL_NAME_REQUIREMENTS)
1042 1033
1043 1034 rmap.connect('files_add_home',
1044 1035 '/{repo_name}/add/{revision}/{f_path}',
1045 1036 controller='files', action='add_home', revision='tip',
1046 1037 f_path='', conditions={'function': check_repo},
1047 1038 requirements=URL_NAME_REQUIREMENTS)
1048 1039
1049 1040 rmap.connect('files_delete',
1050 1041 '/{repo_name}/delete/{revision}/{f_path}',
1051 1042 controller='files', action='delete', revision='tip',
1052 1043 f_path='',
1053 1044 conditions={'function': check_repo, 'method': ['POST']},
1054 1045 requirements=URL_NAME_REQUIREMENTS)
1055 1046
1056 1047 rmap.connect('files_delete_home',
1057 1048 '/{repo_name}/delete/{revision}/{f_path}',
1058 1049 controller='files', action='delete_home', revision='tip',
1059 1050 f_path='', conditions={'function': check_repo},
1060 1051 requirements=URL_NAME_REQUIREMENTS)
1061 1052
1062 1053 rmap.connect('files_archive_home', '/{repo_name}/archive/{fname}',
1063 1054 controller='files', action='archivefile',
1064 1055 conditions={'function': check_repo},
1065 1056 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
1066 1057
1067 1058 rmap.connect('files_nodelist_home',
1068 1059 '/{repo_name}/nodelist/{revision}/{f_path}',
1069 1060 controller='files', action='nodelist',
1070 1061 conditions={'function': check_repo},
1071 1062 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
1072 1063
1073 1064 rmap.connect('files_nodetree_full',
1074 1065 '/{repo_name}/nodetree_full/{commit_id}/{f_path}',
1075 1066 controller='files', action='nodetree_full',
1076 1067 conditions={'function': check_repo},
1077 1068 requirements=URL_NAME_REQUIREMENTS, jsroute=True)
1078 1069
1079 1070 rmap.connect('repo_fork_create_home', '/{repo_name}/fork',
1080 1071 controller='forks', action='fork_create',
1081 1072 conditions={'function': check_repo, 'method': ['POST']},
1082 1073 requirements=URL_NAME_REQUIREMENTS)
1083 1074
1084 1075 rmap.connect('repo_fork_home', '/{repo_name}/fork',
1085 1076 controller='forks', action='fork',
1086 1077 conditions={'function': check_repo},
1087 1078 requirements=URL_NAME_REQUIREMENTS)
1088 1079
1089 1080 rmap.connect('repo_forks_home', '/{repo_name}/forks',
1090 1081 controller='forks', action='forks',
1091 1082 conditions={'function': check_repo},
1092 1083 requirements=URL_NAME_REQUIREMENTS)
1093 1084
1094 1085 # must be here for proper group/repo catching pattern
1095 1086 _connect_with_slash(
1096 1087 rmap, 'repo_group_home', '/{group_name}',
1097 1088 controller='home', action='index_repo_group',
1098 1089 conditions={'function': check_group},
1099 1090 requirements=URL_NAME_REQUIREMENTS)
1100 1091
1101 1092 # catch all, at the end
1102 1093 _connect_with_slash(
1103 1094 rmap, 'summary_home', '/{repo_name}', jsroute=True,
1104 1095 controller='summary', action='index',
1105 1096 conditions={'function': check_repo},
1106 1097 requirements=URL_NAME_REQUIREMENTS)
1107 1098
1108 1099 return rmap
1109 1100
1110 1101
1111 1102 def _connect_with_slash(mapper, name, path, *args, **kwargs):
1112 1103 """
1113 1104 Connect a route with an optional trailing slash in `path`.
1114 1105 """
1115 1106 mapper.connect(name + '_slash', path + '/', *args, **kwargs)
1116 1107 mapper.connect(name, path, *args, **kwargs)
@@ -1,888 +1,805 b''
1 1 # -*- coding: utf-8 -*-
2 2
3 3 # Copyright (C) 2013-2017 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 Repositories controller for RhodeCode
24 24 """
25 25
26 26 import logging
27 27 import traceback
28 28
29 29 import formencode
30 30 from formencode import htmlfill
31 31 from pylons import request, tmpl_context as c, url
32 32 from pylons.controllers.util import redirect
33 33 from pylons.i18n.translation import _
34 34 from webob.exc import HTTPForbidden, HTTPNotFound, HTTPBadRequest
35 35
36 36 import rhodecode
37 37 from rhodecode.lib import auth, helpers as h
38 38 from rhodecode.lib.auth import (
39 39 LoginRequired, HasPermissionAllDecorator,
40 40 HasRepoPermissionAllDecorator, NotAnonymous, HasPermissionAny,
41 41 HasRepoGroupPermissionAny, HasRepoPermissionAnyDecorator)
42 42 from rhodecode.lib.base import BaseRepoController, render
43 43 from rhodecode.lib.ext_json import json
44 44 from rhodecode.lib.exceptions import AttachedForksError
45 45 from rhodecode.lib.utils import action_logger, repo_name_slug, jsonify
46 46 from rhodecode.lib.utils2 import safe_int, str2bool
47 47 from rhodecode.lib.vcs import RepositoryError
48 48 from rhodecode.model.db import (
49 49 User, Repository, UserFollowing, RepoGroup, RepositoryField)
50 50 from rhodecode.model.forms import (
51 51 RepoForm, RepoFieldForm, RepoPermsForm, RepoVcsSettingsForm,
52 52 IssueTrackerPatternsForm)
53 53 from rhodecode.model.meta import Session
54 54 from rhodecode.model.repo import RepoModel
55 55 from rhodecode.model.scm import ScmModel, RepoGroupList, RepoList
56 56 from rhodecode.model.settings import (
57 57 SettingsModel, IssueTrackerSettingsModel, VcsSettingsModel,
58 58 SettingNotFound)
59 59
60 60 log = logging.getLogger(__name__)
61 61
62 62
63 63 class ReposController(BaseRepoController):
64 64 """
65 65 REST Controller styled on the Atom Publishing Protocol"""
66 66 # To properly map this controller, ensure your config/routing.py
67 67 # file has a resource setup:
68 68 # map.resource('repo', 'repos')
69 69
70 70 @LoginRequired()
71 71 def __before__(self):
72 72 super(ReposController, self).__before__()
73 73
74 74 def _load_repo(self, repo_name):
75 75 repo_obj = Repository.get_by_repo_name(repo_name)
76 76
77 77 if repo_obj is None:
78 78 h.not_mapped_error(repo_name)
79 79 return redirect(url('repos'))
80 80
81 81 return repo_obj
82 82
83 83 def __load_defaults(self, repo=None):
84 84 acl_groups = RepoGroupList(RepoGroup.query().all(),
85 85 perm_set=['group.write', 'group.admin'])
86 86 c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)
87 87 c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)
88 88
89 89 # in case someone no longer have a group.write access to a repository
90 90 # pre fill the list with this entry, we don't care if this is the same
91 91 # but it will allow saving repo data properly.
92 92
93 93 repo_group = None
94 94 if repo:
95 95 repo_group = repo.group
96 96 if repo_group and unicode(repo_group.group_id) not in c.repo_groups_choices:
97 97 c.repo_groups_choices.append(unicode(repo_group.group_id))
98 98 c.repo_groups.append(RepoGroup._generate_choice(repo_group))
99 99
100 100 choices, c.landing_revs = ScmModel().get_repo_landing_revs()
101 101 c.landing_revs_choices = choices
102 102
103 103 def __load_data(self, repo_name=None):
104 104 """
105 105 Load defaults settings for edit, and update
106 106
107 107 :param repo_name:
108 108 """
109 109 c.repo_info = self._load_repo(repo_name)
110 110 self.__load_defaults(c.repo_info)
111 111
112 112 # override defaults for exact repo info here git/hg etc
113 113 if not c.repository_requirements_missing:
114 114 choices, c.landing_revs = ScmModel().get_repo_landing_revs(
115 115 c.repo_info)
116 116 c.landing_revs_choices = choices
117 117 defaults = RepoModel()._get_defaults(repo_name)
118 118
119 119 return defaults
120 120
121 121 def _log_creation_exception(self, e, repo_name):
122 122 reason = None
123 123 if len(e.args) == 2:
124 124 reason = e.args[1]
125 125
126 126 if reason == 'INVALID_CERTIFICATE':
127 127 log.exception(
128 128 'Exception creating a repository: invalid certificate')
129 129 msg = (_('Error creating repository %s: invalid certificate')
130 130 % repo_name)
131 131 else:
132 132 log.exception("Exception creating a repository")
133 133 msg = (_('Error creating repository %s')
134 134 % repo_name)
135 135
136 136 return msg
137 137
138 138 @NotAnonymous()
139 139 def index(self, format='html'):
140 140 """GET /repos: All items in the collection"""
141 141 # url('repos')
142 142
143 143 repo_list = Repository.get_all_repos()
144 144 c.repo_list = RepoList(repo_list, perm_set=['repository.admin'])
145 145 repos_data = RepoModel().get_repos_as_dict(
146 146 repo_list=c.repo_list, admin=True, super_user_actions=True)
147 147 # json used to render the grid
148 148 c.data = json.dumps(repos_data)
149 149
150 150 return render('admin/repos/repos.mako')
151 151
152 152 # perms check inside
153 153 @NotAnonymous()
154 154 @auth.CSRFRequired()
155 155 def create(self):
156 156 """
157 157 POST /repos: Create a new item"""
158 158 # url('repos')
159 159
160 160 self.__load_defaults()
161 161 form_result = {}
162 162 task_id = None
163 163 c.personal_repo_group = c.rhodecode_user.personal_repo_group
164 164 try:
165 165 # CanWriteToGroup validators checks permissions of this POST
166 166 form_result = RepoForm(repo_groups=c.repo_groups_choices,
167 167 landing_revs=c.landing_revs_choices)()\
168 168 .to_python(dict(request.POST))
169 169
170 170 # create is done sometimes async on celery, db transaction
171 171 # management is handled there.
172 172 task = RepoModel().create(form_result, c.rhodecode_user.user_id)
173 173 from celery.result import BaseAsyncResult
174 174 if isinstance(task, BaseAsyncResult):
175 175 task_id = task.task_id
176 176 except formencode.Invalid as errors:
177 177 return htmlfill.render(
178 178 render('admin/repos/repo_add.mako'),
179 179 defaults=errors.value,
180 180 errors=errors.error_dict or {},
181 181 prefix_error=False,
182 182 encoding="UTF-8",
183 183 force_defaults=False)
184 184
185 185 except Exception as e:
186 186 msg = self._log_creation_exception(e, form_result.get('repo_name'))
187 187 h.flash(msg, category='error')
188 188 return redirect(url('home'))
189 189
190 190 return redirect(h.url('repo_creating_home',
191 191 repo_name=form_result['repo_name_full'],
192 192 task_id=task_id))
193 193
194 194 # perms check inside
195 195 @NotAnonymous()
196 196 def create_repository(self):
197 197 """GET /_admin/create_repository: Form to create a new item"""
198 198 new_repo = request.GET.get('repo', '')
199 199 parent_group = safe_int(request.GET.get('parent_group'))
200 200 _gr = RepoGroup.get(parent_group)
201 201
202 202 if not HasPermissionAny('hg.admin', 'hg.create.repository')():
203 203 # you're not super admin nor have global create permissions,
204 204 # but maybe you have at least write permission to a parent group ?
205 205
206 206 gr_name = _gr.group_name if _gr else None
207 207 # create repositories with write permission on group is set to true
208 208 create_on_write = HasPermissionAny('hg.create.write_on_repogroup.true')()
209 209 group_admin = HasRepoGroupPermissionAny('group.admin')(group_name=gr_name)
210 210 group_write = HasRepoGroupPermissionAny('group.write')(group_name=gr_name)
211 211 if not (group_admin or (group_write and create_on_write)):
212 212 raise HTTPForbidden
213 213
214 214 acl_groups = RepoGroupList(RepoGroup.query().all(),
215 215 perm_set=['group.write', 'group.admin'])
216 216 c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)
217 217 c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)
218 218 choices, c.landing_revs = ScmModel().get_repo_landing_revs()
219 219 c.personal_repo_group = c.rhodecode_user.personal_repo_group
220 220 c.new_repo = repo_name_slug(new_repo)
221 221
222 222 # apply the defaults from defaults page
223 223 defaults = SettingsModel().get_default_repo_settings(strip_prefix=True)
224 224 # set checkbox to autochecked
225 225 defaults['repo_copy_permissions'] = True
226 226
227 227 parent_group_choice = '-1'
228 228 if not c.rhodecode_user.is_admin and c.rhodecode_user.personal_repo_group:
229 229 parent_group_choice = c.rhodecode_user.personal_repo_group
230 230
231 231 if parent_group and _gr:
232 232 if parent_group in [x[0] for x in c.repo_groups]:
233 233 parent_group_choice = unicode(parent_group)
234 234
235 235 defaults.update({'repo_group': parent_group_choice})
236 236
237 237 return htmlfill.render(
238 238 render('admin/repos/repo_add.mako'),
239 239 defaults=defaults,
240 240 errors={},
241 241 prefix_error=False,
242 242 encoding="UTF-8",
243 243 force_defaults=False
244 244 )
245 245
246 246 @NotAnonymous()
247 247 def repo_creating(self, repo_name):
248 248 c.repo = repo_name
249 249 c.task_id = request.GET.get('task_id')
250 250 if not c.repo:
251 251 raise HTTPNotFound()
252 252 return render('admin/repos/repo_creating.mako')
253 253
254 254 @NotAnonymous()
255 255 @jsonify
256 256 def repo_check(self, repo_name):
257 257 c.repo = repo_name
258 258 task_id = request.GET.get('task_id')
259 259
260 260 if task_id and task_id not in ['None']:
261 261 import rhodecode
262 262 from celery.result import AsyncResult
263 263 if rhodecode.CELERY_ENABLED:
264 264 task = AsyncResult(task_id)
265 265 if task.failed():
266 266 msg = self._log_creation_exception(task.result, c.repo)
267 267 h.flash(msg, category='error')
268 268 return redirect(url('home'), code=501)
269 269
270 270 repo = Repository.get_by_repo_name(repo_name)
271 271 if repo and repo.repo_state == Repository.STATE_CREATED:
272 272 if repo.clone_uri:
273 273 clone_uri = repo.clone_uri_hidden
274 274 h.flash(_('Created repository %s from %s')
275 275 % (repo.repo_name, clone_uri), category='success')
276 276 else:
277 277 repo_url = h.link_to(repo.repo_name,
278 278 h.url('summary_home',
279 279 repo_name=repo.repo_name))
280 280 fork = repo.fork
281 281 if fork:
282 282 fork_name = fork.repo_name
283 283 h.flash(h.literal(_('Forked repository %s as %s')
284 284 % (fork_name, repo_url)), category='success')
285 285 else:
286 286 h.flash(h.literal(_('Created repository %s') % repo_url),
287 287 category='success')
288 288 return {'result': True}
289 289 return {'result': False}
290 290
291 291 @HasRepoPermissionAllDecorator('repository.admin')
292 292 @auth.CSRFRequired()
293 def update(self, repo_name):
294 """
295 PUT /repos/repo_name: Update an existing item"""
296 # Forms posted to this method should contain a hidden field:
297 # <input type="hidden" name="_method" value="PUT" />
298 # Or using helpers:
299 # h.form(url('repo', repo_name=ID),
300 # method='put')
301 # url('repo', repo_name=ID)
302
303 self.__load_data(repo_name)
304 c.active = 'settings'
305 c.repo_fields = RepositoryField.query()\
306 .filter(RepositoryField.repository == c.repo_info).all()
307
308 repo_model = RepoModel()
309 changed_name = repo_name
310
311 c.personal_repo_group = c.rhodecode_user.personal_repo_group
312 # override the choices with extracted revisions !
313 repo = Repository.get_by_repo_name(repo_name)
314 old_data = {
315 'repo_name': repo_name,
316 'repo_group': repo.group.get_dict() if repo.group else {},
317 'repo_type': repo.repo_type,
318 }
319 _form = RepoForm(
320 edit=True, old_data=old_data, repo_groups=c.repo_groups_choices,
321 landing_revs=c.landing_revs_choices, allow_disabled=True)()
322
323 try:
324 form_result = _form.to_python(dict(request.POST))
325 repo = repo_model.update(repo_name, **form_result)
326 ScmModel().mark_for_invalidation(repo_name)
327 h.flash(_('Repository %s updated successfully') % repo_name,
328 category='success')
329 changed_name = repo.repo_name
330 action_logger(c.rhodecode_user, 'admin_updated_repo',
331 changed_name, self.ip_addr, self.sa)
332 Session().commit()
333 except formencode.Invalid as errors:
334 defaults = self.__load_data(repo_name)
335 defaults.update(errors.value)
336 return htmlfill.render(
337 render('admin/repos/repo_edit.mako'),
338 defaults=defaults,
339 errors=errors.error_dict or {},
340 prefix_error=False,
341 encoding="UTF-8",
342 force_defaults=False)
343
344 except Exception:
345 log.exception("Exception during update of repository")
346 h.flash(_('Error occurred during update of repository %s') \
347 % repo_name, category='error')
348 return redirect(url('edit_repo', repo_name=changed_name))
349
350 @HasRepoPermissionAllDecorator('repository.admin')
351 @auth.CSRFRequired()
352 293 def delete(self, repo_name):
353 294 """
354 295 DELETE /repos/repo_name: Delete an existing item"""
355 296 # Forms posted to this method should contain a hidden field:
356 297 # <input type="hidden" name="_method" value="DELETE" />
357 298 # Or using helpers:
358 299 # h.form(url('repo', repo_name=ID),
359 300 # method='delete')
360 301 # url('repo', repo_name=ID)
361 302
362 303 repo_model = RepoModel()
363 304 repo = repo_model.get_by_repo_name(repo_name)
364 305 if not repo:
365 306 h.not_mapped_error(repo_name)
366 307 return redirect(url('repos'))
367 308 try:
368 309 _forks = repo.forks.count()
369 310 handle_forks = None
370 311 if _forks and request.POST.get('forks'):
371 312 do = request.POST['forks']
372 313 if do == 'detach_forks':
373 314 handle_forks = 'detach'
374 315 h.flash(_('Detached %s forks') % _forks, category='success')
375 316 elif do == 'delete_forks':
376 317 handle_forks = 'delete'
377 318 h.flash(_('Deleted %s forks') % _forks, category='success')
378 319 repo_model.delete(repo, forks=handle_forks)
379 320 action_logger(c.rhodecode_user, 'admin_deleted_repo',
380 321 repo_name, self.ip_addr, self.sa)
381 322 ScmModel().mark_for_invalidation(repo_name)
382 323 h.flash(_('Deleted repository %s') % repo_name, category='success')
383 324 Session().commit()
384 325 except AttachedForksError:
385 326 h.flash(_('Cannot delete %s it still contains attached forks')
386 327 % repo_name, category='warning')
387 328
388 329 except Exception:
389 330 log.exception("Exception during deletion of repository")
390 331 h.flash(_('An error occurred during deletion of %s') % repo_name,
391 332 category='error')
392 333
393 334 return redirect(url('repos'))
394 335
395 336 @HasPermissionAllDecorator('hg.admin')
396 337 def show(self, repo_name, format='html'):
397 338 """GET /repos/repo_name: Show a specific item"""
398 339 # url('repo', repo_name=ID)
399 340
400 341 @HasRepoPermissionAllDecorator('repository.admin')
401 def edit(self, repo_name):
402 """GET /repo_name/settings: Form to edit an existing item"""
403 # url('edit_repo', repo_name=ID)
404 defaults = self.__load_data(repo_name)
405 if 'clone_uri' in defaults:
406 del defaults['clone_uri']
407
408 c.repo_fields = RepositoryField.query()\
409 .filter(RepositoryField.repository == c.repo_info).all()
410 c.personal_repo_group = c.rhodecode_user.personal_repo_group
411 c.active = 'settings'
412 return htmlfill.render(
413 render('admin/repos/repo_edit.mako'),
414 defaults=defaults,
415 encoding="UTF-8",
416 force_defaults=False)
417
418 @HasRepoPermissionAllDecorator('repository.admin')
419 342 def edit_permissions(self, repo_name):
420 343 """GET /repo_name/settings: Form to edit an existing item"""
421 # url('edit_repo', repo_name=ID)
422 344 c.repo_info = self._load_repo(repo_name)
423 345 c.active = 'permissions'
424 346 defaults = RepoModel()._get_defaults(repo_name)
425 347
426 348 return htmlfill.render(
427 349 render('admin/repos/repo_edit.mako'),
428 350 defaults=defaults,
429 351 encoding="UTF-8",
430 352 force_defaults=False)
431 353
432 354 @HasRepoPermissionAllDecorator('repository.admin')
433 355 @auth.CSRFRequired()
434 356 def edit_permissions_update(self, repo_name):
435 357 form = RepoPermsForm()().to_python(request.POST)
436 358 RepoModel().update_permissions(repo_name,
437 359 form['perm_additions'], form['perm_updates'], form['perm_deletions'])
438 360
439 361 #TODO: implement this
440 362 #action_logger(c.rhodecode_user, 'admin_changed_repo_permissions',
441 363 # repo_name, self.ip_addr, self.sa)
442 364 Session().commit()
443 365 h.flash(_('Repository permissions updated'), category='success')
444 366 return redirect(url('edit_repo_perms', repo_name=repo_name))
445 367
446 368 @HasRepoPermissionAllDecorator('repository.admin')
447 369 def edit_fields(self, repo_name):
448 370 """GET /repo_name/settings: Form to edit an existing item"""
449 # url('edit_repo', repo_name=ID)
450 371 c.repo_info = self._load_repo(repo_name)
451 372 c.repo_fields = RepositoryField.query()\
452 373 .filter(RepositoryField.repository == c.repo_info).all()
453 374 c.active = 'fields'
454 375 if request.POST:
455 376
456 377 return redirect(url('repo_edit_fields'))
457 378 return render('admin/repos/repo_edit.mako')
458 379
459 380 @HasRepoPermissionAllDecorator('repository.admin')
460 381 @auth.CSRFRequired()
461 382 def create_repo_field(self, repo_name):
462 383 try:
463 384 form_result = RepoFieldForm()().to_python(dict(request.POST))
464 385 RepoModel().add_repo_field(
465 386 repo_name, form_result['new_field_key'],
466 387 field_type=form_result['new_field_type'],
467 388 field_value=form_result['new_field_value'],
468 389 field_label=form_result['new_field_label'],
469 390 field_desc=form_result['new_field_desc'])
470 391
471 392 Session().commit()
472 393 except Exception as e:
473 394 log.exception("Exception creating field")
474 395 msg = _('An error occurred during creation of field')
475 396 if isinstance(e, formencode.Invalid):
476 397 msg += ". " + e.msg
477 398 h.flash(msg, category='error')
478 399 return redirect(url('edit_repo_fields', repo_name=repo_name))
479 400
480 401 @HasRepoPermissionAllDecorator('repository.admin')
481 402 @auth.CSRFRequired()
482 403 def delete_repo_field(self, repo_name, field_id):
483 404 field = RepositoryField.get_or_404(field_id)
484 405 try:
485 406 RepoModel().delete_repo_field(repo_name, field.field_key)
486 407 Session().commit()
487 408 except Exception as e:
488 409 log.exception("Exception during removal of field")
489 410 msg = _('An error occurred during removal of field')
490 411 h.flash(msg, category='error')
491 412 return redirect(url('edit_repo_fields', repo_name=repo_name))
492 413
493 414 @HasRepoPermissionAllDecorator('repository.admin')
494 415 def edit_advanced(self, repo_name):
495 416 """GET /repo_name/settings: Form to edit an existing item"""
496 # url('edit_repo', repo_name=ID)
497 417 c.repo_info = self._load_repo(repo_name)
498 418 c.default_user_id = User.get_default_user().user_id
499 419 c.in_public_journal = UserFollowing.query()\
500 420 .filter(UserFollowing.user_id == c.default_user_id)\
501 421 .filter(UserFollowing.follows_repository == c.repo_info).scalar()
502 422
503 423 c.active = 'advanced'
504 424 c.has_origin_repo_read_perm = False
505 425 if c.repo_info.fork:
506 426 c.has_origin_repo_read_perm = h.HasRepoPermissionAny(
507 427 'repository.write', 'repository.read', 'repository.admin')(
508 428 c.repo_info.fork.repo_name, 'repo set as fork page')
509 429
510 430 if request.POST:
511 431 return redirect(url('repo_edit_advanced'))
512 432 return render('admin/repos/repo_edit.mako')
513 433
514 434 @HasRepoPermissionAllDecorator('repository.admin')
515 435 @auth.CSRFRequired()
516 436 def edit_advanced_journal(self, repo_name):
517 437 """
518 438 Set's this repository to be visible in public journal,
519 439 in other words assing default user to follow this repo
520 440
521 441 :param repo_name:
522 442 """
523 443
524 444 try:
525 445 repo_id = Repository.get_by_repo_name(repo_name).repo_id
526 446 user_id = User.get_default_user().user_id
527 447 self.scm_model.toggle_following_repo(repo_id, user_id)
528 448 h.flash(_('Updated repository visibility in public journal'),
529 449 category='success')
530 450 Session().commit()
531 451 except Exception:
532 452 h.flash(_('An error occurred during setting this'
533 453 ' repository in public journal'),
534 454 category='error')
535 455
536 456 return redirect(url('edit_repo_advanced', repo_name=repo_name))
537 457
538 458 @HasRepoPermissionAllDecorator('repository.admin')
539 459 @auth.CSRFRequired()
540 460 def edit_advanced_fork(self, repo_name):
541 461 """
542 462 Mark given repository as a fork of another
543 463
544 464 :param repo_name:
545 465 """
546 466
547 467 new_fork_id = request.POST.get('id_fork_of')
548 468 try:
549 469
550 470 if new_fork_id and not new_fork_id.isdigit():
551 471 log.error('Given fork id %s is not an INT', new_fork_id)
552 472
553 473 fork_id = safe_int(new_fork_id)
554 474 repo = ScmModel().mark_as_fork(repo_name, fork_id,
555 475 c.rhodecode_user.username)
556 476 fork = repo.fork.repo_name if repo.fork else _('Nothing')
557 477 Session().commit()
558 478 h.flash(_('Marked repo %s as fork of %s') % (repo_name, fork),
559 479 category='success')
560 480 except RepositoryError as e:
561 481 log.exception("Repository Error occurred")
562 482 h.flash(str(e), category='error')
563 483 except Exception as e:
564 484 log.exception("Exception while editing fork")
565 485 h.flash(_('An error occurred during this operation'),
566 486 category='error')
567 487
568 488 return redirect(url('edit_repo_advanced', repo_name=repo_name))
569 489
570 490 @HasRepoPermissionAllDecorator('repository.admin')
571 491 @auth.CSRFRequired()
572 492 def edit_advanced_locking(self, repo_name):
573 493 """
574 494 Unlock repository when it is locked !
575 495
576 496 :param repo_name:
577 497 """
578 498 try:
579 499 repo = Repository.get_by_repo_name(repo_name)
580 500 if request.POST.get('set_lock'):
581 501 Repository.lock(repo, c.rhodecode_user.user_id,
582 502 lock_reason=Repository.LOCK_WEB)
583 503 h.flash(_('Locked repository'), category='success')
584 504 elif request.POST.get('set_unlock'):
585 505 Repository.unlock(repo)
586 506 h.flash(_('Unlocked repository'), category='success')
587 507 except Exception as e:
588 508 log.exception("Exception during unlocking")
589 509 h.flash(_('An error occurred during unlocking'),
590 510 category='error')
591 511 return redirect(url('edit_repo_advanced', repo_name=repo_name))
592 512
593 513 @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
594 514 @auth.CSRFRequired()
595 515 def toggle_locking(self, repo_name):
596 516 """
597 517 Toggle locking of repository by simple GET call to url
598 518
599 519 :param repo_name:
600 520 """
601 521
602 522 try:
603 523 repo = Repository.get_by_repo_name(repo_name)
604 524
605 525 if repo.enable_locking:
606 526 if repo.locked[0]:
607 527 Repository.unlock(repo)
608 528 action = _('Unlocked')
609 529 else:
610 530 Repository.lock(repo, c.rhodecode_user.user_id,
611 531 lock_reason=Repository.LOCK_WEB)
612 532 action = _('Locked')
613 533
614 534 h.flash(_('Repository has been %s') % action,
615 535 category='success')
616 536 except Exception:
617 537 log.exception("Exception during unlocking")
618 538 h.flash(_('An error occurred during unlocking'),
619 539 category='error')
620 540 return redirect(url('summary_home', repo_name=repo_name))
621 541
622 542 @HasRepoPermissionAllDecorator('repository.admin')
623 543 @auth.CSRFRequired()
624 544 def edit_caches(self, repo_name):
625 545 """PUT /{repo_name}/settings/caches: invalidate the repo caches."""
626 546 try:
627 547 ScmModel().mark_for_invalidation(repo_name, delete=True)
628 548 Session().commit()
629 549 h.flash(_('Cache invalidation successful'),
630 550 category='success')
631 551 except Exception:
632 552 log.exception("Exception during cache invalidation")
633 553 h.flash(_('An error occurred during cache invalidation'),
634 554 category='error')
635 555
636 556 return redirect(url('edit_repo_caches', repo_name=c.repo_name))
637 557
638 558 @HasRepoPermissionAllDecorator('repository.admin')
639 559 def edit_caches_form(self, repo_name):
640 560 """GET /repo_name/settings: Form to edit an existing item"""
641 # url('edit_repo', repo_name=ID)
642 561 c.repo_info = self._load_repo(repo_name)
643 562 c.active = 'caches'
644 563
645 564 return render('admin/repos/repo_edit.mako')
646 565
647 566 @HasRepoPermissionAllDecorator('repository.admin')
648 567 @auth.CSRFRequired()
649 568 def edit_remote(self, repo_name):
650 569 """PUT /{repo_name}/settings/remote: edit the repo remote."""
651 570 try:
652 571 ScmModel().pull_changes(repo_name, c.rhodecode_user.username)
653 572 h.flash(_('Pulled from remote location'), category='success')
654 573 except Exception:
655 574 log.exception("Exception during pull from remote")
656 575 h.flash(_('An error occurred during pull from remote location'),
657 576 category='error')
658 577 return redirect(url('edit_repo_remote', repo_name=c.repo_name))
659 578
660 579 @HasRepoPermissionAllDecorator('repository.admin')
661 580 def edit_remote_form(self, repo_name):
662 581 """GET /repo_name/settings: Form to edit an existing item"""
663 # url('edit_repo', repo_name=ID)
664 582 c.repo_info = self._load_repo(repo_name)
665 583 c.active = 'remote'
666 584
667 585 return render('admin/repos/repo_edit.mako')
668 586
669 587 @HasRepoPermissionAllDecorator('repository.admin')
670 588 @auth.CSRFRequired()
671 589 def edit_statistics(self, repo_name):
672 590 """PUT /{repo_name}/settings/statistics: reset the repo statistics."""
673 591 try:
674 592 RepoModel().delete_stats(repo_name)
675 593 Session().commit()
676 594 except Exception as e:
677 595 log.error(traceback.format_exc())
678 596 h.flash(_('An error occurred during deletion of repository stats'),
679 597 category='error')
680 598 return redirect(url('edit_repo_statistics', repo_name=c.repo_name))
681 599
682 600 @HasRepoPermissionAllDecorator('repository.admin')
683 601 def edit_statistics_form(self, repo_name):
684 602 """GET /repo_name/settings: Form to edit an existing item"""
685 # url('edit_repo', repo_name=ID)
686 603 c.repo_info = self._load_repo(repo_name)
687 604 repo = c.repo_info.scm_instance()
688 605
689 606 if c.repo_info.stats:
690 607 # this is on what revision we ended up so we add +1 for count
691 608 last_rev = c.repo_info.stats.stat_on_revision + 1
692 609 else:
693 610 last_rev = 0
694 611 c.stats_revision = last_rev
695 612
696 613 c.repo_last_rev = repo.count()
697 614
698 615 if last_rev == 0 or c.repo_last_rev == 0:
699 616 c.stats_percentage = 0
700 617 else:
701 618 c.stats_percentage = '%.2f' % ((float((last_rev)) / c.repo_last_rev) * 100)
702 619
703 620 c.active = 'statistics'
704 621
705 622 return render('admin/repos/repo_edit.mako')
706 623
707 624 @HasRepoPermissionAllDecorator('repository.admin')
708 625 @auth.CSRFRequired()
709 626 def repo_issuetracker_test(self, repo_name):
710 627 if request.is_xhr:
711 628 return h.urlify_commit_message(
712 629 request.POST.get('test_text', ''),
713 630 repo_name)
714 631 else:
715 632 raise HTTPBadRequest()
716 633
717 634 @HasRepoPermissionAllDecorator('repository.admin')
718 635 @auth.CSRFRequired()
719 636 def repo_issuetracker_delete(self, repo_name):
720 637 uid = request.POST.get('uid')
721 638 repo_settings = IssueTrackerSettingsModel(repo=repo_name)
722 639 try:
723 640 repo_settings.delete_entries(uid)
724 641 except Exception:
725 642 h.flash(_('Error occurred during deleting issue tracker entry'),
726 643 category='error')
727 644 else:
728 645 h.flash(_('Removed issue tracker entry'), category='success')
729 646 return redirect(url('repo_settings_issuetracker',
730 647 repo_name=repo_name))
731 648
732 649 def _update_patterns(self, form, repo_settings):
733 650 for uid in form['delete_patterns']:
734 651 repo_settings.delete_entries(uid)
735 652
736 653 for pattern in form['patterns']:
737 654 for setting, value, type_ in pattern:
738 655 sett = repo_settings.create_or_update_setting(
739 656 setting, value, type_)
740 657 Session().add(sett)
741 658
742 659 Session().commit()
743 660
744 661 @HasRepoPermissionAllDecorator('repository.admin')
745 662 @auth.CSRFRequired()
746 663 def repo_issuetracker_save(self, repo_name):
747 664 # Save inheritance
748 665 repo_settings = IssueTrackerSettingsModel(repo=repo_name)
749 666 inherited = (request.POST.get('inherit_global_issuetracker')
750 667 == "inherited")
751 668 repo_settings.inherit_global_settings = inherited
752 669 Session().commit()
753 670
754 671 form = IssueTrackerPatternsForm()().to_python(request.POST)
755 672 if form:
756 673 self._update_patterns(form, repo_settings)
757 674
758 675 h.flash(_('Updated issue tracker entries'), category='success')
759 676 return redirect(url('repo_settings_issuetracker',
760 677 repo_name=repo_name))
761 678
762 679 @HasRepoPermissionAllDecorator('repository.admin')
763 680 def repo_issuetracker(self, repo_name):
764 681 """GET /admin/settings/issue-tracker: All items in the collection"""
765 682 c.active = 'issuetracker'
766 683 c.data = 'data'
767 684 c.repo_info = self._load_repo(repo_name)
768 685
769 686 repo = Repository.get_by_repo_name(repo_name)
770 687 c.settings_model = IssueTrackerSettingsModel(repo=repo)
771 688 c.global_patterns = c.settings_model.get_global_settings()
772 689 c.repo_patterns = c.settings_model.get_repo_settings()
773 690
774 691 return render('admin/repos/repo_edit.mako')
775 692
776 693 @HasRepoPermissionAllDecorator('repository.admin')
777 694 def repo_settings_vcs(self, repo_name):
778 695 """GET /{repo_name}/settings/vcs/: All items in the collection"""
779 696
780 697 model = VcsSettingsModel(repo=repo_name)
781 698
782 699 c.active = 'vcs'
783 700 c.global_svn_branch_patterns = model.get_global_svn_branch_patterns()
784 701 c.global_svn_tag_patterns = model.get_global_svn_tag_patterns()
785 702 c.svn_branch_patterns = model.get_repo_svn_branch_patterns()
786 703 c.svn_tag_patterns = model.get_repo_svn_tag_patterns()
787 704 c.repo_info = self._load_repo(repo_name)
788 705 defaults = self._vcs_form_defaults(repo_name)
789 706 c.inherit_global_settings = defaults['inherit_global_settings']
790 707 c.labs_active = str2bool(
791 708 rhodecode.CONFIG.get('labs_settings_active', 'true'))
792 709
793 710 return htmlfill.render(
794 711 render('admin/repos/repo_edit.mako'),
795 712 defaults=defaults,
796 713 encoding="UTF-8",
797 714 force_defaults=False)
798 715
799 716 @HasRepoPermissionAllDecorator('repository.admin')
800 717 @auth.CSRFRequired()
801 718 def repo_settings_vcs_update(self, repo_name):
802 719 """POST /{repo_name}/settings/vcs/: All items in the collection"""
803 720 c.active = 'vcs'
804 721
805 722 model = VcsSettingsModel(repo=repo_name)
806 723 c.global_svn_branch_patterns = model.get_global_svn_branch_patterns()
807 724 c.global_svn_tag_patterns = model.get_global_svn_tag_patterns()
808 725 c.svn_branch_patterns = model.get_repo_svn_branch_patterns()
809 726 c.svn_tag_patterns = model.get_repo_svn_tag_patterns()
810 727 c.repo_info = self._load_repo(repo_name)
811 728 defaults = self._vcs_form_defaults(repo_name)
812 729 c.inherit_global_settings = defaults['inherit_global_settings']
813 730
814 731 application_form = RepoVcsSettingsForm(repo_name)()
815 732 try:
816 733 form_result = application_form.to_python(dict(request.POST))
817 734 except formencode.Invalid as errors:
818 735 h.flash(
819 736 _("Some form inputs contain invalid data."),
820 737 category='error')
821 738 return htmlfill.render(
822 739 render('admin/repos/repo_edit.mako'),
823 740 defaults=errors.value,
824 741 errors=errors.error_dict or {},
825 742 prefix_error=False,
826 743 encoding="UTF-8",
827 744 force_defaults=False
828 745 )
829 746
830 747 try:
831 748 inherit_global_settings = form_result['inherit_global_settings']
832 749 model.create_or_update_repo_settings(
833 750 form_result, inherit_global_settings=inherit_global_settings)
834 751 except Exception:
835 752 log.exception("Exception while updating settings")
836 753 h.flash(
837 754 _('Error occurred during updating repository VCS settings'),
838 755 category='error')
839 756 else:
840 757 Session().commit()
841 758 h.flash(_('Updated VCS settings'), category='success')
842 759 return redirect(url('repo_vcs_settings', repo_name=repo_name))
843 760
844 761 return htmlfill.render(
845 762 render('admin/repos/repo_edit.mako'),
846 763 defaults=self._vcs_form_defaults(repo_name),
847 764 encoding="UTF-8",
848 765 force_defaults=False)
849 766
850 767 @HasRepoPermissionAllDecorator('repository.admin')
851 768 @auth.CSRFRequired()
852 769 @jsonify
853 770 def repo_delete_svn_pattern(self, repo_name):
854 771 if not request.is_xhr:
855 772 return False
856 773
857 774 delete_pattern_id = request.POST.get('delete_svn_pattern')
858 775 model = VcsSettingsModel(repo=repo_name)
859 776 try:
860 777 model.delete_repo_svn_pattern(delete_pattern_id)
861 778 except SettingNotFound:
862 779 raise HTTPBadRequest()
863 780
864 781 Session().commit()
865 782 return True
866 783
867 784 def _vcs_form_defaults(self, repo_name):
868 785 model = VcsSettingsModel(repo=repo_name)
869 786 global_defaults = model.get_global_settings()
870 787
871 788 repo_defaults = {}
872 789 repo_defaults.update(global_defaults)
873 790 repo_defaults.update(model.get_repo_settings())
874 791
875 792 global_defaults = {
876 793 '{}_inherited'.format(k): global_defaults[k]
877 794 for k in global_defaults}
878 795
879 796 defaults = {
880 797 'inherit_global_settings': model.inherit_global_settings
881 798 }
882 799 defaults.update(global_defaults)
883 800 defaults.update(repo_defaults)
884 801 defaults.update({
885 802 'new_svn_branch': '',
886 803 'new_svn_tag': '',
887 804 })
888 805 return defaults
@@ -1,3986 +1,3986 b''
1 1 # -*- coding: utf-8 -*-
2 2
3 3 # Copyright (C) 2010-2017 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 re
26 26 import os
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.ext.declarative import declared_attr
40 40 from sqlalchemy.ext.hybrid import hybrid_property
41 41 from sqlalchemy.orm import (
42 42 relationship, joinedload, class_mapper, validates, aliased)
43 43 from sqlalchemy.sql.expression import true
44 44 from beaker.cache import cache_region
45 45 from zope.cachedescriptors.property import Lazy as LazyProperty
46 46
47 47 from pylons import url
48 48 from pylons.i18n.translation import lazy_ugettext as _
49 49
50 50 from rhodecode.lib.vcs import get_vcs_instance
51 51 from rhodecode.lib.vcs.backends.base import EmptyCommit, Reference
52 52 from rhodecode.lib.utils2 import (
53 53 str2bool, safe_str, get_commit_safe, safe_unicode, md5_safe,
54 54 time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,
55 55 glob2re, StrictAttributeDict, cleaned_uri)
56 56 from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType
57 57 from rhodecode.lib.ext_json import json
58 58 from rhodecode.lib.caching_query import FromCache
59 59 from rhodecode.lib.encrypt import AESCipher
60 60
61 61 from rhodecode.model.meta import Base, Session
62 62
63 63 URL_SEP = '/'
64 64 log = logging.getLogger(__name__)
65 65
66 66 # =============================================================================
67 67 # BASE CLASSES
68 68 # =============================================================================
69 69
70 70 # this is propagated from .ini file rhodecode.encrypted_values.secret or
71 71 # beaker.session.secret if first is not set.
72 72 # and initialized at environment.py
73 73 ENCRYPTION_KEY = None
74 74
75 75 # used to sort permissions by types, '#' used here is not allowed to be in
76 76 # usernames, and it's very early in sorted string.printable table.
77 77 PERMISSION_TYPE_SORT = {
78 78 'admin': '####',
79 79 'write': '###',
80 80 'read': '##',
81 81 'none': '#',
82 82 }
83 83
84 84
85 85 def display_sort(obj):
86 86 """
87 87 Sort function used to sort permissions in .permissions() function of
88 88 Repository, RepoGroup, UserGroup. Also it put the default user in front
89 89 of all other resources
90 90 """
91 91
92 92 if obj.username == User.DEFAULT_USER:
93 93 return '#####'
94 94 prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
95 95 return prefix + obj.username
96 96
97 97
98 98 def _hash_key(k):
99 99 return md5_safe(k)
100 100
101 101
102 102 class EncryptedTextValue(TypeDecorator):
103 103 """
104 104 Special column for encrypted long text data, use like::
105 105
106 106 value = Column("encrypted_value", EncryptedValue(), nullable=False)
107 107
108 108 This column is intelligent so if value is in unencrypted form it return
109 109 unencrypted form, but on save it always encrypts
110 110 """
111 111 impl = Text
112 112
113 113 def process_bind_param(self, value, dialect):
114 114 if not value:
115 115 return value
116 116 if value.startswith('enc$aes$') or value.startswith('enc$aes_hmac$'):
117 117 # protect against double encrypting if someone manually starts
118 118 # doing
119 119 raise ValueError('value needs to be in unencrypted format, ie. '
120 120 'not starting with enc$aes')
121 121 return 'enc$aes_hmac$%s' % AESCipher(
122 122 ENCRYPTION_KEY, hmac=True).encrypt(value)
123 123
124 124 def process_result_value(self, value, dialect):
125 125 import rhodecode
126 126
127 127 if not value:
128 128 return value
129 129
130 130 parts = value.split('$', 3)
131 131 if not len(parts) == 3:
132 132 # probably not encrypted values
133 133 return value
134 134 else:
135 135 if parts[0] != 'enc':
136 136 # parts ok but without our header ?
137 137 return value
138 138 enc_strict_mode = str2bool(rhodecode.CONFIG.get(
139 139 'rhodecode.encrypted_values.strict') or True)
140 140 # at that stage we know it's our encryption
141 141 if parts[1] == 'aes':
142 142 decrypted_data = AESCipher(ENCRYPTION_KEY).decrypt(parts[2])
143 143 elif parts[1] == 'aes_hmac':
144 144 decrypted_data = AESCipher(
145 145 ENCRYPTION_KEY, hmac=True,
146 146 strict_verification=enc_strict_mode).decrypt(parts[2])
147 147 else:
148 148 raise ValueError(
149 149 'Encryption type part is wrong, must be `aes` '
150 150 'or `aes_hmac`, got `%s` instead' % (parts[1]))
151 151 return decrypted_data
152 152
153 153
154 154 class BaseModel(object):
155 155 """
156 156 Base Model for all classes
157 157 """
158 158
159 159 @classmethod
160 160 def _get_keys(cls):
161 161 """return column names for this model """
162 162 return class_mapper(cls).c.keys()
163 163
164 164 def get_dict(self):
165 165 """
166 166 return dict with keys and values corresponding
167 167 to this model data """
168 168
169 169 d = {}
170 170 for k in self._get_keys():
171 171 d[k] = getattr(self, k)
172 172
173 173 # also use __json__() if present to get additional fields
174 174 _json_attr = getattr(self, '__json__', None)
175 175 if _json_attr:
176 176 # update with attributes from __json__
177 177 if callable(_json_attr):
178 178 _json_attr = _json_attr()
179 179 for k, val in _json_attr.iteritems():
180 180 d[k] = val
181 181 return d
182 182
183 183 def get_appstruct(self):
184 184 """return list with keys and values tuples corresponding
185 185 to this model data """
186 186
187 187 l = []
188 188 for k in self._get_keys():
189 189 l.append((k, getattr(self, k),))
190 190 return l
191 191
192 192 def populate_obj(self, populate_dict):
193 193 """populate model with data from given populate_dict"""
194 194
195 195 for k in self._get_keys():
196 196 if k in populate_dict:
197 197 setattr(self, k, populate_dict[k])
198 198
199 199 @classmethod
200 200 def query(cls):
201 201 return Session().query(cls)
202 202
203 203 @classmethod
204 204 def get(cls, id_):
205 205 if id_:
206 206 return cls.query().get(id_)
207 207
208 208 @classmethod
209 209 def get_or_404(cls, id_, pyramid_exc=False):
210 210 if pyramid_exc:
211 211 # NOTE(marcink): backward compat, once migration to pyramid
212 212 # this should only use pyramid exceptions
213 213 from pyramid.httpexceptions import HTTPNotFound
214 214 else:
215 215 from webob.exc import HTTPNotFound
216 216
217 217 try:
218 218 id_ = int(id_)
219 219 except (TypeError, ValueError):
220 220 raise HTTPNotFound
221 221
222 222 res = cls.query().get(id_)
223 223 if not res:
224 224 raise HTTPNotFound
225 225 return res
226 226
227 227 @classmethod
228 228 def getAll(cls):
229 229 # deprecated and left for backward compatibility
230 230 return cls.get_all()
231 231
232 232 @classmethod
233 233 def get_all(cls):
234 234 return cls.query().all()
235 235
236 236 @classmethod
237 237 def delete(cls, id_):
238 238 obj = cls.query().get(id_)
239 239 Session().delete(obj)
240 240
241 241 @classmethod
242 242 def identity_cache(cls, session, attr_name, value):
243 243 exist_in_session = []
244 244 for (item_cls, pkey), instance in session.identity_map.items():
245 245 if cls == item_cls and getattr(instance, attr_name) == value:
246 246 exist_in_session.append(instance)
247 247 if exist_in_session:
248 248 if len(exist_in_session) == 1:
249 249 return exist_in_session[0]
250 250 log.exception(
251 251 'multiple objects with attr %s and '
252 252 'value %s found with same name: %r',
253 253 attr_name, value, exist_in_session)
254 254
255 255 def __repr__(self):
256 256 if hasattr(self, '__unicode__'):
257 257 # python repr needs to return str
258 258 try:
259 259 return safe_str(self.__unicode__())
260 260 except UnicodeDecodeError:
261 261 pass
262 262 return '<DB:%s>' % (self.__class__.__name__)
263 263
264 264
265 265 class RhodeCodeSetting(Base, BaseModel):
266 266 __tablename__ = 'rhodecode_settings'
267 267 __table_args__ = (
268 268 UniqueConstraint('app_settings_name'),
269 269 {'extend_existing': True, 'mysql_engine': 'InnoDB',
270 270 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
271 271 )
272 272
273 273 SETTINGS_TYPES = {
274 274 'str': safe_str,
275 275 'int': safe_int,
276 276 'unicode': safe_unicode,
277 277 'bool': str2bool,
278 278 'list': functools.partial(aslist, sep=',')
279 279 }
280 280 DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions'
281 281 GLOBAL_CONF_KEY = 'app_settings'
282 282
283 283 app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
284 284 app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None)
285 285 _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None)
286 286 _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None)
287 287
288 288 def __init__(self, key='', val='', type='unicode'):
289 289 self.app_settings_name = key
290 290 self.app_settings_type = type
291 291 self.app_settings_value = val
292 292
293 293 @validates('_app_settings_value')
294 294 def validate_settings_value(self, key, val):
295 295 assert type(val) == unicode
296 296 return val
297 297
298 298 @hybrid_property
299 299 def app_settings_value(self):
300 300 v = self._app_settings_value
301 301 _type = self.app_settings_type
302 302 if _type:
303 303 _type = self.app_settings_type.split('.')[0]
304 304 # decode the encrypted value
305 305 if 'encrypted' in self.app_settings_type:
306 306 cipher = EncryptedTextValue()
307 307 v = safe_unicode(cipher.process_result_value(v, None))
308 308
309 309 converter = self.SETTINGS_TYPES.get(_type) or \
310 310 self.SETTINGS_TYPES['unicode']
311 311 return converter(v)
312 312
313 313 @app_settings_value.setter
314 314 def app_settings_value(self, val):
315 315 """
316 316 Setter that will always make sure we use unicode in app_settings_value
317 317
318 318 :param val:
319 319 """
320 320 val = safe_unicode(val)
321 321 # encode the encrypted value
322 322 if 'encrypted' in self.app_settings_type:
323 323 cipher = EncryptedTextValue()
324 324 val = safe_unicode(cipher.process_bind_param(val, None))
325 325 self._app_settings_value = val
326 326
327 327 @hybrid_property
328 328 def app_settings_type(self):
329 329 return self._app_settings_type
330 330
331 331 @app_settings_type.setter
332 332 def app_settings_type(self, val):
333 333 if val.split('.')[0] not in self.SETTINGS_TYPES:
334 334 raise Exception('type must be one of %s got %s'
335 335 % (self.SETTINGS_TYPES.keys(), val))
336 336 self._app_settings_type = val
337 337
338 338 def __unicode__(self):
339 339 return u"<%s('%s:%s[%s]')>" % (
340 340 self.__class__.__name__,
341 341 self.app_settings_name, self.app_settings_value,
342 342 self.app_settings_type
343 343 )
344 344
345 345
346 346 class RhodeCodeUi(Base, BaseModel):
347 347 __tablename__ = 'rhodecode_ui'
348 348 __table_args__ = (
349 349 UniqueConstraint('ui_key'),
350 350 {'extend_existing': True, 'mysql_engine': 'InnoDB',
351 351 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
352 352 )
353 353
354 354 HOOK_REPO_SIZE = 'changegroup.repo_size'
355 355 # HG
356 356 HOOK_PRE_PULL = 'preoutgoing.pre_pull'
357 357 HOOK_PULL = 'outgoing.pull_logger'
358 358 HOOK_PRE_PUSH = 'prechangegroup.pre_push'
359 359 HOOK_PRETX_PUSH = 'pretxnchangegroup.pre_push'
360 360 HOOK_PUSH = 'changegroup.push_logger'
361 361
362 362 # TODO: johbo: Unify way how hooks are configured for git and hg,
363 363 # git part is currently hardcoded.
364 364
365 365 # SVN PATTERNS
366 366 SVN_BRANCH_ID = 'vcs_svn_branch'
367 367 SVN_TAG_ID = 'vcs_svn_tag'
368 368
369 369 ui_id = Column(
370 370 "ui_id", Integer(), nullable=False, unique=True, default=None,
371 371 primary_key=True)
372 372 ui_section = Column(
373 373 "ui_section", String(255), nullable=True, unique=None, default=None)
374 374 ui_key = Column(
375 375 "ui_key", String(255), nullable=True, unique=None, default=None)
376 376 ui_value = Column(
377 377 "ui_value", String(255), nullable=True, unique=None, default=None)
378 378 ui_active = Column(
379 379 "ui_active", Boolean(), nullable=True, unique=None, default=True)
380 380
381 381 def __repr__(self):
382 382 return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section,
383 383 self.ui_key, self.ui_value)
384 384
385 385
386 386 class RepoRhodeCodeSetting(Base, BaseModel):
387 387 __tablename__ = 'repo_rhodecode_settings'
388 388 __table_args__ = (
389 389 UniqueConstraint(
390 390 'app_settings_name', 'repository_id',
391 391 name='uq_repo_rhodecode_setting_name_repo_id'),
392 392 {'extend_existing': True, 'mysql_engine': 'InnoDB',
393 393 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
394 394 )
395 395
396 396 repository_id = Column(
397 397 "repository_id", Integer(), ForeignKey('repositories.repo_id'),
398 398 nullable=False)
399 399 app_settings_id = Column(
400 400 "app_settings_id", Integer(), nullable=False, unique=True,
401 401 default=None, primary_key=True)
402 402 app_settings_name = Column(
403 403 "app_settings_name", String(255), nullable=True, unique=None,
404 404 default=None)
405 405 _app_settings_value = Column(
406 406 "app_settings_value", String(4096), nullable=True, unique=None,
407 407 default=None)
408 408 _app_settings_type = Column(
409 409 "app_settings_type", String(255), nullable=True, unique=None,
410 410 default=None)
411 411
412 412 repository = relationship('Repository')
413 413
414 414 def __init__(self, repository_id, key='', val='', type='unicode'):
415 415 self.repository_id = repository_id
416 416 self.app_settings_name = key
417 417 self.app_settings_type = type
418 418 self.app_settings_value = val
419 419
420 420 @validates('_app_settings_value')
421 421 def validate_settings_value(self, key, val):
422 422 assert type(val) == unicode
423 423 return val
424 424
425 425 @hybrid_property
426 426 def app_settings_value(self):
427 427 v = self._app_settings_value
428 428 type_ = self.app_settings_type
429 429 SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
430 430 converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode']
431 431 return converter(v)
432 432
433 433 @app_settings_value.setter
434 434 def app_settings_value(self, val):
435 435 """
436 436 Setter that will always make sure we use unicode in app_settings_value
437 437
438 438 :param val:
439 439 """
440 440 self._app_settings_value = safe_unicode(val)
441 441
442 442 @hybrid_property
443 443 def app_settings_type(self):
444 444 return self._app_settings_type
445 445
446 446 @app_settings_type.setter
447 447 def app_settings_type(self, val):
448 448 SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
449 449 if val not in SETTINGS_TYPES:
450 450 raise Exception('type must be one of %s got %s'
451 451 % (SETTINGS_TYPES.keys(), val))
452 452 self._app_settings_type = val
453 453
454 454 def __unicode__(self):
455 455 return u"<%s('%s:%s:%s[%s]')>" % (
456 456 self.__class__.__name__, self.repository.repo_name,
457 457 self.app_settings_name, self.app_settings_value,
458 458 self.app_settings_type
459 459 )
460 460
461 461
462 462 class RepoRhodeCodeUi(Base, BaseModel):
463 463 __tablename__ = 'repo_rhodecode_ui'
464 464 __table_args__ = (
465 465 UniqueConstraint(
466 466 'repository_id', 'ui_section', 'ui_key',
467 467 name='uq_repo_rhodecode_ui_repository_id_section_key'),
468 468 {'extend_existing': True, 'mysql_engine': 'InnoDB',
469 469 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
470 470 )
471 471
472 472 repository_id = Column(
473 473 "repository_id", Integer(), ForeignKey('repositories.repo_id'),
474 474 nullable=False)
475 475 ui_id = Column(
476 476 "ui_id", Integer(), nullable=False, unique=True, default=None,
477 477 primary_key=True)
478 478 ui_section = Column(
479 479 "ui_section", String(255), nullable=True, unique=None, default=None)
480 480 ui_key = Column(
481 481 "ui_key", String(255), nullable=True, unique=None, default=None)
482 482 ui_value = Column(
483 483 "ui_value", String(255), nullable=True, unique=None, default=None)
484 484 ui_active = Column(
485 485 "ui_active", Boolean(), nullable=True, unique=None, default=True)
486 486
487 487 repository = relationship('Repository')
488 488
489 489 def __repr__(self):
490 490 return '<%s[%s:%s]%s=>%s]>' % (
491 491 self.__class__.__name__, self.repository.repo_name,
492 492 self.ui_section, self.ui_key, self.ui_value)
493 493
494 494
495 495 class User(Base, BaseModel):
496 496 __tablename__ = 'users'
497 497 __table_args__ = (
498 498 UniqueConstraint('username'), UniqueConstraint('email'),
499 499 Index('u_username_idx', 'username'),
500 500 Index('u_email_idx', 'email'),
501 501 {'extend_existing': True, 'mysql_engine': 'InnoDB',
502 502 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
503 503 )
504 504 DEFAULT_USER = 'default'
505 505 DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org'
506 506 DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}'
507 507
508 508 user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
509 509 username = Column("username", String(255), nullable=True, unique=None, default=None)
510 510 password = Column("password", String(255), nullable=True, unique=None, default=None)
511 511 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
512 512 admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)
513 513 name = Column("firstname", String(255), nullable=True, unique=None, default=None)
514 514 lastname = Column("lastname", String(255), nullable=True, unique=None, default=None)
515 515 _email = Column("email", String(255), nullable=True, unique=None, default=None)
516 516 last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)
517 517 last_activity = Column('last_activity', DateTime(timezone=False), nullable=True, unique=None, default=None)
518 518
519 519 extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None)
520 520 extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None)
521 521 _api_key = Column("api_key", String(255), nullable=True, unique=None, default=None)
522 522 inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
523 523 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
524 524 _user_data = Column("user_data", LargeBinary(), nullable=True) # JSON data
525 525
526 526 user_log = relationship('UserLog')
527 527 user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')
528 528
529 529 repositories = relationship('Repository')
530 530 repository_groups = relationship('RepoGroup')
531 531 user_groups = relationship('UserGroup')
532 532
533 533 user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')
534 534 followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all')
535 535
536 536 repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')
537 537 repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')
538 538 user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all')
539 539
540 540 group_member = relationship('UserGroupMember', cascade='all')
541 541
542 542 notifications = relationship('UserNotification', cascade='all')
543 543 # notifications assigned to this user
544 544 user_created_notifications = relationship('Notification', cascade='all')
545 545 # comments created by this user
546 546 user_comments = relationship('ChangesetComment', cascade='all')
547 547 # user profile extra info
548 548 user_emails = relationship('UserEmailMap', cascade='all')
549 549 user_ip_map = relationship('UserIpMap', cascade='all')
550 550 user_auth_tokens = relationship('UserApiKeys', cascade='all')
551 551 # gists
552 552 user_gists = relationship('Gist', cascade='all')
553 553 # user pull requests
554 554 user_pull_requests = relationship('PullRequest', cascade='all')
555 555 # external identities
556 556 extenal_identities = relationship(
557 557 'ExternalIdentity',
558 558 primaryjoin="User.user_id==ExternalIdentity.local_user_id",
559 559 cascade='all')
560 560
561 561 def __unicode__(self):
562 562 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
563 563 self.user_id, self.username)
564 564
565 565 @hybrid_property
566 566 def email(self):
567 567 return self._email
568 568
569 569 @email.setter
570 570 def email(self, val):
571 571 self._email = val.lower() if val else None
572 572
573 573 @hybrid_property
574 574 def api_key(self):
575 575 """
576 576 Fetch if exist an auth-token with role ALL connected to this user
577 577 """
578 578 user_auth_token = UserApiKeys.query()\
579 579 .filter(UserApiKeys.user_id == self.user_id)\
580 580 .filter(or_(UserApiKeys.expires == -1,
581 581 UserApiKeys.expires >= time.time()))\
582 582 .filter(UserApiKeys.role == UserApiKeys.ROLE_ALL).first()
583 583 if user_auth_token:
584 584 user_auth_token = user_auth_token.api_key
585 585
586 586 return user_auth_token
587 587
588 588 @api_key.setter
589 589 def api_key(self, val):
590 590 # don't allow to set API key this is deprecated for now
591 591 self._api_key = None
592 592
593 593 @property
594 594 def firstname(self):
595 595 # alias for future
596 596 return self.name
597 597
598 598 @property
599 599 def emails(self):
600 600 other = UserEmailMap.query().filter(UserEmailMap.user==self).all()
601 601 return [self.email] + [x.email for x in other]
602 602
603 603 @property
604 604 def auth_tokens(self):
605 605 return [x.api_key for x in self.extra_auth_tokens]
606 606
607 607 @property
608 608 def extra_auth_tokens(self):
609 609 return UserApiKeys.query().filter(UserApiKeys.user == self).all()
610 610
611 611 @property
612 612 def feed_token(self):
613 613 return self.get_feed_token()
614 614
615 615 def get_feed_token(self):
616 616 feed_tokens = UserApiKeys.query()\
617 617 .filter(UserApiKeys.user == self)\
618 618 .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED)\
619 619 .all()
620 620 if feed_tokens:
621 621 return feed_tokens[0].api_key
622 622 return 'NO_FEED_TOKEN_AVAILABLE'
623 623
624 624 @classmethod
625 625 def extra_valid_auth_tokens(cls, user, role=None):
626 626 tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\
627 627 .filter(or_(UserApiKeys.expires == -1,
628 628 UserApiKeys.expires >= time.time()))
629 629 if role:
630 630 tokens = tokens.filter(or_(UserApiKeys.role == role,
631 631 UserApiKeys.role == UserApiKeys.ROLE_ALL))
632 632 return tokens.all()
633 633
634 634 def authenticate_by_token(self, auth_token, roles=None, scope_repo_id=None):
635 635 from rhodecode.lib import auth
636 636
637 637 log.debug('Trying to authenticate user: %s via auth-token, '
638 638 'and roles: %s', self, roles)
639 639
640 640 if not auth_token:
641 641 return False
642 642
643 643 crypto_backend = auth.crypto_backend()
644 644
645 645 roles = (roles or []) + [UserApiKeys.ROLE_ALL]
646 646 tokens_q = UserApiKeys.query()\
647 647 .filter(UserApiKeys.user_id == self.user_id)\
648 648 .filter(or_(UserApiKeys.expires == -1,
649 649 UserApiKeys.expires >= time.time()))
650 650
651 651 tokens_q = tokens_q.filter(UserApiKeys.role.in_(roles))
652 652
653 653 plain_tokens = []
654 654 hash_tokens = []
655 655
656 656 for token in tokens_q.all():
657 657 # verify scope first
658 658 if token.repo_id:
659 659 # token has a scope, we need to verify it
660 660 if scope_repo_id != token.repo_id:
661 661 log.debug(
662 662 'Scope mismatch: token has a set repo scope: %s, '
663 663 'and calling scope is:%s, skipping further checks',
664 664 token.repo, scope_repo_id)
665 665 # token has a scope, and it doesn't match, skip token
666 666 continue
667 667
668 668 if token.api_key.startswith(crypto_backend.ENC_PREF):
669 669 hash_tokens.append(token.api_key)
670 670 else:
671 671 plain_tokens.append(token.api_key)
672 672
673 673 is_plain_match = auth_token in plain_tokens
674 674 if is_plain_match:
675 675 return True
676 676
677 677 for hashed in hash_tokens:
678 678 # TODO(marcink): this is expensive to calculate, but most secure
679 679 match = crypto_backend.hash_check(auth_token, hashed)
680 680 if match:
681 681 return True
682 682
683 683 return False
684 684
685 685 @property
686 686 def ip_addresses(self):
687 687 ret = UserIpMap.query().filter(UserIpMap.user == self).all()
688 688 return [x.ip_addr for x in ret]
689 689
690 690 @property
691 691 def username_and_name(self):
692 692 return '%s (%s %s)' % (self.username, self.firstname, self.lastname)
693 693
694 694 @property
695 695 def username_or_name_or_email(self):
696 696 full_name = self.full_name if self.full_name is not ' ' else None
697 697 return self.username or full_name or self.email
698 698
699 699 @property
700 700 def full_name(self):
701 701 return '%s %s' % (self.firstname, self.lastname)
702 702
703 703 @property
704 704 def full_name_or_username(self):
705 705 return ('%s %s' % (self.firstname, self.lastname)
706 706 if (self.firstname and self.lastname) else self.username)
707 707
708 708 @property
709 709 def full_contact(self):
710 710 return '%s %s <%s>' % (self.firstname, self.lastname, self.email)
711 711
712 712 @property
713 713 def short_contact(self):
714 714 return '%s %s' % (self.firstname, self.lastname)
715 715
716 716 @property
717 717 def is_admin(self):
718 718 return self.admin
719 719
720 720 @property
721 721 def AuthUser(self):
722 722 """
723 723 Returns instance of AuthUser for this user
724 724 """
725 725 from rhodecode.lib.auth import AuthUser
726 726 return AuthUser(user_id=self.user_id, username=self.username)
727 727
728 728 @hybrid_property
729 729 def user_data(self):
730 730 if not self._user_data:
731 731 return {}
732 732
733 733 try:
734 734 return json.loads(self._user_data)
735 735 except TypeError:
736 736 return {}
737 737
738 738 @user_data.setter
739 739 def user_data(self, val):
740 740 if not isinstance(val, dict):
741 741 raise Exception('user_data must be dict, got %s' % type(val))
742 742 try:
743 743 self._user_data = json.dumps(val)
744 744 except Exception:
745 745 log.error(traceback.format_exc())
746 746
747 747 @classmethod
748 748 def get_by_username(cls, username, case_insensitive=False,
749 749 cache=False, identity_cache=False):
750 750 session = Session()
751 751
752 752 if case_insensitive:
753 753 q = cls.query().filter(
754 754 func.lower(cls.username) == func.lower(username))
755 755 else:
756 756 q = cls.query().filter(cls.username == username)
757 757
758 758 if cache:
759 759 if identity_cache:
760 760 val = cls.identity_cache(session, 'username', username)
761 761 if val:
762 762 return val
763 763 else:
764 764 q = q.options(
765 765 FromCache("sql_cache_short",
766 766 "get_user_by_name_%s" % _hash_key(username)))
767 767
768 768 return q.scalar()
769 769
770 770 @classmethod
771 771 def get_by_auth_token(cls, auth_token, cache=False):
772 772 q = UserApiKeys.query()\
773 773 .filter(UserApiKeys.api_key == auth_token)\
774 774 .filter(or_(UserApiKeys.expires == -1,
775 775 UserApiKeys.expires >= time.time()))
776 776 if cache:
777 777 q = q.options(FromCache("sql_cache_short",
778 778 "get_auth_token_%s" % auth_token))
779 779
780 780 match = q.first()
781 781 if match:
782 782 return match.user
783 783
784 784 @classmethod
785 785 def get_by_email(cls, email, case_insensitive=False, cache=False):
786 786
787 787 if case_insensitive:
788 788 q = cls.query().filter(func.lower(cls.email) == func.lower(email))
789 789
790 790 else:
791 791 q = cls.query().filter(cls.email == email)
792 792
793 793 if cache:
794 794 q = q.options(FromCache("sql_cache_short",
795 795 "get_email_key_%s" % _hash_key(email)))
796 796
797 797 ret = q.scalar()
798 798 if ret is None:
799 799 q = UserEmailMap.query()
800 800 # try fetching in alternate email map
801 801 if case_insensitive:
802 802 q = q.filter(func.lower(UserEmailMap.email) == func.lower(email))
803 803 else:
804 804 q = q.filter(UserEmailMap.email == email)
805 805 q = q.options(joinedload(UserEmailMap.user))
806 806 if cache:
807 807 q = q.options(FromCache("sql_cache_short",
808 808 "get_email_map_key_%s" % email))
809 809 ret = getattr(q.scalar(), 'user', None)
810 810
811 811 return ret
812 812
813 813 @classmethod
814 814 def get_from_cs_author(cls, author):
815 815 """
816 816 Tries to get User objects out of commit author string
817 817
818 818 :param author:
819 819 """
820 820 from rhodecode.lib.helpers import email, author_name
821 821 # Valid email in the attribute passed, see if they're in the system
822 822 _email = email(author)
823 823 if _email:
824 824 user = cls.get_by_email(_email, case_insensitive=True)
825 825 if user:
826 826 return user
827 827 # Maybe we can match by username?
828 828 _author = author_name(author)
829 829 user = cls.get_by_username(_author, case_insensitive=True)
830 830 if user:
831 831 return user
832 832
833 833 def update_userdata(self, **kwargs):
834 834 usr = self
835 835 old = usr.user_data
836 836 old.update(**kwargs)
837 837 usr.user_data = old
838 838 Session().add(usr)
839 839 log.debug('updated userdata with ', kwargs)
840 840
841 841 def update_lastlogin(self):
842 842 """Update user lastlogin"""
843 843 self.last_login = datetime.datetime.now()
844 844 Session().add(self)
845 845 log.debug('updated user %s lastlogin', self.username)
846 846
847 847 def update_lastactivity(self):
848 848 """Update user lastactivity"""
849 849 self.last_activity = datetime.datetime.now()
850 850 Session().add(self)
851 851 log.debug('updated user %s lastactivity', self.username)
852 852
853 853 def update_password(self, new_password):
854 854 from rhodecode.lib.auth import get_crypt_password
855 855
856 856 self.password = get_crypt_password(new_password)
857 857 Session().add(self)
858 858
859 859 @classmethod
860 860 def get_first_super_admin(cls):
861 861 user = User.query().filter(User.admin == true()).first()
862 862 if user is None:
863 863 raise Exception('FATAL: Missing administrative account!')
864 864 return user
865 865
866 866 @classmethod
867 867 def get_all_super_admins(cls):
868 868 """
869 869 Returns all admin accounts sorted by username
870 870 """
871 871 return User.query().filter(User.admin == true())\
872 872 .order_by(User.username.asc()).all()
873 873
874 874 @classmethod
875 875 def get_default_user(cls, cache=False):
876 876 user = User.get_by_username(User.DEFAULT_USER, cache=cache)
877 877 if user is None:
878 878 raise Exception('FATAL: Missing default account!')
879 879 return user
880 880
881 881 def _get_default_perms(self, user, suffix=''):
882 882 from rhodecode.model.permission import PermissionModel
883 883 return PermissionModel().get_default_perms(user.user_perms, suffix)
884 884
885 885 def get_default_perms(self, suffix=''):
886 886 return self._get_default_perms(self, suffix)
887 887
888 888 def get_api_data(self, include_secrets=False, details='full'):
889 889 """
890 890 Common function for generating user related data for API
891 891
892 892 :param include_secrets: By default secrets in the API data will be replaced
893 893 by a placeholder value to prevent exposing this data by accident. In case
894 894 this data shall be exposed, set this flag to ``True``.
895 895
896 896 :param details: details can be 'basic|full' basic gives only a subset of
897 897 the available user information that includes user_id, name and emails.
898 898 """
899 899 user = self
900 900 user_data = self.user_data
901 901 data = {
902 902 'user_id': user.user_id,
903 903 'username': user.username,
904 904 'firstname': user.name,
905 905 'lastname': user.lastname,
906 906 'email': user.email,
907 907 'emails': user.emails,
908 908 }
909 909 if details == 'basic':
910 910 return data
911 911
912 912 api_key_length = 40
913 913 api_key_replacement = '*' * api_key_length
914 914
915 915 extras = {
916 916 'api_keys': [api_key_replacement],
917 917 'auth_tokens': [api_key_replacement],
918 918 'active': user.active,
919 919 'admin': user.admin,
920 920 'extern_type': user.extern_type,
921 921 'extern_name': user.extern_name,
922 922 'last_login': user.last_login,
923 923 'last_activity': user.last_activity,
924 924 'ip_addresses': user.ip_addresses,
925 925 'language': user_data.get('language')
926 926 }
927 927 data.update(extras)
928 928
929 929 if include_secrets:
930 930 data['api_keys'] = user.auth_tokens
931 931 data['auth_tokens'] = user.extra_auth_tokens
932 932 return data
933 933
934 934 def __json__(self):
935 935 data = {
936 936 'full_name': self.full_name,
937 937 'full_name_or_username': self.full_name_or_username,
938 938 'short_contact': self.short_contact,
939 939 'full_contact': self.full_contact,
940 940 }
941 941 data.update(self.get_api_data())
942 942 return data
943 943
944 944
945 945 class UserApiKeys(Base, BaseModel):
946 946 __tablename__ = 'user_api_keys'
947 947 __table_args__ = (
948 948 Index('uak_api_key_idx', 'api_key'),
949 949 Index('uak_api_key_expires_idx', 'api_key', 'expires'),
950 950 UniqueConstraint('api_key'),
951 951 {'extend_existing': True, 'mysql_engine': 'InnoDB',
952 952 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
953 953 )
954 954 __mapper_args__ = {}
955 955
956 956 # ApiKey role
957 957 ROLE_ALL = 'token_role_all'
958 958 ROLE_HTTP = 'token_role_http'
959 959 ROLE_VCS = 'token_role_vcs'
960 960 ROLE_API = 'token_role_api'
961 961 ROLE_FEED = 'token_role_feed'
962 962 ROLE_PASSWORD_RESET = 'token_password_reset'
963 963
964 964 ROLES = [ROLE_ALL, ROLE_HTTP, ROLE_VCS, ROLE_API, ROLE_FEED]
965 965
966 966 user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
967 967 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
968 968 api_key = Column("api_key", String(255), nullable=False, unique=True)
969 969 description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
970 970 expires = Column('expires', Float(53), nullable=False)
971 971 role = Column('role', String(255), nullable=True)
972 972 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
973 973
974 974 # scope columns
975 975 repo_id = Column(
976 976 'repo_id', Integer(), ForeignKey('repositories.repo_id'),
977 977 nullable=True, unique=None, default=None)
978 978 repo = relationship('Repository', lazy='joined')
979 979
980 980 repo_group_id = Column(
981 981 'repo_group_id', Integer(), ForeignKey('groups.group_id'),
982 982 nullable=True, unique=None, default=None)
983 983 repo_group = relationship('RepoGroup', lazy='joined')
984 984
985 985 user = relationship('User', lazy='joined')
986 986
987 987 def __unicode__(self):
988 988 return u"<%s('%s')>" % (self.__class__.__name__, self.role)
989 989
990 990 def __json__(self):
991 991 data = {
992 992 'auth_token': self.api_key,
993 993 'role': self.role,
994 994 'scope': self.scope_humanized,
995 995 'expired': self.expired
996 996 }
997 997 return data
998 998
999 999 @property
1000 1000 def expired(self):
1001 1001 if self.expires == -1:
1002 1002 return False
1003 1003 return time.time() > self.expires
1004 1004
1005 1005 @classmethod
1006 1006 def _get_role_name(cls, role):
1007 1007 return {
1008 1008 cls.ROLE_ALL: _('all'),
1009 1009 cls.ROLE_HTTP: _('http/web interface'),
1010 1010 cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'),
1011 1011 cls.ROLE_API: _('api calls'),
1012 1012 cls.ROLE_FEED: _('feed access'),
1013 1013 }.get(role, role)
1014 1014
1015 1015 @property
1016 1016 def role_humanized(self):
1017 1017 return self._get_role_name(self.role)
1018 1018
1019 1019 def _get_scope(self):
1020 1020 if self.repo:
1021 1021 return repr(self.repo)
1022 1022 if self.repo_group:
1023 1023 return repr(self.repo_group) + ' (recursive)'
1024 1024 return 'global'
1025 1025
1026 1026 @property
1027 1027 def scope_humanized(self):
1028 1028 return self._get_scope()
1029 1029
1030 1030
1031 1031 class UserEmailMap(Base, BaseModel):
1032 1032 __tablename__ = 'user_email_map'
1033 1033 __table_args__ = (
1034 1034 Index('uem_email_idx', 'email'),
1035 1035 UniqueConstraint('email'),
1036 1036 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1037 1037 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
1038 1038 )
1039 1039 __mapper_args__ = {}
1040 1040
1041 1041 email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1042 1042 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1043 1043 _email = Column("email", String(255), nullable=True, unique=False, default=None)
1044 1044 user = relationship('User', lazy='joined')
1045 1045
1046 1046 @validates('_email')
1047 1047 def validate_email(self, key, email):
1048 1048 # check if this email is not main one
1049 1049 main_email = Session().query(User).filter(User.email == email).scalar()
1050 1050 if main_email is not None:
1051 1051 raise AttributeError('email %s is present is user table' % email)
1052 1052 return email
1053 1053
1054 1054 @hybrid_property
1055 1055 def email(self):
1056 1056 return self._email
1057 1057
1058 1058 @email.setter
1059 1059 def email(self, val):
1060 1060 self._email = val.lower() if val else None
1061 1061
1062 1062
1063 1063 class UserIpMap(Base, BaseModel):
1064 1064 __tablename__ = 'user_ip_map'
1065 1065 __table_args__ = (
1066 1066 UniqueConstraint('user_id', 'ip_addr'),
1067 1067 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1068 1068 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
1069 1069 )
1070 1070 __mapper_args__ = {}
1071 1071
1072 1072 ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1073 1073 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1074 1074 ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None)
1075 1075 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
1076 1076 description = Column("description", String(10000), nullable=True, unique=None, default=None)
1077 1077 user = relationship('User', lazy='joined')
1078 1078
1079 1079 @classmethod
1080 1080 def _get_ip_range(cls, ip_addr):
1081 1081 net = ipaddress.ip_network(ip_addr, strict=False)
1082 1082 return [str(net.network_address), str(net.broadcast_address)]
1083 1083
1084 1084 def __json__(self):
1085 1085 return {
1086 1086 'ip_addr': self.ip_addr,
1087 1087 'ip_range': self._get_ip_range(self.ip_addr),
1088 1088 }
1089 1089
1090 1090 def __unicode__(self):
1091 1091 return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,
1092 1092 self.user_id, self.ip_addr)
1093 1093
1094 1094
1095 1095 class UserLog(Base, BaseModel):
1096 1096 __tablename__ = 'user_logs'
1097 1097 __table_args__ = (
1098 1098 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1099 1099 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1100 1100 )
1101 1101 VERSION_1 = 'v1'
1102 1102 VERSION_2 = 'v2'
1103 1103 VERSIONS = [VERSION_1, VERSION_2]
1104 1104
1105 1105 user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1106 1106 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1107 1107 username = Column("username", String(255), nullable=True, unique=None, default=None)
1108 1108 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True)
1109 1109 repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None)
1110 1110 user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None)
1111 1111 action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None)
1112 1112 action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)
1113 1113
1114 1114 version = Column("version", String(255), nullable=True, default=VERSION_1)
1115 1115 user_data = Column('user_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
1116 1116 action_data = Column('action_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
1117 1117
1118 1118 def __unicode__(self):
1119 1119 return u"<%s('id:%s:%s')>" % (
1120 1120 self.__class__.__name__, self.repository_name, self.action)
1121 1121
1122 1122 def __json__(self):
1123 1123 return {
1124 1124 'user_id': self.user_id,
1125 1125 'username': self.username,
1126 1126 'repository_id': self.repository_id,
1127 1127 'repository_name': self.repository_name,
1128 1128 'user_ip': self.user_ip,
1129 1129 'action_date': self.action_date,
1130 1130 'action': self.action,
1131 1131 }
1132 1132
1133 1133 @property
1134 1134 def action_as_day(self):
1135 1135 return datetime.date(*self.action_date.timetuple()[:3])
1136 1136
1137 1137 user = relationship('User')
1138 1138 repository = relationship('Repository', cascade='')
1139 1139
1140 1140
1141 1141 class UserGroup(Base, BaseModel):
1142 1142 __tablename__ = 'users_groups'
1143 1143 __table_args__ = (
1144 1144 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1145 1145 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1146 1146 )
1147 1147
1148 1148 users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1149 1149 users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None)
1150 1150 user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None)
1151 1151 users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
1152 1152 inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
1153 1153 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
1154 1154 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1155 1155 _group_data = Column("group_data", LargeBinary(), nullable=True) # JSON data
1156 1156
1157 1157 members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
1158 1158 users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
1159 1159 users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
1160 1160 users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
1161 1161 user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all')
1162 1162 user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all')
1163 1163
1164 1164 user = relationship('User')
1165 1165
1166 1166 @hybrid_property
1167 1167 def group_data(self):
1168 1168 if not self._group_data:
1169 1169 return {}
1170 1170
1171 1171 try:
1172 1172 return json.loads(self._group_data)
1173 1173 except TypeError:
1174 1174 return {}
1175 1175
1176 1176 @group_data.setter
1177 1177 def group_data(self, val):
1178 1178 try:
1179 1179 self._group_data = json.dumps(val)
1180 1180 except Exception:
1181 1181 log.error(traceback.format_exc())
1182 1182
1183 1183 def __unicode__(self):
1184 1184 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
1185 1185 self.users_group_id,
1186 1186 self.users_group_name)
1187 1187
1188 1188 @classmethod
1189 1189 def get_by_group_name(cls, group_name, cache=False,
1190 1190 case_insensitive=False):
1191 1191 if case_insensitive:
1192 1192 q = cls.query().filter(func.lower(cls.users_group_name) ==
1193 1193 func.lower(group_name))
1194 1194
1195 1195 else:
1196 1196 q = cls.query().filter(cls.users_group_name == group_name)
1197 1197 if cache:
1198 1198 q = q.options(FromCache(
1199 1199 "sql_cache_short",
1200 1200 "get_group_%s" % _hash_key(group_name)))
1201 1201 return q.scalar()
1202 1202
1203 1203 @classmethod
1204 1204 def get(cls, user_group_id, cache=False):
1205 1205 user_group = cls.query()
1206 1206 if cache:
1207 1207 user_group = user_group.options(FromCache("sql_cache_short",
1208 1208 "get_users_group_%s" % user_group_id))
1209 1209 return user_group.get(user_group_id)
1210 1210
1211 1211 def permissions(self, with_admins=True, with_owner=True):
1212 1212 q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self)
1213 1213 q = q.options(joinedload(UserUserGroupToPerm.user_group),
1214 1214 joinedload(UserUserGroupToPerm.user),
1215 1215 joinedload(UserUserGroupToPerm.permission),)
1216 1216
1217 1217 # get owners and admins and permissions. We do a trick of re-writing
1218 1218 # objects from sqlalchemy to named-tuples due to sqlalchemy session
1219 1219 # has a global reference and changing one object propagates to all
1220 1220 # others. This means if admin is also an owner admin_row that change
1221 1221 # would propagate to both objects
1222 1222 perm_rows = []
1223 1223 for _usr in q.all():
1224 1224 usr = AttributeDict(_usr.user.get_dict())
1225 1225 usr.permission = _usr.permission.permission_name
1226 1226 perm_rows.append(usr)
1227 1227
1228 1228 # filter the perm rows by 'default' first and then sort them by
1229 1229 # admin,write,read,none permissions sorted again alphabetically in
1230 1230 # each group
1231 1231 perm_rows = sorted(perm_rows, key=display_sort)
1232 1232
1233 1233 _admin_perm = 'usergroup.admin'
1234 1234 owner_row = []
1235 1235 if with_owner:
1236 1236 usr = AttributeDict(self.user.get_dict())
1237 1237 usr.owner_row = True
1238 1238 usr.permission = _admin_perm
1239 1239 owner_row.append(usr)
1240 1240
1241 1241 super_admin_rows = []
1242 1242 if with_admins:
1243 1243 for usr in User.get_all_super_admins():
1244 1244 # if this admin is also owner, don't double the record
1245 1245 if usr.user_id == owner_row[0].user_id:
1246 1246 owner_row[0].admin_row = True
1247 1247 else:
1248 1248 usr = AttributeDict(usr.get_dict())
1249 1249 usr.admin_row = True
1250 1250 usr.permission = _admin_perm
1251 1251 super_admin_rows.append(usr)
1252 1252
1253 1253 return super_admin_rows + owner_row + perm_rows
1254 1254
1255 1255 def permission_user_groups(self):
1256 1256 q = UserGroupUserGroupToPerm.query().filter(UserGroupUserGroupToPerm.target_user_group == self)
1257 1257 q = q.options(joinedload(UserGroupUserGroupToPerm.user_group),
1258 1258 joinedload(UserGroupUserGroupToPerm.target_user_group),
1259 1259 joinedload(UserGroupUserGroupToPerm.permission),)
1260 1260
1261 1261 perm_rows = []
1262 1262 for _user_group in q.all():
1263 1263 usr = AttributeDict(_user_group.user_group.get_dict())
1264 1264 usr.permission = _user_group.permission.permission_name
1265 1265 perm_rows.append(usr)
1266 1266
1267 1267 return perm_rows
1268 1268
1269 1269 def _get_default_perms(self, user_group, suffix=''):
1270 1270 from rhodecode.model.permission import PermissionModel
1271 1271 return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix)
1272 1272
1273 1273 def get_default_perms(self, suffix=''):
1274 1274 return self._get_default_perms(self, suffix)
1275 1275
1276 1276 def get_api_data(self, with_group_members=True, include_secrets=False):
1277 1277 """
1278 1278 :param include_secrets: See :meth:`User.get_api_data`, this parameter is
1279 1279 basically forwarded.
1280 1280
1281 1281 """
1282 1282 user_group = self
1283 1283 data = {
1284 1284 'users_group_id': user_group.users_group_id,
1285 1285 'group_name': user_group.users_group_name,
1286 1286 'group_description': user_group.user_group_description,
1287 1287 'active': user_group.users_group_active,
1288 1288 'owner': user_group.user.username,
1289 1289 'owner_email': user_group.user.email,
1290 1290 }
1291 1291
1292 1292 if with_group_members:
1293 1293 users = []
1294 1294 for user in user_group.members:
1295 1295 user = user.user
1296 1296 users.append(user.get_api_data(include_secrets=include_secrets))
1297 1297 data['users'] = users
1298 1298
1299 1299 return data
1300 1300
1301 1301
1302 1302 class UserGroupMember(Base, BaseModel):
1303 1303 __tablename__ = 'users_groups_members'
1304 1304 __table_args__ = (
1305 1305 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1306 1306 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1307 1307 )
1308 1308
1309 1309 users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1310 1310 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
1311 1311 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
1312 1312
1313 1313 user = relationship('User', lazy='joined')
1314 1314 users_group = relationship('UserGroup')
1315 1315
1316 1316 def __init__(self, gr_id='', u_id=''):
1317 1317 self.users_group_id = gr_id
1318 1318 self.user_id = u_id
1319 1319
1320 1320
1321 1321 class RepositoryField(Base, BaseModel):
1322 1322 __tablename__ = 'repositories_fields'
1323 1323 __table_args__ = (
1324 1324 UniqueConstraint('repository_id', 'field_key'), # no-multi field
1325 1325 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1326 1326 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1327 1327 )
1328 1328 PREFIX = 'ex_' # prefix used in form to not conflict with already existing fields
1329 1329
1330 1330 repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1331 1331 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
1332 1332 field_key = Column("field_key", String(250))
1333 1333 field_label = Column("field_label", String(1024), nullable=False)
1334 1334 field_value = Column("field_value", String(10000), nullable=False)
1335 1335 field_desc = Column("field_desc", String(1024), nullable=False)
1336 1336 field_type = Column("field_type", String(255), nullable=False, unique=None)
1337 1337 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1338 1338
1339 1339 repository = relationship('Repository')
1340 1340
1341 1341 @property
1342 1342 def field_key_prefixed(self):
1343 1343 return 'ex_%s' % self.field_key
1344 1344
1345 1345 @classmethod
1346 1346 def un_prefix_key(cls, key):
1347 1347 if key.startswith(cls.PREFIX):
1348 1348 return key[len(cls.PREFIX):]
1349 1349 return key
1350 1350
1351 1351 @classmethod
1352 1352 def get_by_key_name(cls, key, repo):
1353 1353 row = cls.query()\
1354 1354 .filter(cls.repository == repo)\
1355 1355 .filter(cls.field_key == key).scalar()
1356 1356 return row
1357 1357
1358 1358
1359 1359 class Repository(Base, BaseModel):
1360 1360 __tablename__ = 'repositories'
1361 1361 __table_args__ = (
1362 1362 Index('r_repo_name_idx', 'repo_name', mysql_length=255),
1363 1363 {'extend_existing': True, 'mysql_engine': 'InnoDB',
1364 1364 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
1365 1365 )
1366 1366 DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'
1367 1367 DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'
1368 1368
1369 1369 STATE_CREATED = 'repo_state_created'
1370 1370 STATE_PENDING = 'repo_state_pending'
1371 1371 STATE_ERROR = 'repo_state_error'
1372 1372
1373 1373 LOCK_AUTOMATIC = 'lock_auto'
1374 1374 LOCK_API = 'lock_api'
1375 1375 LOCK_WEB = 'lock_web'
1376 1376 LOCK_PULL = 'lock_pull'
1377 1377
1378 1378 NAME_SEP = URL_SEP
1379 1379
1380 1380 repo_id = Column(
1381 1381 "repo_id", Integer(), nullable=False, unique=True, default=None,
1382 1382 primary_key=True)
1383 1383 _repo_name = Column(
1384 1384 "repo_name", Text(), nullable=False, default=None)
1385 1385 _repo_name_hash = Column(
1386 1386 "repo_name_hash", String(255), nullable=False, unique=True)
1387 1387 repo_state = Column("repo_state", String(255), nullable=True)
1388 1388
1389 1389 clone_uri = Column(
1390 1390 "clone_uri", EncryptedTextValue(), nullable=True, unique=False,
1391 1391 default=None)
1392 1392 repo_type = Column(
1393 1393 "repo_type", String(255), nullable=False, unique=False, default=None)
1394 1394 user_id = Column(
1395 1395 "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
1396 1396 unique=False, default=None)
1397 1397 private = Column(
1398 1398 "private", Boolean(), nullable=True, unique=None, default=None)
1399 1399 enable_statistics = Column(
1400 1400 "statistics", Boolean(), nullable=True, unique=None, default=True)
1401 1401 enable_downloads = Column(
1402 1402 "downloads", Boolean(), nullable=True, unique=None, default=True)
1403 1403 description = Column(
1404 1404 "description", String(10000), nullable=True, unique=None, default=None)
1405 1405 created_on = Column(
1406 1406 'created_on', DateTime(timezone=False), nullable=True, unique=None,
1407 1407 default=datetime.datetime.now)
1408 1408 updated_on = Column(
1409 1409 'updated_on', DateTime(timezone=False), nullable=True, unique=None,
1410 1410 default=datetime.datetime.now)
1411 1411 _landing_revision = Column(
1412 1412 "landing_revision", String(255), nullable=False, unique=False,
1413 1413 default=None)
1414 1414 enable_locking = Column(
1415 1415 "enable_locking", Boolean(), nullable=False, unique=None,
1416 1416 default=False)
1417 1417 _locked = Column(
1418 1418 "locked", String(255), nullable=True, unique=False, default=None)
1419 1419 _changeset_cache = Column(
1420 1420 "changeset_cache", LargeBinary(), nullable=True) # JSON data
1421 1421
1422 1422 fork_id = Column(
1423 1423 "fork_id", Integer(), ForeignKey('repositories.repo_id'),
1424 1424 nullable=True, unique=False, default=None)
1425 1425 group_id = Column(
1426 1426 "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True,
1427 1427 unique=False, default=None)
1428 1428
1429 1429 user = relationship('User', lazy='joined')
1430 1430 fork = relationship('Repository', remote_side=repo_id, lazy='joined')
1431 1431 group = relationship('RepoGroup', lazy='joined')
1432 1432 repo_to_perm = relationship(
1433 1433 'UserRepoToPerm', cascade='all',
1434 1434 order_by='UserRepoToPerm.repo_to_perm_id')
1435 1435 users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
1436 1436 stats = relationship('Statistics', cascade='all', uselist=False)
1437 1437
1438 1438 followers = relationship(
1439 1439 'UserFollowing',
1440 1440 primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id',
1441 1441 cascade='all')
1442 1442 extra_fields = relationship(
1443 1443 'RepositoryField', cascade="all, delete, delete-orphan")
1444 1444 logs = relationship('UserLog')
1445 1445 comments = relationship(
1446 1446 'ChangesetComment', cascade="all, delete, delete-orphan")
1447 1447 pull_requests_source = relationship(
1448 1448 'PullRequest',
1449 1449 primaryjoin='PullRequest.source_repo_id==Repository.repo_id',
1450 1450 cascade="all, delete, delete-orphan")
1451 1451 pull_requests_target = relationship(
1452 1452 'PullRequest',
1453 1453 primaryjoin='PullRequest.target_repo_id==Repository.repo_id',
1454 1454 cascade="all, delete, delete-orphan")
1455 1455 ui = relationship('RepoRhodeCodeUi', cascade="all")
1456 1456 settings = relationship('RepoRhodeCodeSetting', cascade="all")
1457 1457 integrations = relationship('Integration',
1458 1458 cascade="all, delete, delete-orphan")
1459 1459
1460 1460 def __unicode__(self):
1461 1461 return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,
1462 1462 safe_unicode(self.repo_name))
1463 1463
1464 1464 @hybrid_property
1465 1465 def landing_rev(self):
1466 1466 # always should return [rev_type, rev]
1467 1467 if self._landing_revision:
1468 1468 _rev_info = self._landing_revision.split(':')
1469 1469 if len(_rev_info) < 2:
1470 1470 _rev_info.insert(0, 'rev')
1471 1471 return [_rev_info[0], _rev_info[1]]
1472 1472 return [None, None]
1473 1473
1474 1474 @landing_rev.setter
1475 1475 def landing_rev(self, val):
1476 1476 if ':' not in val:
1477 1477 raise ValueError('value must be delimited with `:` and consist '
1478 1478 'of <rev_type>:<rev>, got %s instead' % val)
1479 1479 self._landing_revision = val
1480 1480
1481 1481 @hybrid_property
1482 1482 def locked(self):
1483 1483 if self._locked:
1484 1484 user_id, timelocked, reason = self._locked.split(':')
1485 1485 lock_values = int(user_id), timelocked, reason
1486 1486 else:
1487 1487 lock_values = [None, None, None]
1488 1488 return lock_values
1489 1489
1490 1490 @locked.setter
1491 1491 def locked(self, val):
1492 1492 if val and isinstance(val, (list, tuple)):
1493 1493 self._locked = ':'.join(map(str, val))
1494 1494 else:
1495 1495 self._locked = None
1496 1496
1497 1497 @hybrid_property
1498 1498 def changeset_cache(self):
1499 1499 from rhodecode.lib.vcs.backends.base import EmptyCommit
1500 1500 dummy = EmptyCommit().__json__()
1501 1501 if not self._changeset_cache:
1502 1502 return dummy
1503 1503 try:
1504 1504 return json.loads(self._changeset_cache)
1505 1505 except TypeError:
1506 1506 return dummy
1507 1507 except Exception:
1508 1508 log.error(traceback.format_exc())
1509 1509 return dummy
1510 1510
1511 1511 @changeset_cache.setter
1512 1512 def changeset_cache(self, val):
1513 1513 try:
1514 1514 self._changeset_cache = json.dumps(val)
1515 1515 except Exception:
1516 1516 log.error(traceback.format_exc())
1517 1517
1518 1518 @hybrid_property
1519 1519 def repo_name(self):
1520 1520 return self._repo_name
1521 1521
1522 1522 @repo_name.setter
1523 1523 def repo_name(self, value):
1524 1524 self._repo_name = value
1525 1525 self._repo_name_hash = hashlib.sha1(safe_str(value)).hexdigest()
1526 1526
1527 1527 @classmethod
1528 1528 def normalize_repo_name(cls, repo_name):
1529 1529 """
1530 1530 Normalizes os specific repo_name to the format internally stored inside
1531 1531 database using URL_SEP
1532 1532
1533 1533 :param cls:
1534 1534 :param repo_name:
1535 1535 """
1536 1536 return cls.NAME_SEP.join(repo_name.split(os.sep))
1537 1537
1538 1538 @classmethod
1539 1539 def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False):
1540 1540 session = Session()
1541 1541 q = session.query(cls).filter(cls.repo_name == repo_name)
1542 1542
1543 1543 if cache:
1544 1544 if identity_cache:
1545 1545 val = cls.identity_cache(session, 'repo_name', repo_name)
1546 1546 if val:
1547 1547 return val
1548 1548 else:
1549 1549 q = q.options(
1550 1550 FromCache("sql_cache_short",
1551 1551 "get_repo_by_name_%s" % _hash_key(repo_name)))
1552 1552
1553 1553 return q.scalar()
1554 1554
1555 1555 @classmethod
1556 1556 def get_by_full_path(cls, repo_full_path):
1557 1557 repo_name = repo_full_path.split(cls.base_path(), 1)[-1]
1558 1558 repo_name = cls.normalize_repo_name(repo_name)
1559 1559 return cls.get_by_repo_name(repo_name.strip(URL_SEP))
1560 1560
1561 1561 @classmethod
1562 1562 def get_repo_forks(cls, repo_id):
1563 1563 return cls.query().filter(Repository.fork_id == repo_id)
1564 1564
1565 1565 @classmethod
1566 1566 def base_path(cls):
1567 1567 """
1568 1568 Returns base path when all repos are stored
1569 1569
1570 1570 :param cls:
1571 1571 """
1572 1572 q = Session().query(RhodeCodeUi)\
1573 1573 .filter(RhodeCodeUi.ui_key == cls.NAME_SEP)
1574 1574 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
1575 1575 return q.one().ui_value
1576 1576
1577 1577 @classmethod
1578 1578 def is_valid(cls, repo_name):
1579 1579 """
1580 1580 returns True if given repo name is a valid filesystem repository
1581 1581
1582 1582 :param cls:
1583 1583 :param repo_name:
1584 1584 """
1585 1585 from rhodecode.lib.utils import is_valid_repo
1586 1586
1587 1587 return is_valid_repo(repo_name, cls.base_path())
1588 1588
1589 1589 @classmethod
1590 1590 def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None),
1591 1591 case_insensitive=True):
1592 1592 q = Repository.query()
1593 1593
1594 1594 if not isinstance(user_id, Optional):
1595 1595 q = q.filter(Repository.user_id == user_id)
1596 1596
1597 1597 if not isinstance(group_id, Optional):
1598 1598 q = q.filter(Repository.group_id == group_id)
1599 1599
1600 1600 if case_insensitive:
1601 1601 q = q.order_by(func.lower(Repository.repo_name))
1602 1602 else:
1603 1603 q = q.order_by(Repository.repo_name)
1604 1604 return q.all()
1605 1605
1606 1606 @property
1607 1607 def forks(self):
1608 1608 """
1609 1609 Return forks of this repo
1610 1610 """
1611 1611 return Repository.get_repo_forks(self.repo_id)
1612 1612
1613 1613 @property
1614 1614 def parent(self):
1615 1615 """
1616 1616 Returns fork parent
1617 1617 """
1618 1618 return self.fork
1619 1619
1620 1620 @property
1621 1621 def just_name(self):
1622 1622 return self.repo_name.split(self.NAME_SEP)[-1]
1623 1623
1624 1624 @property
1625 1625 def groups_with_parents(self):
1626 1626 groups = []
1627 1627 if self.group is None:
1628 1628 return groups
1629 1629
1630 1630 cur_gr = self.group
1631 1631 groups.insert(0, cur_gr)
1632 1632 while 1:
1633 1633 gr = getattr(cur_gr, 'parent_group', None)
1634 1634 cur_gr = cur_gr.parent_group
1635 1635 if gr is None:
1636 1636 break
1637 1637 groups.insert(0, gr)
1638 1638
1639 1639 return groups
1640 1640
1641 1641 @property
1642 1642 def groups_and_repo(self):
1643 1643 return self.groups_with_parents, self
1644 1644
1645 1645 @LazyProperty
1646 1646 def repo_path(self):
1647 1647 """
1648 1648 Returns base full path for that repository means where it actually
1649 1649 exists on a filesystem
1650 1650 """
1651 1651 q = Session().query(RhodeCodeUi).filter(
1652 1652 RhodeCodeUi.ui_key == self.NAME_SEP)
1653 1653 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
1654 1654 return q.one().ui_value
1655 1655
1656 1656 @property
1657 1657 def repo_full_path(self):
1658 1658 p = [self.repo_path]
1659 1659 # we need to split the name by / since this is how we store the
1660 1660 # names in the database, but that eventually needs to be converted
1661 1661 # into a valid system path
1662 1662 p += self.repo_name.split(self.NAME_SEP)
1663 1663 return os.path.join(*map(safe_unicode, p))
1664 1664
1665 1665 @property
1666 1666 def cache_keys(self):
1667 1667 """
1668 1668 Returns associated cache keys for that repo
1669 1669 """
1670 1670 return CacheKey.query()\
1671 1671 .filter(CacheKey.cache_args == self.repo_name)\
1672 1672 .order_by(CacheKey.cache_key)\
1673 1673 .all()
1674 1674
1675 1675 def get_new_name(self, repo_name):
1676 1676 """
1677 1677 returns new full repository name based on assigned group and new new
1678 1678
1679 1679 :param group_name:
1680 1680 """
1681 1681 path_prefix = self.group.full_path_splitted if self.group else []
1682 1682 return self.NAME_SEP.join(path_prefix + [repo_name])
1683 1683
1684 1684 @property
1685 1685 def _config(self):
1686 1686 """
1687 1687 Returns db based config object.
1688 1688 """
1689 1689 from rhodecode.lib.utils import make_db_config
1690 1690 return make_db_config(clear_session=False, repo=self)
1691 1691
1692 1692 def permissions(self, with_admins=True, with_owner=True):
1693 1693 q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self)
1694 1694 q = q.options(joinedload(UserRepoToPerm.repository),
1695 1695 joinedload(UserRepoToPerm.user),
1696 1696 joinedload(UserRepoToPerm.permission),)
1697 1697
1698 1698 # get owners and admins and permissions. We do a trick of re-writing
1699 1699 # objects from sqlalchemy to named-tuples due to sqlalchemy session
1700 1700 # has a global reference and changing one object propagates to all
1701 1701 # others. This means if admin is also an owner admin_row that change
1702 1702 # would propagate to both objects
1703 1703 perm_rows = []
1704 1704 for _usr in q.all():
1705 1705 usr = AttributeDict(_usr.user.get_dict())
1706 1706 usr.permission = _usr.permission.permission_name
1707 1707 perm_rows.append(usr)
1708 1708
1709 1709 # filter the perm rows by 'default' first and then sort them by
1710 1710 # admin,write,read,none permissions sorted again alphabetically in
1711 1711 # each group
1712 1712 perm_rows = sorted(perm_rows, key=display_sort)
1713 1713
1714 1714 _admin_perm = 'repository.admin'
1715 1715 owner_row = []
1716 1716 if with_owner:
1717 1717 usr = AttributeDict(self.user.get_dict())
1718 1718 usr.owner_row = True
1719 1719 usr.permission = _admin_perm
1720 1720 owner_row.append(usr)
1721 1721
1722 1722 super_admin_rows = []
1723 1723 if with_admins:
1724 1724 for usr in User.get_all_super_admins():
1725 1725 # if this admin is also owner, don't double the record
1726 1726 if usr.user_id == owner_row[0].user_id:
1727 1727 owner_row[0].admin_row = True
1728 1728 else:
1729 1729 usr = AttributeDict(usr.get_dict())
1730 1730 usr.admin_row = True
1731 1731 usr.permission = _admin_perm
1732 1732 super_admin_rows.append(usr)
1733 1733
1734 1734 return super_admin_rows + owner_row + perm_rows
1735 1735
1736 1736 def permission_user_groups(self):
1737 1737 q = UserGroupRepoToPerm.query().filter(
1738 1738 UserGroupRepoToPerm.repository == self)
1739 1739 q = q.options(joinedload(UserGroupRepoToPerm.repository),
1740 1740 joinedload(UserGroupRepoToPerm.users_group),
1741 1741 joinedload(UserGroupRepoToPerm.permission),)
1742 1742
1743 1743 perm_rows = []
1744 1744 for _user_group in q.all():
1745 1745 usr = AttributeDict(_user_group.users_group.get_dict())
1746 1746 usr.permission = _user_group.permission.permission_name
1747 1747 perm_rows.append(usr)
1748 1748
1749 1749 return perm_rows
1750 1750
1751 1751 def get_api_data(self, include_secrets=False):
1752 1752 """
1753 1753 Common function for generating repo api data
1754 1754
1755 1755 :param include_secrets: See :meth:`User.get_api_data`.
1756 1756
1757 1757 """
1758 1758 # TODO: mikhail: Here there is an anti-pattern, we probably need to
1759 1759 # move this methods on models level.
1760 1760 from rhodecode.model.settings import SettingsModel
1761 1761
1762 1762 repo = self
1763 1763 _user_id, _time, _reason = self.locked
1764 1764
1765 1765 data = {
1766 1766 'repo_id': repo.repo_id,
1767 1767 'repo_name': repo.repo_name,
1768 1768 'repo_type': repo.repo_type,
1769 1769 'clone_uri': repo.clone_uri or '',
1770 1770 'url': url('summary_home', repo_name=self.repo_name, qualified=True),
1771 1771 'private': repo.private,
1772 1772 'created_on': repo.created_on,
1773 1773 'description': repo.description,
1774 1774 'landing_rev': repo.landing_rev,
1775 1775 'owner': repo.user.username,
1776 1776 'fork_of': repo.fork.repo_name if repo.fork else None,
1777 1777 'enable_statistics': repo.enable_statistics,
1778 1778 'enable_locking': repo.enable_locking,
1779 1779 'enable_downloads': repo.enable_downloads,
1780 1780 'last_changeset': repo.changeset_cache,
1781 1781 'locked_by': User.get(_user_id).get_api_data(
1782 1782 include_secrets=include_secrets) if _user_id else None,
1783 1783 'locked_date': time_to_datetime(_time) if _time else None,
1784 1784 'lock_reason': _reason if _reason else None,
1785 1785 }
1786 1786
1787 1787 # TODO: mikhail: should be per-repo settings here
1788 1788 rc_config = SettingsModel().get_all_settings()
1789 1789 repository_fields = str2bool(
1790 1790 rc_config.get('rhodecode_repository_fields'))
1791 1791 if repository_fields:
1792 1792 for f in self.extra_fields:
1793 1793 data[f.field_key_prefixed] = f.field_value
1794 1794
1795 1795 return data
1796 1796
1797 1797 @classmethod
1798 1798 def lock(cls, repo, user_id, lock_time=None, lock_reason=None):
1799 1799 if not lock_time:
1800 1800 lock_time = time.time()
1801 1801 if not lock_reason:
1802 1802 lock_reason = cls.LOCK_AUTOMATIC
1803 1803 repo.locked = [user_id, lock_time, lock_reason]
1804 1804 Session().add(repo)
1805 1805 Session().commit()
1806 1806
1807 1807 @classmethod
1808 1808 def unlock(cls, repo):
1809 1809 repo.locked = None
1810 1810 Session().add(repo)
1811 1811 Session().commit()
1812 1812
1813 1813 @classmethod
1814 1814 def getlock(cls, repo):
1815 1815 return repo.locked
1816 1816
1817 1817 def is_user_lock(self, user_id):
1818 1818 if self.lock[0]:
1819 1819 lock_user_id = safe_int(self.lock[0])
1820 1820 user_id = safe_int(user_id)
1821 1821 # both are ints, and they are equal
1822 1822 return all([lock_user_id, user_id]) and lock_user_id == user_id
1823 1823
1824 1824 return False
1825 1825
1826 1826 def get_locking_state(self, action, user_id, only_when_enabled=True):
1827 1827 """
1828 1828 Checks locking on this repository, if locking is enabled and lock is
1829 1829 present returns a tuple of make_lock, locked, locked_by.
1830 1830 make_lock can have 3 states None (do nothing) True, make lock
1831 1831 False release lock, This value is later propagated to hooks, which
1832 1832 do the locking. Think about this as signals passed to hooks what to do.
1833 1833
1834 1834 """
1835 1835 # TODO: johbo: This is part of the business logic and should be moved
1836 1836 # into the RepositoryModel.
1837 1837
1838 1838 if action not in ('push', 'pull'):
1839 1839 raise ValueError("Invalid action value: %s" % repr(action))
1840 1840
1841 1841 # defines if locked error should be thrown to user
1842 1842 currently_locked = False
1843 1843 # defines if new lock should be made, tri-state
1844 1844 make_lock = None
1845 1845 repo = self
1846 1846 user = User.get(user_id)
1847 1847
1848 1848 lock_info = repo.locked
1849 1849
1850 1850 if repo and (repo.enable_locking or not only_when_enabled):
1851 1851 if action == 'push':
1852 1852 # check if it's already locked !, if it is compare users
1853 1853 locked_by_user_id = lock_info[0]
1854 1854 if user.user_id == locked_by_user_id:
1855 1855 log.debug(
1856 1856 'Got `push` action from user %s, now unlocking', user)
1857 1857 # unlock if we have push from user who locked
1858 1858 make_lock = False
1859 1859 else:
1860 1860 # we're not the same user who locked, ban with
1861 1861 # code defined in settings (default is 423 HTTP Locked) !
1862 1862 log.debug('Repo %s is currently locked by %s', repo, user)
1863 1863 currently_locked = True
1864 1864 elif action == 'pull':
1865 1865 # [0] user [1] date
1866 1866 if lock_info[0] and lock_info[1]:
1867 1867 log.debug('Repo %s is currently locked by %s', repo, user)
1868 1868 currently_locked = True
1869 1869 else:
1870 1870 log.debug('Setting lock on repo %s by %s', repo, user)
1871 1871 make_lock = True
1872 1872
1873 1873 else:
1874 1874 log.debug('Repository %s do not have locking enabled', repo)
1875 1875
1876 1876 log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s',
1877 1877 make_lock, currently_locked, lock_info)
1878 1878
1879 1879 from rhodecode.lib.auth import HasRepoPermissionAny
1880 1880 perm_check = HasRepoPermissionAny('repository.write', 'repository.admin')
1881 1881 if make_lock and not perm_check(repo_name=repo.repo_name, user=user):
1882 1882 # if we don't have at least write permission we cannot make a lock
1883 1883 log.debug('lock state reset back to FALSE due to lack '
1884 1884 'of at least read permission')
1885 1885 make_lock = False
1886 1886
1887 1887 return make_lock, currently_locked, lock_info
1888 1888
1889 1889 @property
1890 1890 def last_db_change(self):
1891 1891 return self.updated_on
1892 1892
1893 1893 @property
1894 1894 def clone_uri_hidden(self):
1895 1895 clone_uri = self.clone_uri
1896 1896 if clone_uri:
1897 1897 import urlobject
1898 1898 url_obj = urlobject.URLObject(cleaned_uri(clone_uri))
1899 1899 if url_obj.password:
1900 1900 clone_uri = url_obj.with_password('*****')
1901 1901 return clone_uri
1902 1902
1903 1903 def clone_url(self, **override):
1904 1904 qualified_home_url = url('home', qualified=True)
1905 1905
1906 1906 uri_tmpl = None
1907 1907 if 'with_id' in override:
1908 1908 uri_tmpl = self.DEFAULT_CLONE_URI_ID
1909 1909 del override['with_id']
1910 1910
1911 1911 if 'uri_tmpl' in override:
1912 1912 uri_tmpl = override['uri_tmpl']
1913 1913 del override['uri_tmpl']
1914 1914
1915 1915 # we didn't override our tmpl from **overrides
1916 1916 if not uri_tmpl:
1917 1917 uri_tmpl = self.DEFAULT_CLONE_URI
1918 1918 try:
1919 1919 from pylons import tmpl_context as c
1920 1920 uri_tmpl = c.clone_uri_tmpl
1921 1921 except Exception:
1922 1922 # in any case if we call this outside of request context,
1923 1923 # ie, not having tmpl_context set up
1924 1924 pass
1925 1925
1926 1926 return get_clone_url(uri_tmpl=uri_tmpl,
1927 1927 qualifed_home_url=qualified_home_url,
1928 1928 repo_name=self.repo_name,
1929 1929 repo_id=self.repo_id, **override)
1930 1930
1931 1931 def set_state(self, state):
1932 1932 self.repo_state = state
1933 1933 Session().add(self)
1934 1934 #==========================================================================
1935 1935 # SCM PROPERTIES
1936 1936 #==========================================================================
1937 1937
1938 1938 def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
1939 1939 return get_commit_safe(
1940 1940 self.scm_instance(), commit_id, commit_idx, pre_load=pre_load)
1941 1941
1942 1942 def get_changeset(self, rev=None, pre_load=None):
1943 1943 warnings.warn("Use get_commit", DeprecationWarning)
1944 1944 commit_id = None
1945 1945 commit_idx = None
1946 1946 if isinstance(rev, basestring):
1947 1947 commit_id = rev
1948 1948 else:
1949 1949 commit_idx = rev
1950 1950 return self.get_commit(commit_id=commit_id, commit_idx=commit_idx,
1951 1951 pre_load=pre_load)
1952 1952
1953 1953 def get_landing_commit(self):
1954 1954 """
1955 1955 Returns landing commit, or if that doesn't exist returns the tip
1956 1956 """
1957 1957 _rev_type, _rev = self.landing_rev
1958 1958 commit = self.get_commit(_rev)
1959 1959 if isinstance(commit, EmptyCommit):
1960 1960 return self.get_commit()
1961 1961 return commit
1962 1962
1963 1963 def update_commit_cache(self, cs_cache=None, config=None):
1964 1964 """
1965 1965 Update cache of last changeset for repository, keys should be::
1966 1966
1967 1967 short_id
1968 1968 raw_id
1969 1969 revision
1970 1970 parents
1971 1971 message
1972 1972 date
1973 1973 author
1974 1974
1975 1975 :param cs_cache:
1976 1976 """
1977 1977 from rhodecode.lib.vcs.backends.base import BaseChangeset
1978 1978 if cs_cache is None:
1979 1979 # use no-cache version here
1980 1980 scm_repo = self.scm_instance(cache=False, config=config)
1981 1981 if scm_repo:
1982 1982 cs_cache = scm_repo.get_commit(
1983 1983 pre_load=["author", "date", "message", "parents"])
1984 1984 else:
1985 1985 cs_cache = EmptyCommit()
1986 1986
1987 1987 if isinstance(cs_cache, BaseChangeset):
1988 1988 cs_cache = cs_cache.__json__()
1989 1989
1990 1990 def is_outdated(new_cs_cache):
1991 1991 if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or
1992 1992 new_cs_cache['revision'] != self.changeset_cache['revision']):
1993 1993 return True
1994 1994 return False
1995 1995
1996 1996 # check if we have maybe already latest cached revision
1997 1997 if is_outdated(cs_cache) or not self.changeset_cache:
1998 1998 _default = datetime.datetime.fromtimestamp(0)
1999 1999 last_change = cs_cache.get('date') or _default
2000 2000 log.debug('updated repo %s with new cs cache %s',
2001 2001 self.repo_name, cs_cache)
2002 2002 self.updated_on = last_change
2003 2003 self.changeset_cache = cs_cache
2004 2004 Session().add(self)
2005 2005 Session().commit()
2006 2006 else:
2007 2007 log.debug('Skipping update_commit_cache for repo:`%s` '
2008 2008 'commit already with latest changes', self.repo_name)
2009 2009
2010 2010 @property
2011 2011 def tip(self):
2012 2012 return self.get_commit('tip')
2013 2013
2014 2014 @property
2015 2015 def author(self):
2016 2016 return self.tip.author
2017 2017
2018 2018 @property
2019 2019 def last_change(self):
2020 2020 return self.scm_instance().last_change
2021 2021
2022 2022 def get_comments(self, revisions=None):
2023 2023 """
2024 2024 Returns comments for this repository grouped by revisions
2025 2025
2026 2026 :param revisions: filter query by revisions only
2027 2027 """
2028 2028 cmts = ChangesetComment.query()\
2029 2029 .filter(ChangesetComment.repo == self)
2030 2030 if revisions:
2031 2031 cmts = cmts.filter(ChangesetComment.revision.in_(revisions))
2032 2032 grouped = collections.defaultdict(list)
2033 2033 for cmt in cmts.all():
2034 2034 grouped[cmt.revision].append(cmt)
2035 2035 return grouped
2036 2036
2037 2037 def statuses(self, revisions=None):
2038 2038 """
2039 2039 Returns statuses for this repository
2040 2040
2041 2041 :param revisions: list of revisions to get statuses for
2042 2042 """
2043 2043 statuses = ChangesetStatus.query()\
2044 2044 .filter(ChangesetStatus.repo == self)\
2045 2045 .filter(ChangesetStatus.version == 0)
2046 2046
2047 2047 if revisions:
2048 2048 # Try doing the filtering in chunks to avoid hitting limits
2049 2049 size = 500
2050 2050 status_results = []
2051 2051 for chunk in xrange(0, len(revisions), size):
2052 2052 status_results += statuses.filter(
2053 2053 ChangesetStatus.revision.in_(
2054 2054 revisions[chunk: chunk+size])
2055 2055 ).all()
2056 2056 else:
2057 2057 status_results = statuses.all()
2058 2058
2059 2059 grouped = {}
2060 2060
2061 2061 # maybe we have open new pullrequest without a status?
2062 2062 stat = ChangesetStatus.STATUS_UNDER_REVIEW
2063 2063 status_lbl = ChangesetStatus.get_status_lbl(stat)
2064 2064 for pr in PullRequest.query().filter(PullRequest.source_repo == self).all():
2065 2065 for rev in pr.revisions:
2066 2066 pr_id = pr.pull_request_id
2067 2067 pr_repo = pr.target_repo.repo_name
2068 2068 grouped[rev] = [stat, status_lbl, pr_id, pr_repo]
2069 2069
2070 2070 for stat in status_results:
2071 2071 pr_id = pr_repo = None
2072 2072 if stat.pull_request:
2073 2073 pr_id = stat.pull_request.pull_request_id
2074 2074 pr_repo = stat.pull_request.target_repo.repo_name
2075 2075 grouped[stat.revision] = [str(stat.status), stat.status_lbl,
2076 2076 pr_id, pr_repo]
2077 2077 return grouped
2078 2078
2079 2079 # ==========================================================================
2080 2080 # SCM CACHE INSTANCE
2081 2081 # ==========================================================================
2082 2082
2083 2083 def scm_instance(self, **kwargs):
2084 2084 import rhodecode
2085 2085
2086 2086 # Passing a config will not hit the cache currently only used
2087 2087 # for repo2dbmapper
2088 2088 config = kwargs.pop('config', None)
2089 2089 cache = kwargs.pop('cache', None)
2090 2090 full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))
2091 2091 # if cache is NOT defined use default global, else we have a full
2092 2092 # control over cache behaviour
2093 2093 if cache is None and full_cache and not config:
2094 2094 return self._get_instance_cached()
2095 2095 return self._get_instance(cache=bool(cache), config=config)
2096 2096
2097 2097 def _get_instance_cached(self):
2098 2098 @cache_region('long_term')
2099 2099 def _get_repo(cache_key):
2100 2100 return self._get_instance()
2101 2101
2102 2102 invalidator_context = CacheKey.repo_context_cache(
2103 2103 _get_repo, self.repo_name, None, thread_scoped=True)
2104 2104
2105 2105 with invalidator_context as context:
2106 2106 context.invalidate()
2107 2107 repo = context.compute()
2108 2108
2109 2109 return repo
2110 2110
2111 2111 def _get_instance(self, cache=True, config=None):
2112 2112 config = config or self._config
2113 2113 custom_wire = {
2114 2114 'cache': cache # controls the vcs.remote cache
2115 2115 }
2116 2116 repo = get_vcs_instance(
2117 2117 repo_path=safe_str(self.repo_full_path),
2118 2118 config=config,
2119 2119 with_wire=custom_wire,
2120 2120 create=False,
2121 2121 _vcs_alias=self.repo_type)
2122 2122
2123 2123 return repo
2124 2124
2125 2125 def __json__(self):
2126 2126 return {'landing_rev': self.landing_rev}
2127 2127
2128 2128 def get_dict(self):
2129 2129
2130 2130 # Since we transformed `repo_name` to a hybrid property, we need to
2131 2131 # keep compatibility with the code which uses `repo_name` field.
2132 2132
2133 2133 result = super(Repository, self).get_dict()
2134 2134 result['repo_name'] = result.pop('_repo_name', None)
2135 2135 return result
2136 2136
2137 2137
2138 2138 class RepoGroup(Base, BaseModel):
2139 2139 __tablename__ = 'groups'
2140 2140 __table_args__ = (
2141 2141 UniqueConstraint('group_name', 'group_parent_id'),
2142 2142 CheckConstraint('group_id != group_parent_id'),
2143 2143 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2144 2144 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2145 2145 )
2146 2146 __mapper_args__ = {'order_by': 'group_name'}
2147 2147
2148 2148 CHOICES_SEPARATOR = '/' # used to generate select2 choices for nested groups
2149 2149
2150 2150 group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2151 2151 group_name = Column("group_name", String(255), nullable=False, unique=True, default=None)
2152 2152 group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)
2153 2153 group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None)
2154 2154 enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
2155 2155 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
2156 2156 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
2157 2157 personal = Column('personal', Boolean(), nullable=True, unique=None, default=None)
2158 2158
2159 2159 repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
2160 2160 users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
2161 2161 parent_group = relationship('RepoGroup', remote_side=group_id)
2162 2162 user = relationship('User')
2163 2163 integrations = relationship('Integration',
2164 2164 cascade="all, delete, delete-orphan")
2165 2165
2166 2166 def __init__(self, group_name='', parent_group=None):
2167 2167 self.group_name = group_name
2168 2168 self.parent_group = parent_group
2169 2169
2170 2170 def __unicode__(self):
2171 2171 return u"<%s('id:%s:%s')>" % (self.__class__.__name__, self.group_id,
2172 2172 self.group_name)
2173 2173
2174 2174 @classmethod
2175 2175 def _generate_choice(cls, repo_group):
2176 2176 from webhelpers.html import literal as _literal
2177 2177 _name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k))
2178 2178 return repo_group.group_id, _name(repo_group.full_path_splitted)
2179 2179
2180 2180 @classmethod
2181 2181 def groups_choices(cls, groups=None, show_empty_group=True):
2182 2182 if not groups:
2183 2183 groups = cls.query().all()
2184 2184
2185 2185 repo_groups = []
2186 2186 if show_empty_group:
2187 repo_groups = [('-1', u'-- %s --' % _('No parent'))]
2187 repo_groups = [(-1, u'-- %s --' % _('No parent'))]
2188 2188
2189 2189 repo_groups.extend([cls._generate_choice(x) for x in groups])
2190 2190
2191 2191 repo_groups = sorted(
2192 2192 repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0])
2193 2193 return repo_groups
2194 2194
2195 2195 @classmethod
2196 2196 def url_sep(cls):
2197 2197 return URL_SEP
2198 2198
2199 2199 @classmethod
2200 2200 def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
2201 2201 if case_insensitive:
2202 2202 gr = cls.query().filter(func.lower(cls.group_name)
2203 2203 == func.lower(group_name))
2204 2204 else:
2205 2205 gr = cls.query().filter(cls.group_name == group_name)
2206 2206 if cache:
2207 2207 gr = gr.options(FromCache(
2208 2208 "sql_cache_short",
2209 2209 "get_group_%s" % _hash_key(group_name)))
2210 2210 return gr.scalar()
2211 2211
2212 2212 @classmethod
2213 2213 def get_user_personal_repo_group(cls, user_id):
2214 2214 user = User.get(user_id)
2215 2215 if user.username == User.DEFAULT_USER:
2216 2216 return None
2217 2217
2218 2218 return cls.query()\
2219 2219 .filter(cls.personal == true()) \
2220 2220 .filter(cls.user == user).scalar()
2221 2221
2222 2222 @classmethod
2223 2223 def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),
2224 2224 case_insensitive=True):
2225 2225 q = RepoGroup.query()
2226 2226
2227 2227 if not isinstance(user_id, Optional):
2228 2228 q = q.filter(RepoGroup.user_id == user_id)
2229 2229
2230 2230 if not isinstance(group_id, Optional):
2231 2231 q = q.filter(RepoGroup.group_parent_id == group_id)
2232 2232
2233 2233 if case_insensitive:
2234 2234 q = q.order_by(func.lower(RepoGroup.group_name))
2235 2235 else:
2236 2236 q = q.order_by(RepoGroup.group_name)
2237 2237 return q.all()
2238 2238
2239 2239 @property
2240 2240 def parents(self):
2241 2241 parents_recursion_limit = 10
2242 2242 groups = []
2243 2243 if self.parent_group is None:
2244 2244 return groups
2245 2245 cur_gr = self.parent_group
2246 2246 groups.insert(0, cur_gr)
2247 2247 cnt = 0
2248 2248 while 1:
2249 2249 cnt += 1
2250 2250 gr = getattr(cur_gr, 'parent_group', None)
2251 2251 cur_gr = cur_gr.parent_group
2252 2252 if gr is None:
2253 2253 break
2254 2254 if cnt == parents_recursion_limit:
2255 2255 # this will prevent accidental infinit loops
2256 2256 log.error(('more than %s parents found for group %s, stopping '
2257 2257 'recursive parent fetching' % (parents_recursion_limit, self)))
2258 2258 break
2259 2259
2260 2260 groups.insert(0, gr)
2261 2261 return groups
2262 2262
2263 2263 @property
2264 2264 def children(self):
2265 2265 return RepoGroup.query().filter(RepoGroup.parent_group == self)
2266 2266
2267 2267 @property
2268 2268 def name(self):
2269 2269 return self.group_name.split(RepoGroup.url_sep())[-1]
2270 2270
2271 2271 @property
2272 2272 def full_path(self):
2273 2273 return self.group_name
2274 2274
2275 2275 @property
2276 2276 def full_path_splitted(self):
2277 2277 return self.group_name.split(RepoGroup.url_sep())
2278 2278
2279 2279 @property
2280 2280 def repositories(self):
2281 2281 return Repository.query()\
2282 2282 .filter(Repository.group == self)\
2283 2283 .order_by(Repository.repo_name)
2284 2284
2285 2285 @property
2286 2286 def repositories_recursive_count(self):
2287 2287 cnt = self.repositories.count()
2288 2288
2289 2289 def children_count(group):
2290 2290 cnt = 0
2291 2291 for child in group.children:
2292 2292 cnt += child.repositories.count()
2293 2293 cnt += children_count(child)
2294 2294 return cnt
2295 2295
2296 2296 return cnt + children_count(self)
2297 2297
2298 2298 def _recursive_objects(self, include_repos=True):
2299 2299 all_ = []
2300 2300
2301 2301 def _get_members(root_gr):
2302 2302 if include_repos:
2303 2303 for r in root_gr.repositories:
2304 2304 all_.append(r)
2305 2305 childs = root_gr.children.all()
2306 2306 if childs:
2307 2307 for gr in childs:
2308 2308 all_.append(gr)
2309 2309 _get_members(gr)
2310 2310
2311 2311 _get_members(self)
2312 2312 return [self] + all_
2313 2313
2314 2314 def recursive_groups_and_repos(self):
2315 2315 """
2316 2316 Recursive return all groups, with repositories in those groups
2317 2317 """
2318 2318 return self._recursive_objects()
2319 2319
2320 2320 def recursive_groups(self):
2321 2321 """
2322 2322 Returns all children groups for this group including children of children
2323 2323 """
2324 2324 return self._recursive_objects(include_repos=False)
2325 2325
2326 2326 def get_new_name(self, group_name):
2327 2327 """
2328 2328 returns new full group name based on parent and new name
2329 2329
2330 2330 :param group_name:
2331 2331 """
2332 2332 path_prefix = (self.parent_group.full_path_splitted if
2333 2333 self.parent_group else [])
2334 2334 return RepoGroup.url_sep().join(path_prefix + [group_name])
2335 2335
2336 2336 def permissions(self, with_admins=True, with_owner=True):
2337 2337 q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self)
2338 2338 q = q.options(joinedload(UserRepoGroupToPerm.group),
2339 2339 joinedload(UserRepoGroupToPerm.user),
2340 2340 joinedload(UserRepoGroupToPerm.permission),)
2341 2341
2342 2342 # get owners and admins and permissions. We do a trick of re-writing
2343 2343 # objects from sqlalchemy to named-tuples due to sqlalchemy session
2344 2344 # has a global reference and changing one object propagates to all
2345 2345 # others. This means if admin is also an owner admin_row that change
2346 2346 # would propagate to both objects
2347 2347 perm_rows = []
2348 2348 for _usr in q.all():
2349 2349 usr = AttributeDict(_usr.user.get_dict())
2350 2350 usr.permission = _usr.permission.permission_name
2351 2351 perm_rows.append(usr)
2352 2352
2353 2353 # filter the perm rows by 'default' first and then sort them by
2354 2354 # admin,write,read,none permissions sorted again alphabetically in
2355 2355 # each group
2356 2356 perm_rows = sorted(perm_rows, key=display_sort)
2357 2357
2358 2358 _admin_perm = 'group.admin'
2359 2359 owner_row = []
2360 2360 if with_owner:
2361 2361 usr = AttributeDict(self.user.get_dict())
2362 2362 usr.owner_row = True
2363 2363 usr.permission = _admin_perm
2364 2364 owner_row.append(usr)
2365 2365
2366 2366 super_admin_rows = []
2367 2367 if with_admins:
2368 2368 for usr in User.get_all_super_admins():
2369 2369 # if this admin is also owner, don't double the record
2370 2370 if usr.user_id == owner_row[0].user_id:
2371 2371 owner_row[0].admin_row = True
2372 2372 else:
2373 2373 usr = AttributeDict(usr.get_dict())
2374 2374 usr.admin_row = True
2375 2375 usr.permission = _admin_perm
2376 2376 super_admin_rows.append(usr)
2377 2377
2378 2378 return super_admin_rows + owner_row + perm_rows
2379 2379
2380 2380 def permission_user_groups(self):
2381 2381 q = UserGroupRepoGroupToPerm.query().filter(UserGroupRepoGroupToPerm.group == self)
2382 2382 q = q.options(joinedload(UserGroupRepoGroupToPerm.group),
2383 2383 joinedload(UserGroupRepoGroupToPerm.users_group),
2384 2384 joinedload(UserGroupRepoGroupToPerm.permission),)
2385 2385
2386 2386 perm_rows = []
2387 2387 for _user_group in q.all():
2388 2388 usr = AttributeDict(_user_group.users_group.get_dict())
2389 2389 usr.permission = _user_group.permission.permission_name
2390 2390 perm_rows.append(usr)
2391 2391
2392 2392 return perm_rows
2393 2393
2394 2394 def get_api_data(self):
2395 2395 """
2396 2396 Common function for generating api data
2397 2397
2398 2398 """
2399 2399 group = self
2400 2400 data = {
2401 2401 'group_id': group.group_id,
2402 2402 'group_name': group.group_name,
2403 2403 'group_description': group.group_description,
2404 2404 'parent_group': group.parent_group.group_name if group.parent_group else None,
2405 2405 'repositories': [x.repo_name for x in group.repositories],
2406 2406 'owner': group.user.username,
2407 2407 }
2408 2408 return data
2409 2409
2410 2410
2411 2411 class Permission(Base, BaseModel):
2412 2412 __tablename__ = 'permissions'
2413 2413 __table_args__ = (
2414 2414 Index('p_perm_name_idx', 'permission_name'),
2415 2415 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2416 2416 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2417 2417 )
2418 2418 PERMS = [
2419 2419 ('hg.admin', _('RhodeCode Super Administrator')),
2420 2420
2421 2421 ('repository.none', _('Repository no access')),
2422 2422 ('repository.read', _('Repository read access')),
2423 2423 ('repository.write', _('Repository write access')),
2424 2424 ('repository.admin', _('Repository admin access')),
2425 2425
2426 2426 ('group.none', _('Repository group no access')),
2427 2427 ('group.read', _('Repository group read access')),
2428 2428 ('group.write', _('Repository group write access')),
2429 2429 ('group.admin', _('Repository group admin access')),
2430 2430
2431 2431 ('usergroup.none', _('User group no access')),
2432 2432 ('usergroup.read', _('User group read access')),
2433 2433 ('usergroup.write', _('User group write access')),
2434 2434 ('usergroup.admin', _('User group admin access')),
2435 2435
2436 2436 ('hg.repogroup.create.false', _('Repository Group creation disabled')),
2437 2437 ('hg.repogroup.create.true', _('Repository Group creation enabled')),
2438 2438
2439 2439 ('hg.usergroup.create.false', _('User Group creation disabled')),
2440 2440 ('hg.usergroup.create.true', _('User Group creation enabled')),
2441 2441
2442 2442 ('hg.create.none', _('Repository creation disabled')),
2443 2443 ('hg.create.repository', _('Repository creation enabled')),
2444 2444 ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')),
2445 2445 ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')),
2446 2446
2447 2447 ('hg.fork.none', _('Repository forking disabled')),
2448 2448 ('hg.fork.repository', _('Repository forking enabled')),
2449 2449
2450 2450 ('hg.register.none', _('Registration disabled')),
2451 2451 ('hg.register.manual_activate', _('User Registration with manual account activation')),
2452 2452 ('hg.register.auto_activate', _('User Registration with automatic account activation')),
2453 2453
2454 2454 ('hg.password_reset.enabled', _('Password reset enabled')),
2455 2455 ('hg.password_reset.hidden', _('Password reset hidden')),
2456 2456 ('hg.password_reset.disabled', _('Password reset disabled')),
2457 2457
2458 2458 ('hg.extern_activate.manual', _('Manual activation of external account')),
2459 2459 ('hg.extern_activate.auto', _('Automatic activation of external account')),
2460 2460
2461 2461 ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')),
2462 2462 ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')),
2463 2463 ]
2464 2464
2465 2465 # definition of system default permissions for DEFAULT user
2466 2466 DEFAULT_USER_PERMISSIONS = [
2467 2467 'repository.read',
2468 2468 'group.read',
2469 2469 'usergroup.read',
2470 2470 'hg.create.repository',
2471 2471 'hg.repogroup.create.false',
2472 2472 'hg.usergroup.create.false',
2473 2473 'hg.create.write_on_repogroup.true',
2474 2474 'hg.fork.repository',
2475 2475 'hg.register.manual_activate',
2476 2476 'hg.password_reset.enabled',
2477 2477 'hg.extern_activate.auto',
2478 2478 'hg.inherit_default_perms.true',
2479 2479 ]
2480 2480
2481 2481 # defines which permissions are more important higher the more important
2482 2482 # Weight defines which permissions are more important.
2483 2483 # The higher number the more important.
2484 2484 PERM_WEIGHTS = {
2485 2485 'repository.none': 0,
2486 2486 'repository.read': 1,
2487 2487 'repository.write': 3,
2488 2488 'repository.admin': 4,
2489 2489
2490 2490 'group.none': 0,
2491 2491 'group.read': 1,
2492 2492 'group.write': 3,
2493 2493 'group.admin': 4,
2494 2494
2495 2495 'usergroup.none': 0,
2496 2496 'usergroup.read': 1,
2497 2497 'usergroup.write': 3,
2498 2498 'usergroup.admin': 4,
2499 2499
2500 2500 'hg.repogroup.create.false': 0,
2501 2501 'hg.repogroup.create.true': 1,
2502 2502
2503 2503 'hg.usergroup.create.false': 0,
2504 2504 'hg.usergroup.create.true': 1,
2505 2505
2506 2506 'hg.fork.none': 0,
2507 2507 'hg.fork.repository': 1,
2508 2508 'hg.create.none': 0,
2509 2509 'hg.create.repository': 1
2510 2510 }
2511 2511
2512 2512 permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2513 2513 permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)
2514 2514 permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)
2515 2515
2516 2516 def __unicode__(self):
2517 2517 return u"<%s('%s:%s')>" % (
2518 2518 self.__class__.__name__, self.permission_id, self.permission_name
2519 2519 )
2520 2520
2521 2521 @classmethod
2522 2522 def get_by_key(cls, key):
2523 2523 return cls.query().filter(cls.permission_name == key).scalar()
2524 2524
2525 2525 @classmethod
2526 2526 def get_default_repo_perms(cls, user_id, repo_id=None):
2527 2527 q = Session().query(UserRepoToPerm, Repository, Permission)\
2528 2528 .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\
2529 2529 .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\
2530 2530 .filter(UserRepoToPerm.user_id == user_id)
2531 2531 if repo_id:
2532 2532 q = q.filter(UserRepoToPerm.repository_id == repo_id)
2533 2533 return q.all()
2534 2534
2535 2535 @classmethod
2536 2536 def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None):
2537 2537 q = Session().query(UserGroupRepoToPerm, Repository, Permission)\
2538 2538 .join(
2539 2539 Permission,
2540 2540 UserGroupRepoToPerm.permission_id == Permission.permission_id)\
2541 2541 .join(
2542 2542 Repository,
2543 2543 UserGroupRepoToPerm.repository_id == Repository.repo_id)\
2544 2544 .join(
2545 2545 UserGroup,
2546 2546 UserGroupRepoToPerm.users_group_id ==
2547 2547 UserGroup.users_group_id)\
2548 2548 .join(
2549 2549 UserGroupMember,
2550 2550 UserGroupRepoToPerm.users_group_id ==
2551 2551 UserGroupMember.users_group_id)\
2552 2552 .filter(
2553 2553 UserGroupMember.user_id == user_id,
2554 2554 UserGroup.users_group_active == true())
2555 2555 if repo_id:
2556 2556 q = q.filter(UserGroupRepoToPerm.repository_id == repo_id)
2557 2557 return q.all()
2558 2558
2559 2559 @classmethod
2560 2560 def get_default_group_perms(cls, user_id, repo_group_id=None):
2561 2561 q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\
2562 2562 .join((Permission, UserRepoGroupToPerm.permission_id == Permission.permission_id))\
2563 2563 .join((RepoGroup, UserRepoGroupToPerm.group_id == RepoGroup.group_id))\
2564 2564 .filter(UserRepoGroupToPerm.user_id == user_id)
2565 2565 if repo_group_id:
2566 2566 q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id)
2567 2567 return q.all()
2568 2568
2569 2569 @classmethod
2570 2570 def get_default_group_perms_from_user_group(
2571 2571 cls, user_id, repo_group_id=None):
2572 2572 q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\
2573 2573 .join(
2574 2574 Permission,
2575 2575 UserGroupRepoGroupToPerm.permission_id ==
2576 2576 Permission.permission_id)\
2577 2577 .join(
2578 2578 RepoGroup,
2579 2579 UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\
2580 2580 .join(
2581 2581 UserGroup,
2582 2582 UserGroupRepoGroupToPerm.users_group_id ==
2583 2583 UserGroup.users_group_id)\
2584 2584 .join(
2585 2585 UserGroupMember,
2586 2586 UserGroupRepoGroupToPerm.users_group_id ==
2587 2587 UserGroupMember.users_group_id)\
2588 2588 .filter(
2589 2589 UserGroupMember.user_id == user_id,
2590 2590 UserGroup.users_group_active == true())
2591 2591 if repo_group_id:
2592 2592 q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id)
2593 2593 return q.all()
2594 2594
2595 2595 @classmethod
2596 2596 def get_default_user_group_perms(cls, user_id, user_group_id=None):
2597 2597 q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\
2598 2598 .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\
2599 2599 .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\
2600 2600 .filter(UserUserGroupToPerm.user_id == user_id)
2601 2601 if user_group_id:
2602 2602 q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id)
2603 2603 return q.all()
2604 2604
2605 2605 @classmethod
2606 2606 def get_default_user_group_perms_from_user_group(
2607 2607 cls, user_id, user_group_id=None):
2608 2608 TargetUserGroup = aliased(UserGroup, name='target_user_group')
2609 2609 q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\
2610 2610 .join(
2611 2611 Permission,
2612 2612 UserGroupUserGroupToPerm.permission_id ==
2613 2613 Permission.permission_id)\
2614 2614 .join(
2615 2615 TargetUserGroup,
2616 2616 UserGroupUserGroupToPerm.target_user_group_id ==
2617 2617 TargetUserGroup.users_group_id)\
2618 2618 .join(
2619 2619 UserGroup,
2620 2620 UserGroupUserGroupToPerm.user_group_id ==
2621 2621 UserGroup.users_group_id)\
2622 2622 .join(
2623 2623 UserGroupMember,
2624 2624 UserGroupUserGroupToPerm.user_group_id ==
2625 2625 UserGroupMember.users_group_id)\
2626 2626 .filter(
2627 2627 UserGroupMember.user_id == user_id,
2628 2628 UserGroup.users_group_active == true())
2629 2629 if user_group_id:
2630 2630 q = q.filter(
2631 2631 UserGroupUserGroupToPerm.user_group_id == user_group_id)
2632 2632
2633 2633 return q.all()
2634 2634
2635 2635
2636 2636 class UserRepoToPerm(Base, BaseModel):
2637 2637 __tablename__ = 'repo_to_perm'
2638 2638 __table_args__ = (
2639 2639 UniqueConstraint('user_id', 'repository_id', 'permission_id'),
2640 2640 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2641 2641 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2642 2642 )
2643 2643 repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2644 2644 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2645 2645 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2646 2646 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
2647 2647
2648 2648 user = relationship('User')
2649 2649 repository = relationship('Repository')
2650 2650 permission = relationship('Permission')
2651 2651
2652 2652 @classmethod
2653 2653 def create(cls, user, repository, permission):
2654 2654 n = cls()
2655 2655 n.user = user
2656 2656 n.repository = repository
2657 2657 n.permission = permission
2658 2658 Session().add(n)
2659 2659 return n
2660 2660
2661 2661 def __unicode__(self):
2662 2662 return u'<%s => %s >' % (self.user, self.repository)
2663 2663
2664 2664
2665 2665 class UserUserGroupToPerm(Base, BaseModel):
2666 2666 __tablename__ = 'user_user_group_to_perm'
2667 2667 __table_args__ = (
2668 2668 UniqueConstraint('user_id', 'user_group_id', 'permission_id'),
2669 2669 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2670 2670 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2671 2671 )
2672 2672 user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2673 2673 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2674 2674 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2675 2675 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2676 2676
2677 2677 user = relationship('User')
2678 2678 user_group = relationship('UserGroup')
2679 2679 permission = relationship('Permission')
2680 2680
2681 2681 @classmethod
2682 2682 def create(cls, user, user_group, permission):
2683 2683 n = cls()
2684 2684 n.user = user
2685 2685 n.user_group = user_group
2686 2686 n.permission = permission
2687 2687 Session().add(n)
2688 2688 return n
2689 2689
2690 2690 def __unicode__(self):
2691 2691 return u'<%s => %s >' % (self.user, self.user_group)
2692 2692
2693 2693
2694 2694 class UserToPerm(Base, BaseModel):
2695 2695 __tablename__ = 'user_to_perm'
2696 2696 __table_args__ = (
2697 2697 UniqueConstraint('user_id', 'permission_id'),
2698 2698 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2699 2699 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2700 2700 )
2701 2701 user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2702 2702 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2703 2703 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2704 2704
2705 2705 user = relationship('User')
2706 2706 permission = relationship('Permission', lazy='joined')
2707 2707
2708 2708 def __unicode__(self):
2709 2709 return u'<%s => %s >' % (self.user, self.permission)
2710 2710
2711 2711
2712 2712 class UserGroupRepoToPerm(Base, BaseModel):
2713 2713 __tablename__ = 'users_group_repo_to_perm'
2714 2714 __table_args__ = (
2715 2715 UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
2716 2716 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2717 2717 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2718 2718 )
2719 2719 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2720 2720 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2721 2721 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2722 2722 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
2723 2723
2724 2724 users_group = relationship('UserGroup')
2725 2725 permission = relationship('Permission')
2726 2726 repository = relationship('Repository')
2727 2727
2728 2728 @classmethod
2729 2729 def create(cls, users_group, repository, permission):
2730 2730 n = cls()
2731 2731 n.users_group = users_group
2732 2732 n.repository = repository
2733 2733 n.permission = permission
2734 2734 Session().add(n)
2735 2735 return n
2736 2736
2737 2737 def __unicode__(self):
2738 2738 return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)
2739 2739
2740 2740
2741 2741 class UserGroupUserGroupToPerm(Base, BaseModel):
2742 2742 __tablename__ = 'user_group_user_group_to_perm'
2743 2743 __table_args__ = (
2744 2744 UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),
2745 2745 CheckConstraint('target_user_group_id != user_group_id'),
2746 2746 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2747 2747 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2748 2748 )
2749 2749 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)
2750 2750 target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2751 2751 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2752 2752 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2753 2753
2754 2754 target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')
2755 2755 user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')
2756 2756 permission = relationship('Permission')
2757 2757
2758 2758 @classmethod
2759 2759 def create(cls, target_user_group, user_group, permission):
2760 2760 n = cls()
2761 2761 n.target_user_group = target_user_group
2762 2762 n.user_group = user_group
2763 2763 n.permission = permission
2764 2764 Session().add(n)
2765 2765 return n
2766 2766
2767 2767 def __unicode__(self):
2768 2768 return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)
2769 2769
2770 2770
2771 2771 class UserGroupToPerm(Base, BaseModel):
2772 2772 __tablename__ = 'users_group_to_perm'
2773 2773 __table_args__ = (
2774 2774 UniqueConstraint('users_group_id', 'permission_id',),
2775 2775 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2776 2776 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2777 2777 )
2778 2778 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2779 2779 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2780 2780 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2781 2781
2782 2782 users_group = relationship('UserGroup')
2783 2783 permission = relationship('Permission')
2784 2784
2785 2785
2786 2786 class UserRepoGroupToPerm(Base, BaseModel):
2787 2787 __tablename__ = 'user_repo_group_to_perm'
2788 2788 __table_args__ = (
2789 2789 UniqueConstraint('user_id', 'group_id', 'permission_id'),
2790 2790 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2791 2791 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2792 2792 )
2793 2793
2794 2794 group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2795 2795 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2796 2796 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
2797 2797 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2798 2798
2799 2799 user = relationship('User')
2800 2800 group = relationship('RepoGroup')
2801 2801 permission = relationship('Permission')
2802 2802
2803 2803 @classmethod
2804 2804 def create(cls, user, repository_group, permission):
2805 2805 n = cls()
2806 2806 n.user = user
2807 2807 n.group = repository_group
2808 2808 n.permission = permission
2809 2809 Session().add(n)
2810 2810 return n
2811 2811
2812 2812
2813 2813 class UserGroupRepoGroupToPerm(Base, BaseModel):
2814 2814 __tablename__ = 'users_group_repo_group_to_perm'
2815 2815 __table_args__ = (
2816 2816 UniqueConstraint('users_group_id', 'group_id'),
2817 2817 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2818 2818 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2819 2819 )
2820 2820
2821 2821 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)
2822 2822 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
2823 2823 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
2824 2824 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
2825 2825
2826 2826 users_group = relationship('UserGroup')
2827 2827 permission = relationship('Permission')
2828 2828 group = relationship('RepoGroup')
2829 2829
2830 2830 @classmethod
2831 2831 def create(cls, user_group, repository_group, permission):
2832 2832 n = cls()
2833 2833 n.users_group = user_group
2834 2834 n.group = repository_group
2835 2835 n.permission = permission
2836 2836 Session().add(n)
2837 2837 return n
2838 2838
2839 2839 def __unicode__(self):
2840 2840 return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)
2841 2841
2842 2842
2843 2843 class Statistics(Base, BaseModel):
2844 2844 __tablename__ = 'statistics'
2845 2845 __table_args__ = (
2846 2846 UniqueConstraint('repository_id'),
2847 2847 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2848 2848 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2849 2849 )
2850 2850 stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2851 2851 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)
2852 2852 stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)
2853 2853 commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data
2854 2854 commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data
2855 2855 languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data
2856 2856
2857 2857 repository = relationship('Repository', single_parent=True)
2858 2858
2859 2859
2860 2860 class UserFollowing(Base, BaseModel):
2861 2861 __tablename__ = 'user_followings'
2862 2862 __table_args__ = (
2863 2863 UniqueConstraint('user_id', 'follows_repository_id'),
2864 2864 UniqueConstraint('user_id', 'follows_user_id'),
2865 2865 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2866 2866 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
2867 2867 )
2868 2868
2869 2869 user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2870 2870 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
2871 2871 follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)
2872 2872 follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
2873 2873 follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
2874 2874
2875 2875 user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')
2876 2876
2877 2877 follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')
2878 2878 follows_repository = relationship('Repository', order_by='Repository.repo_name')
2879 2879
2880 2880 @classmethod
2881 2881 def get_repo_followers(cls, repo_id):
2882 2882 return cls.query().filter(cls.follows_repo_id == repo_id)
2883 2883
2884 2884
2885 2885 class CacheKey(Base, BaseModel):
2886 2886 __tablename__ = 'cache_invalidation'
2887 2887 __table_args__ = (
2888 2888 UniqueConstraint('cache_key'),
2889 2889 Index('key_idx', 'cache_key'),
2890 2890 {'extend_existing': True, 'mysql_engine': 'InnoDB',
2891 2891 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
2892 2892 )
2893 2893 CACHE_TYPE_ATOM = 'ATOM'
2894 2894 CACHE_TYPE_RSS = 'RSS'
2895 2895 CACHE_TYPE_README = 'README'
2896 2896
2897 2897 cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2898 2898 cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None)
2899 2899 cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None)
2900 2900 cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)
2901 2901
2902 2902 def __init__(self, cache_key, cache_args=''):
2903 2903 self.cache_key = cache_key
2904 2904 self.cache_args = cache_args
2905 2905 self.cache_active = False
2906 2906
2907 2907 def __unicode__(self):
2908 2908 return u"<%s('%s:%s[%s]')>" % (
2909 2909 self.__class__.__name__,
2910 2910 self.cache_id, self.cache_key, self.cache_active)
2911 2911
2912 2912 def _cache_key_partition(self):
2913 2913 prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)
2914 2914 return prefix, repo_name, suffix
2915 2915
2916 2916 def get_prefix(self):
2917 2917 """
2918 2918 Try to extract prefix from existing cache key. The key could consist
2919 2919 of prefix, repo_name, suffix
2920 2920 """
2921 2921 # this returns prefix, repo_name, suffix
2922 2922 return self._cache_key_partition()[0]
2923 2923
2924 2924 def get_suffix(self):
2925 2925 """
2926 2926 get suffix that might have been used in _get_cache_key to
2927 2927 generate self.cache_key. Only used for informational purposes
2928 2928 in repo_edit.mako.
2929 2929 """
2930 2930 # prefix, repo_name, suffix
2931 2931 return self._cache_key_partition()[2]
2932 2932
2933 2933 @classmethod
2934 2934 def delete_all_cache(cls):
2935 2935 """
2936 2936 Delete all cache keys from database.
2937 2937 Should only be run when all instances are down and all entries
2938 2938 thus stale.
2939 2939 """
2940 2940 cls.query().delete()
2941 2941 Session().commit()
2942 2942
2943 2943 @classmethod
2944 2944 def get_cache_key(cls, repo_name, cache_type):
2945 2945 """
2946 2946
2947 2947 Generate a cache key for this process of RhodeCode instance.
2948 2948 Prefix most likely will be process id or maybe explicitly set
2949 2949 instance_id from .ini file.
2950 2950 """
2951 2951 import rhodecode
2952 2952 prefix = safe_unicode(rhodecode.CONFIG.get('instance_id') or '')
2953 2953
2954 2954 repo_as_unicode = safe_unicode(repo_name)
2955 2955 key = u'{}_{}'.format(repo_as_unicode, cache_type) \
2956 2956 if cache_type else repo_as_unicode
2957 2957
2958 2958 return u'{}{}'.format(prefix, key)
2959 2959
2960 2960 @classmethod
2961 2961 def set_invalidate(cls, repo_name, delete=False):
2962 2962 """
2963 2963 Mark all caches of a repo as invalid in the database.
2964 2964 """
2965 2965
2966 2966 try:
2967 2967 qry = Session().query(cls).filter(cls.cache_args == repo_name)
2968 2968 if delete:
2969 2969 log.debug('cache objects deleted for repo %s',
2970 2970 safe_str(repo_name))
2971 2971 qry.delete()
2972 2972 else:
2973 2973 log.debug('cache objects marked as invalid for repo %s',
2974 2974 safe_str(repo_name))
2975 2975 qry.update({"cache_active": False})
2976 2976
2977 2977 Session().commit()
2978 2978 except Exception:
2979 2979 log.exception(
2980 2980 'Cache key invalidation failed for repository %s',
2981 2981 safe_str(repo_name))
2982 2982 Session().rollback()
2983 2983
2984 2984 @classmethod
2985 2985 def get_active_cache(cls, cache_key):
2986 2986 inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()
2987 2987 if inv_obj:
2988 2988 return inv_obj
2989 2989 return None
2990 2990
2991 2991 @classmethod
2992 2992 def repo_context_cache(cls, compute_func, repo_name, cache_type,
2993 2993 thread_scoped=False):
2994 2994 """
2995 2995 @cache_region('long_term')
2996 2996 def _heavy_calculation(cache_key):
2997 2997 return 'result'
2998 2998
2999 2999 cache_context = CacheKey.repo_context_cache(
3000 3000 _heavy_calculation, repo_name, cache_type)
3001 3001
3002 3002 with cache_context as context:
3003 3003 context.invalidate()
3004 3004 computed = context.compute()
3005 3005
3006 3006 assert computed == 'result'
3007 3007 """
3008 3008 from rhodecode.lib import caches
3009 3009 return caches.InvalidationContext(
3010 3010 compute_func, repo_name, cache_type, thread_scoped=thread_scoped)
3011 3011
3012 3012
3013 3013 class ChangesetComment(Base, BaseModel):
3014 3014 __tablename__ = 'changeset_comments'
3015 3015 __table_args__ = (
3016 3016 Index('cc_revision_idx', 'revision'),
3017 3017 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3018 3018 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3019 3019 )
3020 3020
3021 3021 COMMENT_OUTDATED = u'comment_outdated'
3022 3022 COMMENT_TYPE_NOTE = u'note'
3023 3023 COMMENT_TYPE_TODO = u'todo'
3024 3024 COMMENT_TYPES = [COMMENT_TYPE_NOTE, COMMENT_TYPE_TODO]
3025 3025
3026 3026 comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)
3027 3027 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
3028 3028 revision = Column('revision', String(40), nullable=True)
3029 3029 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
3030 3030 pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True)
3031 3031 line_no = Column('line_no', Unicode(10), nullable=True)
3032 3032 hl_lines = Column('hl_lines', Unicode(512), nullable=True)
3033 3033 f_path = Column('f_path', Unicode(1000), nullable=True)
3034 3034 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
3035 3035 text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)
3036 3036 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3037 3037 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3038 3038 renderer = Column('renderer', Unicode(64), nullable=True)
3039 3039 display_state = Column('display_state', Unicode(128), nullable=True)
3040 3040
3041 3041 comment_type = Column('comment_type', Unicode(128), nullable=True, default=COMMENT_TYPE_NOTE)
3042 3042 resolved_comment_id = Column('resolved_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=True)
3043 3043 resolved_comment = relationship('ChangesetComment', remote_side=comment_id, backref='resolved_by')
3044 3044 author = relationship('User', lazy='joined')
3045 3045 repo = relationship('Repository')
3046 3046 status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan", lazy='joined')
3047 3047 pull_request = relationship('PullRequest', lazy='joined')
3048 3048 pull_request_version = relationship('PullRequestVersion')
3049 3049
3050 3050 @classmethod
3051 3051 def get_users(cls, revision=None, pull_request_id=None):
3052 3052 """
3053 3053 Returns user associated with this ChangesetComment. ie those
3054 3054 who actually commented
3055 3055
3056 3056 :param cls:
3057 3057 :param revision:
3058 3058 """
3059 3059 q = Session().query(User)\
3060 3060 .join(ChangesetComment.author)
3061 3061 if revision:
3062 3062 q = q.filter(cls.revision == revision)
3063 3063 elif pull_request_id:
3064 3064 q = q.filter(cls.pull_request_id == pull_request_id)
3065 3065 return q.all()
3066 3066
3067 3067 @classmethod
3068 3068 def get_index_from_version(cls, pr_version, versions):
3069 3069 num_versions = [x.pull_request_version_id for x in versions]
3070 3070 try:
3071 3071 return num_versions.index(pr_version) +1
3072 3072 except (IndexError, ValueError):
3073 3073 return
3074 3074
3075 3075 @property
3076 3076 def outdated(self):
3077 3077 return self.display_state == self.COMMENT_OUTDATED
3078 3078
3079 3079 def outdated_at_version(self, version):
3080 3080 """
3081 3081 Checks if comment is outdated for given pull request version
3082 3082 """
3083 3083 return self.outdated and self.pull_request_version_id != version
3084 3084
3085 3085 def older_than_version(self, version):
3086 3086 """
3087 3087 Checks if comment is made from previous version than given
3088 3088 """
3089 3089 if version is None:
3090 3090 return self.pull_request_version_id is not None
3091 3091
3092 3092 return self.pull_request_version_id < version
3093 3093
3094 3094 @property
3095 3095 def resolved(self):
3096 3096 return self.resolved_by[0] if self.resolved_by else None
3097 3097
3098 3098 @property
3099 3099 def is_todo(self):
3100 3100 return self.comment_type == self.COMMENT_TYPE_TODO
3101 3101
3102 3102 def get_index_version(self, versions):
3103 3103 return self.get_index_from_version(
3104 3104 self.pull_request_version_id, versions)
3105 3105
3106 3106 def __repr__(self):
3107 3107 if self.comment_id:
3108 3108 return '<DB:Comment #%s>' % self.comment_id
3109 3109 else:
3110 3110 return '<DB:Comment at %#x>' % id(self)
3111 3111
3112 3112
3113 3113 class ChangesetStatus(Base, BaseModel):
3114 3114 __tablename__ = 'changeset_statuses'
3115 3115 __table_args__ = (
3116 3116 Index('cs_revision_idx', 'revision'),
3117 3117 Index('cs_version_idx', 'version'),
3118 3118 UniqueConstraint('repo_id', 'revision', 'version'),
3119 3119 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3120 3120 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3121 3121 )
3122 3122 STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'
3123 3123 STATUS_APPROVED = 'approved'
3124 3124 STATUS_REJECTED = 'rejected'
3125 3125 STATUS_UNDER_REVIEW = 'under_review'
3126 3126
3127 3127 STATUSES = [
3128 3128 (STATUS_NOT_REVIEWED, _("Not Reviewed")), # (no icon) and default
3129 3129 (STATUS_APPROVED, _("Approved")),
3130 3130 (STATUS_REJECTED, _("Rejected")),
3131 3131 (STATUS_UNDER_REVIEW, _("Under Review")),
3132 3132 ]
3133 3133
3134 3134 changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)
3135 3135 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
3136 3136 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)
3137 3137 revision = Column('revision', String(40), nullable=False)
3138 3138 status = Column('status', String(128), nullable=False, default=DEFAULT)
3139 3139 changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))
3140 3140 modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)
3141 3141 version = Column('version', Integer(), nullable=False, default=0)
3142 3142 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
3143 3143
3144 3144 author = relationship('User', lazy='joined')
3145 3145 repo = relationship('Repository')
3146 3146 comment = relationship('ChangesetComment', lazy='joined')
3147 3147 pull_request = relationship('PullRequest', lazy='joined')
3148 3148
3149 3149 def __unicode__(self):
3150 3150 return u"<%s('%s[v%s]:%s')>" % (
3151 3151 self.__class__.__name__,
3152 3152 self.status, self.version, self.author
3153 3153 )
3154 3154
3155 3155 @classmethod
3156 3156 def get_status_lbl(cls, value):
3157 3157 return dict(cls.STATUSES).get(value)
3158 3158
3159 3159 @property
3160 3160 def status_lbl(self):
3161 3161 return ChangesetStatus.get_status_lbl(self.status)
3162 3162
3163 3163
3164 3164 class _PullRequestBase(BaseModel):
3165 3165 """
3166 3166 Common attributes of pull request and version entries.
3167 3167 """
3168 3168
3169 3169 # .status values
3170 3170 STATUS_NEW = u'new'
3171 3171 STATUS_OPEN = u'open'
3172 3172 STATUS_CLOSED = u'closed'
3173 3173
3174 3174 title = Column('title', Unicode(255), nullable=True)
3175 3175 description = Column(
3176 3176 'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),
3177 3177 nullable=True)
3178 3178 # new/open/closed status of pull request (not approve/reject/etc)
3179 3179 status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW)
3180 3180 created_on = Column(
3181 3181 'created_on', DateTime(timezone=False), nullable=False,
3182 3182 default=datetime.datetime.now)
3183 3183 updated_on = Column(
3184 3184 'updated_on', DateTime(timezone=False), nullable=False,
3185 3185 default=datetime.datetime.now)
3186 3186
3187 3187 @declared_attr
3188 3188 def user_id(cls):
3189 3189 return Column(
3190 3190 "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
3191 3191 unique=None)
3192 3192
3193 3193 # 500 revisions max
3194 3194 _revisions = Column(
3195 3195 'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql'))
3196 3196
3197 3197 @declared_attr
3198 3198 def source_repo_id(cls):
3199 3199 # TODO: dan: rename column to source_repo_id
3200 3200 return Column(
3201 3201 'org_repo_id', Integer(), ForeignKey('repositories.repo_id'),
3202 3202 nullable=False)
3203 3203
3204 3204 source_ref = Column('org_ref', Unicode(255), nullable=False)
3205 3205
3206 3206 @declared_attr
3207 3207 def target_repo_id(cls):
3208 3208 # TODO: dan: rename column to target_repo_id
3209 3209 return Column(
3210 3210 'other_repo_id', Integer(), ForeignKey('repositories.repo_id'),
3211 3211 nullable=False)
3212 3212
3213 3213 target_ref = Column('other_ref', Unicode(255), nullable=False)
3214 3214 _shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True)
3215 3215
3216 3216 # TODO: dan: rename column to last_merge_source_rev
3217 3217 _last_merge_source_rev = Column(
3218 3218 'last_merge_org_rev', String(40), nullable=True)
3219 3219 # TODO: dan: rename column to last_merge_target_rev
3220 3220 _last_merge_target_rev = Column(
3221 3221 'last_merge_other_rev', String(40), nullable=True)
3222 3222 _last_merge_status = Column('merge_status', Integer(), nullable=True)
3223 3223 merge_rev = Column('merge_rev', String(40), nullable=True)
3224 3224
3225 3225 @hybrid_property
3226 3226 def revisions(self):
3227 3227 return self._revisions.split(':') if self._revisions else []
3228 3228
3229 3229 @revisions.setter
3230 3230 def revisions(self, val):
3231 3231 self._revisions = ':'.join(val)
3232 3232
3233 3233 @declared_attr
3234 3234 def author(cls):
3235 3235 return relationship('User', lazy='joined')
3236 3236
3237 3237 @declared_attr
3238 3238 def source_repo(cls):
3239 3239 return relationship(
3240 3240 'Repository',
3241 3241 primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__)
3242 3242
3243 3243 @property
3244 3244 def source_ref_parts(self):
3245 3245 return self.unicode_to_reference(self.source_ref)
3246 3246
3247 3247 @declared_attr
3248 3248 def target_repo(cls):
3249 3249 return relationship(
3250 3250 'Repository',
3251 3251 primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__)
3252 3252
3253 3253 @property
3254 3254 def target_ref_parts(self):
3255 3255 return self.unicode_to_reference(self.target_ref)
3256 3256
3257 3257 @property
3258 3258 def shadow_merge_ref(self):
3259 3259 return self.unicode_to_reference(self._shadow_merge_ref)
3260 3260
3261 3261 @shadow_merge_ref.setter
3262 3262 def shadow_merge_ref(self, ref):
3263 3263 self._shadow_merge_ref = self.reference_to_unicode(ref)
3264 3264
3265 3265 def unicode_to_reference(self, raw):
3266 3266 """
3267 3267 Convert a unicode (or string) to a reference object.
3268 3268 If unicode evaluates to False it returns None.
3269 3269 """
3270 3270 if raw:
3271 3271 refs = raw.split(':')
3272 3272 return Reference(*refs)
3273 3273 else:
3274 3274 return None
3275 3275
3276 3276 def reference_to_unicode(self, ref):
3277 3277 """
3278 3278 Convert a reference object to unicode.
3279 3279 If reference is None it returns None.
3280 3280 """
3281 3281 if ref:
3282 3282 return u':'.join(ref)
3283 3283 else:
3284 3284 return None
3285 3285
3286 3286 def get_api_data(self):
3287 3287 from rhodecode.model.pull_request import PullRequestModel
3288 3288 pull_request = self
3289 3289 merge_status = PullRequestModel().merge_status(pull_request)
3290 3290
3291 3291 pull_request_url = url(
3292 3292 'pullrequest_show', repo_name=self.target_repo.repo_name,
3293 3293 pull_request_id=self.pull_request_id, qualified=True)
3294 3294
3295 3295 merge_data = {
3296 3296 'clone_url': PullRequestModel().get_shadow_clone_url(pull_request),
3297 3297 'reference': (
3298 3298 pull_request.shadow_merge_ref._asdict()
3299 3299 if pull_request.shadow_merge_ref else None),
3300 3300 }
3301 3301
3302 3302 data = {
3303 3303 'pull_request_id': pull_request.pull_request_id,
3304 3304 'url': pull_request_url,
3305 3305 'title': pull_request.title,
3306 3306 'description': pull_request.description,
3307 3307 'status': pull_request.status,
3308 3308 'created_on': pull_request.created_on,
3309 3309 'updated_on': pull_request.updated_on,
3310 3310 'commit_ids': pull_request.revisions,
3311 3311 'review_status': pull_request.calculated_review_status(),
3312 3312 'mergeable': {
3313 3313 'status': merge_status[0],
3314 3314 'message': unicode(merge_status[1]),
3315 3315 },
3316 3316 'source': {
3317 3317 'clone_url': pull_request.source_repo.clone_url(),
3318 3318 'repository': pull_request.source_repo.repo_name,
3319 3319 'reference': {
3320 3320 'name': pull_request.source_ref_parts.name,
3321 3321 'type': pull_request.source_ref_parts.type,
3322 3322 'commit_id': pull_request.source_ref_parts.commit_id,
3323 3323 },
3324 3324 },
3325 3325 'target': {
3326 3326 'clone_url': pull_request.target_repo.clone_url(),
3327 3327 'repository': pull_request.target_repo.repo_name,
3328 3328 'reference': {
3329 3329 'name': pull_request.target_ref_parts.name,
3330 3330 'type': pull_request.target_ref_parts.type,
3331 3331 'commit_id': pull_request.target_ref_parts.commit_id,
3332 3332 },
3333 3333 },
3334 3334 'merge': merge_data,
3335 3335 'author': pull_request.author.get_api_data(include_secrets=False,
3336 3336 details='basic'),
3337 3337 'reviewers': [
3338 3338 {
3339 3339 'user': reviewer.get_api_data(include_secrets=False,
3340 3340 details='basic'),
3341 3341 'reasons': reasons,
3342 3342 'review_status': st[0][1].status if st else 'not_reviewed',
3343 3343 }
3344 3344 for reviewer, reasons, st in pull_request.reviewers_statuses()
3345 3345 ]
3346 3346 }
3347 3347
3348 3348 return data
3349 3349
3350 3350
3351 3351 class PullRequest(Base, _PullRequestBase):
3352 3352 __tablename__ = 'pull_requests'
3353 3353 __table_args__ = (
3354 3354 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3355 3355 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3356 3356 )
3357 3357
3358 3358 pull_request_id = Column(
3359 3359 'pull_request_id', Integer(), nullable=False, primary_key=True)
3360 3360
3361 3361 def __repr__(self):
3362 3362 if self.pull_request_id:
3363 3363 return '<DB:PullRequest #%s>' % self.pull_request_id
3364 3364 else:
3365 3365 return '<DB:PullRequest at %#x>' % id(self)
3366 3366
3367 3367 reviewers = relationship('PullRequestReviewers',
3368 3368 cascade="all, delete, delete-orphan")
3369 3369 statuses = relationship('ChangesetStatus')
3370 3370 comments = relationship('ChangesetComment',
3371 3371 cascade="all, delete, delete-orphan")
3372 3372 versions = relationship('PullRequestVersion',
3373 3373 cascade="all, delete, delete-orphan",
3374 3374 lazy='dynamic')
3375 3375
3376 3376 @classmethod
3377 3377 def get_pr_display_object(cls, pull_request_obj, org_pull_request_obj,
3378 3378 internal_methods=None):
3379 3379
3380 3380 class PullRequestDisplay(object):
3381 3381 """
3382 3382 Special object wrapper for showing PullRequest data via Versions
3383 3383 It mimics PR object as close as possible. This is read only object
3384 3384 just for display
3385 3385 """
3386 3386
3387 3387 def __init__(self, attrs, internal=None):
3388 3388 self.attrs = attrs
3389 3389 # internal have priority over the given ones via attrs
3390 3390 self.internal = internal or ['versions']
3391 3391
3392 3392 def __getattr__(self, item):
3393 3393 if item in self.internal:
3394 3394 return getattr(self, item)
3395 3395 try:
3396 3396 return self.attrs[item]
3397 3397 except KeyError:
3398 3398 raise AttributeError(
3399 3399 '%s object has no attribute %s' % (self, item))
3400 3400
3401 3401 def __repr__(self):
3402 3402 return '<DB:PullRequestDisplay #%s>' % self.attrs.get('pull_request_id')
3403 3403
3404 3404 def versions(self):
3405 3405 return pull_request_obj.versions.order_by(
3406 3406 PullRequestVersion.pull_request_version_id).all()
3407 3407
3408 3408 def is_closed(self):
3409 3409 return pull_request_obj.is_closed()
3410 3410
3411 3411 @property
3412 3412 def pull_request_version_id(self):
3413 3413 return getattr(pull_request_obj, 'pull_request_version_id', None)
3414 3414
3415 3415 attrs = StrictAttributeDict(pull_request_obj.get_api_data())
3416 3416
3417 3417 attrs.author = StrictAttributeDict(
3418 3418 pull_request_obj.author.get_api_data())
3419 3419 if pull_request_obj.target_repo:
3420 3420 attrs.target_repo = StrictAttributeDict(
3421 3421 pull_request_obj.target_repo.get_api_data())
3422 3422 attrs.target_repo.clone_url = pull_request_obj.target_repo.clone_url
3423 3423
3424 3424 if pull_request_obj.source_repo:
3425 3425 attrs.source_repo = StrictAttributeDict(
3426 3426 pull_request_obj.source_repo.get_api_data())
3427 3427 attrs.source_repo.clone_url = pull_request_obj.source_repo.clone_url
3428 3428
3429 3429 attrs.source_ref_parts = pull_request_obj.source_ref_parts
3430 3430 attrs.target_ref_parts = pull_request_obj.target_ref_parts
3431 3431 attrs.revisions = pull_request_obj.revisions
3432 3432
3433 3433 attrs.shadow_merge_ref = org_pull_request_obj.shadow_merge_ref
3434 3434
3435 3435 return PullRequestDisplay(attrs, internal=internal_methods)
3436 3436
3437 3437 def is_closed(self):
3438 3438 return self.status == self.STATUS_CLOSED
3439 3439
3440 3440 def __json__(self):
3441 3441 return {
3442 3442 'revisions': self.revisions,
3443 3443 }
3444 3444
3445 3445 def calculated_review_status(self):
3446 3446 from rhodecode.model.changeset_status import ChangesetStatusModel
3447 3447 return ChangesetStatusModel().calculated_review_status(self)
3448 3448
3449 3449 def reviewers_statuses(self):
3450 3450 from rhodecode.model.changeset_status import ChangesetStatusModel
3451 3451 return ChangesetStatusModel().reviewers_statuses(self)
3452 3452
3453 3453 @property
3454 3454 def workspace_id(self):
3455 3455 from rhodecode.model.pull_request import PullRequestModel
3456 3456 return PullRequestModel()._workspace_id(self)
3457 3457
3458 3458 def get_shadow_repo(self):
3459 3459 workspace_id = self.workspace_id
3460 3460 vcs_obj = self.target_repo.scm_instance()
3461 3461 shadow_repository_path = vcs_obj._get_shadow_repository_path(
3462 3462 workspace_id)
3463 3463 return vcs_obj._get_shadow_instance(shadow_repository_path)
3464 3464
3465 3465
3466 3466 class PullRequestVersion(Base, _PullRequestBase):
3467 3467 __tablename__ = 'pull_request_versions'
3468 3468 __table_args__ = (
3469 3469 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3470 3470 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3471 3471 )
3472 3472
3473 3473 pull_request_version_id = Column(
3474 3474 'pull_request_version_id', Integer(), nullable=False, primary_key=True)
3475 3475 pull_request_id = Column(
3476 3476 'pull_request_id', Integer(),
3477 3477 ForeignKey('pull_requests.pull_request_id'), nullable=False)
3478 3478 pull_request = relationship('PullRequest')
3479 3479
3480 3480 def __repr__(self):
3481 3481 if self.pull_request_version_id:
3482 3482 return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id
3483 3483 else:
3484 3484 return '<DB:PullRequestVersion at %#x>' % id(self)
3485 3485
3486 3486 @property
3487 3487 def reviewers(self):
3488 3488 return self.pull_request.reviewers
3489 3489
3490 3490 @property
3491 3491 def versions(self):
3492 3492 return self.pull_request.versions
3493 3493
3494 3494 def is_closed(self):
3495 3495 # calculate from original
3496 3496 return self.pull_request.status == self.STATUS_CLOSED
3497 3497
3498 3498 def calculated_review_status(self):
3499 3499 return self.pull_request.calculated_review_status()
3500 3500
3501 3501 def reviewers_statuses(self):
3502 3502 return self.pull_request.reviewers_statuses()
3503 3503
3504 3504
3505 3505 class PullRequestReviewers(Base, BaseModel):
3506 3506 __tablename__ = 'pull_request_reviewers'
3507 3507 __table_args__ = (
3508 3508 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3509 3509 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3510 3510 )
3511 3511
3512 3512 def __init__(self, user=None, pull_request=None, reasons=None):
3513 3513 self.user = user
3514 3514 self.pull_request = pull_request
3515 3515 self.reasons = reasons or []
3516 3516
3517 3517 @hybrid_property
3518 3518 def reasons(self):
3519 3519 if not self._reasons:
3520 3520 return []
3521 3521 return self._reasons
3522 3522
3523 3523 @reasons.setter
3524 3524 def reasons(self, val):
3525 3525 val = val or []
3526 3526 if any(not isinstance(x, basestring) for x in val):
3527 3527 raise Exception('invalid reasons type, must be list of strings')
3528 3528 self._reasons = val
3529 3529
3530 3530 pull_requests_reviewers_id = Column(
3531 3531 'pull_requests_reviewers_id', Integer(), nullable=False,
3532 3532 primary_key=True)
3533 3533 pull_request_id = Column(
3534 3534 "pull_request_id", Integer(),
3535 3535 ForeignKey('pull_requests.pull_request_id'), nullable=False)
3536 3536 user_id = Column(
3537 3537 "user_id", Integer(), ForeignKey('users.user_id'), nullable=True)
3538 3538 _reasons = Column(
3539 3539 'reason', MutationList.as_mutable(
3540 3540 JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))
3541 3541
3542 3542 user = relationship('User')
3543 3543 pull_request = relationship('PullRequest')
3544 3544
3545 3545
3546 3546 class Notification(Base, BaseModel):
3547 3547 __tablename__ = 'notifications'
3548 3548 __table_args__ = (
3549 3549 Index('notification_type_idx', 'type'),
3550 3550 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3551 3551 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3552 3552 )
3553 3553
3554 3554 TYPE_CHANGESET_COMMENT = u'cs_comment'
3555 3555 TYPE_MESSAGE = u'message'
3556 3556 TYPE_MENTION = u'mention'
3557 3557 TYPE_REGISTRATION = u'registration'
3558 3558 TYPE_PULL_REQUEST = u'pull_request'
3559 3559 TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'
3560 3560
3561 3561 notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)
3562 3562 subject = Column('subject', Unicode(512), nullable=True)
3563 3563 body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)
3564 3564 created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)
3565 3565 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3566 3566 type_ = Column('type', Unicode(255))
3567 3567
3568 3568 created_by_user = relationship('User')
3569 3569 notifications_to_users = relationship('UserNotification', lazy='joined',
3570 3570 cascade="all, delete, delete-orphan")
3571 3571
3572 3572 @property
3573 3573 def recipients(self):
3574 3574 return [x.user for x in UserNotification.query()\
3575 3575 .filter(UserNotification.notification == self)\
3576 3576 .order_by(UserNotification.user_id.asc()).all()]
3577 3577
3578 3578 @classmethod
3579 3579 def create(cls, created_by, subject, body, recipients, type_=None):
3580 3580 if type_ is None:
3581 3581 type_ = Notification.TYPE_MESSAGE
3582 3582
3583 3583 notification = cls()
3584 3584 notification.created_by_user = created_by
3585 3585 notification.subject = subject
3586 3586 notification.body = body
3587 3587 notification.type_ = type_
3588 3588 notification.created_on = datetime.datetime.now()
3589 3589
3590 3590 for u in recipients:
3591 3591 assoc = UserNotification()
3592 3592 assoc.notification = notification
3593 3593
3594 3594 # if created_by is inside recipients mark his notification
3595 3595 # as read
3596 3596 if u.user_id == created_by.user_id:
3597 3597 assoc.read = True
3598 3598
3599 3599 u.notifications.append(assoc)
3600 3600 Session().add(notification)
3601 3601
3602 3602 return notification
3603 3603
3604 3604 @property
3605 3605 def description(self):
3606 3606 from rhodecode.model.notification import NotificationModel
3607 3607 return NotificationModel().make_description(self)
3608 3608
3609 3609
3610 3610 class UserNotification(Base, BaseModel):
3611 3611 __tablename__ = 'user_to_notification'
3612 3612 __table_args__ = (
3613 3613 UniqueConstraint('user_id', 'notification_id'),
3614 3614 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3615 3615 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3616 3616 )
3617 3617 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
3618 3618 notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)
3619 3619 read = Column('read', Boolean, default=False)
3620 3620 sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)
3621 3621
3622 3622 user = relationship('User', lazy="joined")
3623 3623 notification = relationship('Notification', lazy="joined",
3624 3624 order_by=lambda: Notification.created_on.desc(),)
3625 3625
3626 3626 def mark_as_read(self):
3627 3627 self.read = True
3628 3628 Session().add(self)
3629 3629
3630 3630
3631 3631 class Gist(Base, BaseModel):
3632 3632 __tablename__ = 'gists'
3633 3633 __table_args__ = (
3634 3634 Index('g_gist_access_id_idx', 'gist_access_id'),
3635 3635 Index('g_created_on_idx', 'created_on'),
3636 3636 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3637 3637 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3638 3638 )
3639 3639 GIST_PUBLIC = u'public'
3640 3640 GIST_PRIVATE = u'private'
3641 3641 DEFAULT_FILENAME = u'gistfile1.txt'
3642 3642
3643 3643 ACL_LEVEL_PUBLIC = u'acl_public'
3644 3644 ACL_LEVEL_PRIVATE = u'acl_private'
3645 3645
3646 3646 gist_id = Column('gist_id', Integer(), primary_key=True)
3647 3647 gist_access_id = Column('gist_access_id', Unicode(250))
3648 3648 gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
3649 3649 gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True)
3650 3650 gist_expires = Column('gist_expires', Float(53), nullable=False)
3651 3651 gist_type = Column('gist_type', Unicode(128), nullable=False)
3652 3652 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3653 3653 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3654 3654 acl_level = Column('acl_level', Unicode(128), nullable=True)
3655 3655
3656 3656 owner = relationship('User')
3657 3657
3658 3658 def __repr__(self):
3659 3659 return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)
3660 3660
3661 3661 @classmethod
3662 3662 def get_or_404(cls, id_, pyramid_exc=False):
3663 3663
3664 3664 if pyramid_exc:
3665 3665 from pyramid.httpexceptions import HTTPNotFound
3666 3666 else:
3667 3667 from webob.exc import HTTPNotFound
3668 3668
3669 3669 res = cls.query().filter(cls.gist_access_id == id_).scalar()
3670 3670 if not res:
3671 3671 raise HTTPNotFound
3672 3672 return res
3673 3673
3674 3674 @classmethod
3675 3675 def get_by_access_id(cls, gist_access_id):
3676 3676 return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()
3677 3677
3678 3678 def gist_url(self):
3679 3679 import rhodecode
3680 3680 alias_url = rhodecode.CONFIG.get('gist_alias_url')
3681 3681 if alias_url:
3682 3682 return alias_url.replace('{gistid}', self.gist_access_id)
3683 3683
3684 3684 return url('gist', gist_id=self.gist_access_id, qualified=True)
3685 3685
3686 3686 @classmethod
3687 3687 def base_path(cls):
3688 3688 """
3689 3689 Returns base path when all gists are stored
3690 3690
3691 3691 :param cls:
3692 3692 """
3693 3693 from rhodecode.model.gist import GIST_STORE_LOC
3694 3694 q = Session().query(RhodeCodeUi)\
3695 3695 .filter(RhodeCodeUi.ui_key == URL_SEP)
3696 3696 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
3697 3697 return os.path.join(q.one().ui_value, GIST_STORE_LOC)
3698 3698
3699 3699 def get_api_data(self):
3700 3700 """
3701 3701 Common function for generating gist related data for API
3702 3702 """
3703 3703 gist = self
3704 3704 data = {
3705 3705 'gist_id': gist.gist_id,
3706 3706 'type': gist.gist_type,
3707 3707 'access_id': gist.gist_access_id,
3708 3708 'description': gist.gist_description,
3709 3709 'url': gist.gist_url(),
3710 3710 'expires': gist.gist_expires,
3711 3711 'created_on': gist.created_on,
3712 3712 'modified_at': gist.modified_at,
3713 3713 'content': None,
3714 3714 'acl_level': gist.acl_level,
3715 3715 }
3716 3716 return data
3717 3717
3718 3718 def __json__(self):
3719 3719 data = dict(
3720 3720 )
3721 3721 data.update(self.get_api_data())
3722 3722 return data
3723 3723 # SCM functions
3724 3724
3725 3725 def scm_instance(self, **kwargs):
3726 3726 full_repo_path = os.path.join(self.base_path(), self.gist_access_id)
3727 3727 return get_vcs_instance(
3728 3728 repo_path=safe_str(full_repo_path), create=False)
3729 3729
3730 3730
3731 3731 class ExternalIdentity(Base, BaseModel):
3732 3732 __tablename__ = 'external_identities'
3733 3733 __table_args__ = (
3734 3734 Index('local_user_id_idx', 'local_user_id'),
3735 3735 Index('external_id_idx', 'external_id'),
3736 3736 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3737 3737 'mysql_charset': 'utf8'})
3738 3738
3739 3739 external_id = Column('external_id', Unicode(255), default=u'',
3740 3740 primary_key=True)
3741 3741 external_username = Column('external_username', Unicode(1024), default=u'')
3742 3742 local_user_id = Column('local_user_id', Integer(),
3743 3743 ForeignKey('users.user_id'), primary_key=True)
3744 3744 provider_name = Column('provider_name', Unicode(255), default=u'',
3745 3745 primary_key=True)
3746 3746 access_token = Column('access_token', String(1024), default=u'')
3747 3747 alt_token = Column('alt_token', String(1024), default=u'')
3748 3748 token_secret = Column('token_secret', String(1024), default=u'')
3749 3749
3750 3750 @classmethod
3751 3751 def by_external_id_and_provider(cls, external_id, provider_name,
3752 3752 local_user_id=None):
3753 3753 """
3754 3754 Returns ExternalIdentity instance based on search params
3755 3755
3756 3756 :param external_id:
3757 3757 :param provider_name:
3758 3758 :return: ExternalIdentity
3759 3759 """
3760 3760 query = cls.query()
3761 3761 query = query.filter(cls.external_id == external_id)
3762 3762 query = query.filter(cls.provider_name == provider_name)
3763 3763 if local_user_id:
3764 3764 query = query.filter(cls.local_user_id == local_user_id)
3765 3765 return query.first()
3766 3766
3767 3767 @classmethod
3768 3768 def user_by_external_id_and_provider(cls, external_id, provider_name):
3769 3769 """
3770 3770 Returns User instance based on search params
3771 3771
3772 3772 :param external_id:
3773 3773 :param provider_name:
3774 3774 :return: User
3775 3775 """
3776 3776 query = User.query()
3777 3777 query = query.filter(cls.external_id == external_id)
3778 3778 query = query.filter(cls.provider_name == provider_name)
3779 3779 query = query.filter(User.user_id == cls.local_user_id)
3780 3780 return query.first()
3781 3781
3782 3782 @classmethod
3783 3783 def by_local_user_id(cls, local_user_id):
3784 3784 """
3785 3785 Returns all tokens for user
3786 3786
3787 3787 :param local_user_id:
3788 3788 :return: ExternalIdentity
3789 3789 """
3790 3790 query = cls.query()
3791 3791 query = query.filter(cls.local_user_id == local_user_id)
3792 3792 return query
3793 3793
3794 3794
3795 3795 class Integration(Base, BaseModel):
3796 3796 __tablename__ = 'integrations'
3797 3797 __table_args__ = (
3798 3798 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3799 3799 'mysql_charset': 'utf8', 'sqlite_autoincrement': True}
3800 3800 )
3801 3801
3802 3802 integration_id = Column('integration_id', Integer(), primary_key=True)
3803 3803 integration_type = Column('integration_type', String(255))
3804 3804 enabled = Column('enabled', Boolean(), nullable=False)
3805 3805 name = Column('name', String(255), nullable=False)
3806 3806 child_repos_only = Column('child_repos_only', Boolean(), nullable=False,
3807 3807 default=False)
3808 3808
3809 3809 settings = Column(
3810 3810 'settings_json', MutationObj.as_mutable(
3811 3811 JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
3812 3812 repo_id = Column(
3813 3813 'repo_id', Integer(), ForeignKey('repositories.repo_id'),
3814 3814 nullable=True, unique=None, default=None)
3815 3815 repo = relationship('Repository', lazy='joined')
3816 3816
3817 3817 repo_group_id = Column(
3818 3818 'repo_group_id', Integer(), ForeignKey('groups.group_id'),
3819 3819 nullable=True, unique=None, default=None)
3820 3820 repo_group = relationship('RepoGroup', lazy='joined')
3821 3821
3822 3822 @property
3823 3823 def scope(self):
3824 3824 if self.repo:
3825 3825 return repr(self.repo)
3826 3826 if self.repo_group:
3827 3827 if self.child_repos_only:
3828 3828 return repr(self.repo_group) + ' (child repos only)'
3829 3829 else:
3830 3830 return repr(self.repo_group) + ' (recursive)'
3831 3831 if self.child_repos_only:
3832 3832 return 'root_repos'
3833 3833 return 'global'
3834 3834
3835 3835 def __repr__(self):
3836 3836 return '<Integration(%r, %r)>' % (self.integration_type, self.scope)
3837 3837
3838 3838
3839 3839 class RepoReviewRuleUser(Base, BaseModel):
3840 3840 __tablename__ = 'repo_review_rules_users'
3841 3841 __table_args__ = (
3842 3842 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3843 3843 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
3844 3844 )
3845 3845 repo_review_rule_user_id = Column(
3846 3846 'repo_review_rule_user_id', Integer(), primary_key=True)
3847 3847 repo_review_rule_id = Column("repo_review_rule_id",
3848 3848 Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
3849 3849 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'),
3850 3850 nullable=False)
3851 3851 user = relationship('User')
3852 3852
3853 3853
3854 3854 class RepoReviewRuleUserGroup(Base, BaseModel):
3855 3855 __tablename__ = 'repo_review_rules_users_groups'
3856 3856 __table_args__ = (
3857 3857 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3858 3858 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
3859 3859 )
3860 3860 repo_review_rule_users_group_id = Column(
3861 3861 'repo_review_rule_users_group_id', Integer(), primary_key=True)
3862 3862 repo_review_rule_id = Column("repo_review_rule_id",
3863 3863 Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
3864 3864 users_group_id = Column("users_group_id", Integer(),
3865 3865 ForeignKey('users_groups.users_group_id'), nullable=False)
3866 3866 users_group = relationship('UserGroup')
3867 3867
3868 3868
3869 3869 class RepoReviewRule(Base, BaseModel):
3870 3870 __tablename__ = 'repo_review_rules'
3871 3871 __table_args__ = (
3872 3872 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3873 3873 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
3874 3874 )
3875 3875
3876 3876 repo_review_rule_id = Column(
3877 3877 'repo_review_rule_id', Integer(), primary_key=True)
3878 3878 repo_id = Column(
3879 3879 "repo_id", Integer(), ForeignKey('repositories.repo_id'))
3880 3880 repo = relationship('Repository', backref='review_rules')
3881 3881
3882 3882 _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),
3883 3883 default=u'*') # glob
3884 3884 _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'),
3885 3885 default=u'*') # glob
3886 3886
3887 3887 use_authors_for_review = Column("use_authors_for_review", Boolean(),
3888 3888 nullable=False, default=False)
3889 3889 rule_users = relationship('RepoReviewRuleUser')
3890 3890 rule_user_groups = relationship('RepoReviewRuleUserGroup')
3891 3891
3892 3892 @hybrid_property
3893 3893 def branch_pattern(self):
3894 3894 return self._branch_pattern or '*'
3895 3895
3896 3896 def _validate_glob(self, value):
3897 3897 re.compile('^' + glob2re(value) + '$')
3898 3898
3899 3899 @branch_pattern.setter
3900 3900 def branch_pattern(self, value):
3901 3901 self._validate_glob(value)
3902 3902 self._branch_pattern = value or '*'
3903 3903
3904 3904 @hybrid_property
3905 3905 def file_pattern(self):
3906 3906 return self._file_pattern or '*'
3907 3907
3908 3908 @file_pattern.setter
3909 3909 def file_pattern(self, value):
3910 3910 self._validate_glob(value)
3911 3911 self._file_pattern = value or '*'
3912 3912
3913 3913 def matches(self, branch, files_changed):
3914 3914 """
3915 3915 Check if this review rule matches a branch/files in a pull request
3916 3916
3917 3917 :param branch: branch name for the commit
3918 3918 :param files_changed: list of file paths changed in the pull request
3919 3919 """
3920 3920
3921 3921 branch = branch or ''
3922 3922 files_changed = files_changed or []
3923 3923
3924 3924 branch_matches = True
3925 3925 if branch:
3926 3926 branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$')
3927 3927 branch_matches = bool(branch_regex.search(branch))
3928 3928
3929 3929 files_matches = True
3930 3930 if self.file_pattern != '*':
3931 3931 files_matches = False
3932 3932 file_regex = re.compile(glob2re(self.file_pattern))
3933 3933 for filename in files_changed:
3934 3934 if file_regex.search(filename):
3935 3935 files_matches = True
3936 3936 break
3937 3937
3938 3938 return branch_matches and files_matches
3939 3939
3940 3940 @property
3941 3941 def review_users(self):
3942 3942 """ Returns the users which this rule applies to """
3943 3943
3944 3944 users = set()
3945 3945 users |= set([
3946 3946 rule_user.user for rule_user in self.rule_users
3947 3947 if rule_user.user.active])
3948 3948 users |= set(
3949 3949 member.user
3950 3950 for rule_user_group in self.rule_user_groups
3951 3951 for member in rule_user_group.users_group.members
3952 3952 if member.user.active
3953 3953 )
3954 3954 return users
3955 3955
3956 3956 def __repr__(self):
3957 3957 return '<RepoReviewerRule(id=%r, repo=%r)>' % (
3958 3958 self.repo_review_rule_id, self.repo)
3959 3959
3960 3960
3961 3961 class DbMigrateVersion(Base, BaseModel):
3962 3962 __tablename__ = 'db_migrate_version'
3963 3963 __table_args__ = (
3964 3964 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3965 3965 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3966 3966 )
3967 3967 repository_id = Column('repository_id', String(250), primary_key=True)
3968 3968 repository_path = Column('repository_path', Text)
3969 3969 version = Column('version', Integer)
3970 3970
3971 3971
3972 3972 class DbSession(Base, BaseModel):
3973 3973 __tablename__ = 'db_session'
3974 3974 __table_args__ = (
3975 3975 {'extend_existing': True, 'mysql_engine': 'InnoDB',
3976 3976 'mysql_charset': 'utf8', 'sqlite_autoincrement': True},
3977 3977 )
3978 3978
3979 3979 def __repr__(self):
3980 3980 return '<DB:DbSession({})>'.format(self.id)
3981 3981
3982 3982 id = Column('id', Integer())
3983 3983 namespace = Column('namespace', String(255), primary_key=True)
3984 3984 accessed = Column('accessed', DateTime, nullable=False)
3985 3985 created = Column('created', DateTime, nullable=False)
3986 3986 data = Column('data', PickleType, nullable=False)
@@ -1,999 +1,993 b''
1 1 # -*- coding: utf-8 -*-
2 2
3 3 # Copyright (C) 2010-2017 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 Repository model for rhodecode
23 23 """
24 24
25 25 import logging
26 26 import os
27 27 import re
28 28 import shutil
29 29 import time
30 30 import traceback
31 31 from datetime import datetime, timedelta
32 32
33 33 from zope.cachedescriptors.property import Lazy as LazyProperty
34 34
35 35 from rhodecode import events
36 36 from rhodecode.lib import helpers as h
37 37 from rhodecode.lib.auth import HasUserGroupPermissionAny
38 38 from rhodecode.lib.caching_query import FromCache
39 39 from rhodecode.lib.exceptions import AttachedForksError
40 40 from rhodecode.lib.hooks_base import log_delete_repository
41 41 from rhodecode.lib.utils import make_db_config
42 42 from rhodecode.lib.utils2 import (
43 43 safe_str, safe_unicode, remove_prefix, obfuscate_url_pw,
44 44 get_current_rhodecode_user, safe_int, datetime_to_time, action_logger_generic)
45 45 from rhodecode.lib.vcs.backends import get_backend
46 46 from rhodecode.model import BaseModel
47 47 from rhodecode.model.db import (
48 48 Repository, UserRepoToPerm, UserGroupRepoToPerm, UserRepoGroupToPerm,
49 49 UserGroupRepoGroupToPerm, User, Permission, Statistics, UserGroup,
50 50 RepoGroup, RepositoryField)
51 51
52 52 from rhodecode.model.settings import VcsSettingsModel
53 53
54 54
55 55 log = logging.getLogger(__name__)
56 56
57 57
58 58 class RepoModel(BaseModel):
59 59
60 60 cls = Repository
61 61
62 62 def _get_user_group(self, users_group):
63 63 return self._get_instance(UserGroup, users_group,
64 64 callback=UserGroup.get_by_group_name)
65 65
66 66 def _get_repo_group(self, repo_group):
67 67 return self._get_instance(RepoGroup, repo_group,
68 68 callback=RepoGroup.get_by_group_name)
69 69
70 70 def _create_default_perms(self, repository, private):
71 71 # create default permission
72 72 default = 'repository.read'
73 73 def_user = User.get_default_user()
74 74 for p in def_user.user_perms:
75 75 if p.permission.permission_name.startswith('repository.'):
76 76 default = p.permission.permission_name
77 77 break
78 78
79 79 default_perm = 'repository.none' if private else default
80 80
81 81 repo_to_perm = UserRepoToPerm()
82 82 repo_to_perm.permission = Permission.get_by_key(default_perm)
83 83
84 84 repo_to_perm.repository = repository
85 85 repo_to_perm.user_id = def_user.user_id
86 86
87 87 return repo_to_perm
88 88
89 89 @LazyProperty
90 90 def repos_path(self):
91 91 """
92 92 Gets the repositories root path from database
93 93 """
94 94 settings_model = VcsSettingsModel(sa=self.sa)
95 95 return settings_model.get_repos_location()
96 96
97 97 def get(self, repo_id, cache=False):
98 98 repo = self.sa.query(Repository) \
99 99 .filter(Repository.repo_id == repo_id)
100 100
101 101 if cache:
102 102 repo = repo.options(FromCache("sql_cache_short",
103 103 "get_repo_%s" % repo_id))
104 104 return repo.scalar()
105 105
106 106 def get_repo(self, repository):
107 107 return self._get_repo(repository)
108 108
109 109 def get_by_repo_name(self, repo_name, cache=False):
110 110 repo = self.sa.query(Repository) \
111 111 .filter(Repository.repo_name == repo_name)
112 112
113 113 if cache:
114 114 repo = repo.options(FromCache("sql_cache_short",
115 115 "get_repo_%s" % repo_name))
116 116 return repo.scalar()
117 117
118 118 def _extract_id_from_repo_name(self, repo_name):
119 119 if repo_name.startswith('/'):
120 120 repo_name = repo_name.lstrip('/')
121 121 by_id_match = re.match(r'^_(\d{1,})', repo_name)
122 122 if by_id_match:
123 123 return by_id_match.groups()[0]
124 124
125 125 def get_repo_by_id(self, repo_name):
126 126 """
127 127 Extracts repo_name by id from special urls.
128 128 Example url is _11/repo_name
129 129
130 130 :param repo_name:
131 131 :return: repo object if matched else None
132 132 """
133 133 try:
134 134 _repo_id = self._extract_id_from_repo_name(repo_name)
135 135 if _repo_id:
136 136 return self.get(_repo_id)
137 137 except Exception:
138 138 log.exception('Failed to extract repo_name from URL')
139 139
140 140 return None
141 141
142 142 def get_repos_for_root(self, root, traverse=False):
143 143 if traverse:
144 144 like_expression = u'{}%'.format(safe_unicode(root))
145 145 repos = Repository.query().filter(
146 146 Repository.repo_name.like(like_expression)).all()
147 147 else:
148 148 if root and not isinstance(root, RepoGroup):
149 149 raise ValueError(
150 150 'Root must be an instance '
151 151 'of RepoGroup, got:{} instead'.format(type(root)))
152 152 repos = Repository.query().filter(Repository.group == root).all()
153 153 return repos
154 154
155 155 def get_url(self, repo):
156 156 return h.url('summary_home', repo_name=safe_str(repo.repo_name),
157 157 qualified=True)
158 158
159 159 @classmethod
160 160 def update_repoinfo(cls, repositories=None):
161 161 if not repositories:
162 162 repositories = Repository.getAll()
163 163 for repo in repositories:
164 164 repo.update_commit_cache()
165 165
166 166 def get_repos_as_dict(self, repo_list=None, admin=False,
167 167 super_user_actions=False):
168 168
169 169 from rhodecode.lib.utils import PartialRenderer
170 170 _render = PartialRenderer('data_table/_dt_elements.mako')
171 171 c = _render.c
172 172
173 173 def quick_menu(repo_name):
174 174 return _render('quick_menu', repo_name)
175 175
176 176 def repo_lnk(name, rtype, rstate, private, fork_of):
177 177 return _render('repo_name', name, rtype, rstate, private, fork_of,
178 178 short_name=not admin, admin=False)
179 179
180 180 def last_change(last_change):
181 181 if admin and isinstance(last_change, datetime) and not last_change.tzinfo:
182 182 last_change = last_change + timedelta(seconds=
183 183 (datetime.now() - datetime.utcnow()).seconds)
184 184 return _render("last_change", last_change)
185 185
186 186 def rss_lnk(repo_name):
187 187 return _render("rss", repo_name)
188 188
189 189 def atom_lnk(repo_name):
190 190 return _render("atom", repo_name)
191 191
192 192 def last_rev(repo_name, cs_cache):
193 193 return _render('revision', repo_name, cs_cache.get('revision'),
194 194 cs_cache.get('raw_id'), cs_cache.get('author'),
195 195 cs_cache.get('message'))
196 196
197 197 def desc(desc):
198 198 if c.visual.stylify_metatags:
199 199 desc = h.urlify_text(h.escaped_stylize(desc))
200 200 else:
201 201 desc = h.urlify_text(h.html_escape(desc))
202 202
203 203 return _render('repo_desc', desc)
204 204
205 205 def state(repo_state):
206 206 return _render("repo_state", repo_state)
207 207
208 208 def repo_actions(repo_name):
209 209 return _render('repo_actions', repo_name, super_user_actions)
210 210
211 211 def user_profile(username):
212 212 return _render('user_profile', username)
213 213
214 214 repos_data = []
215 215 for repo in repo_list:
216 216 cs_cache = repo.changeset_cache
217 217 row = {
218 218 "menu": quick_menu(repo.repo_name),
219 219
220 220 "name": repo_lnk(repo.repo_name, repo.repo_type,
221 221 repo.repo_state, repo.private, repo.fork),
222 222 "name_raw": repo.repo_name.lower(),
223 223
224 224 "last_change": last_change(repo.last_db_change),
225 225 "last_change_raw": datetime_to_time(repo.last_db_change),
226 226
227 227 "last_changeset": last_rev(repo.repo_name, cs_cache),
228 228 "last_changeset_raw": cs_cache.get('revision'),
229 229
230 230 "desc": desc(repo.description),
231 231 "owner": user_profile(repo.user.username),
232 232
233 233 "state": state(repo.repo_state),
234 234 "rss": rss_lnk(repo.repo_name),
235 235
236 236 "atom": atom_lnk(repo.repo_name),
237 237 }
238 238 if admin:
239 239 row.update({
240 240 "action": repo_actions(repo.repo_name),
241 241 })
242 242 repos_data.append(row)
243 243
244 244 return repos_data
245 245
246 246 def _get_defaults(self, repo_name):
247 247 """
248 248 Gets information about repository, and returns a dict for
249 249 usage in forms
250 250
251 251 :param repo_name:
252 252 """
253 253
254 254 repo_info = Repository.get_by_repo_name(repo_name)
255 255
256 256 if repo_info is None:
257 257 return None
258 258
259 259 defaults = repo_info.get_dict()
260 260 defaults['repo_name'] = repo_info.just_name
261 261
262 262 groups = repo_info.groups_with_parents
263 263 parent_group = groups[-1] if groups else None
264 264
265 265 # we use -1 as this is how in HTML, we mark an empty group
266 266 defaults['repo_group'] = getattr(parent_group, 'group_id', -1)
267 267
268 268 keys_to_process = (
269 269 {'k': 'repo_type', 'strip': False},
270 270 {'k': 'repo_enable_downloads', 'strip': True},
271 271 {'k': 'repo_description', 'strip': True},
272 272 {'k': 'repo_enable_locking', 'strip': True},
273 273 {'k': 'repo_landing_rev', 'strip': True},
274 274 {'k': 'clone_uri', 'strip': False},
275 275 {'k': 'repo_private', 'strip': True},
276 276 {'k': 'repo_enable_statistics', 'strip': True}
277 277 )
278 278
279 279 for item in keys_to_process:
280 280 attr = item['k']
281 281 if item['strip']:
282 282 attr = remove_prefix(item['k'], 'repo_')
283 283
284 284 val = defaults[attr]
285 285 if item['k'] == 'repo_landing_rev':
286 286 val = ':'.join(defaults[attr])
287 287 defaults[item['k']] = val
288 288 if item['k'] == 'clone_uri':
289 289 defaults['clone_uri_hidden'] = repo_info.clone_uri_hidden
290 290
291 291 # fill owner
292 292 if repo_info.user:
293 293 defaults.update({'user': repo_info.user.username})
294 294 else:
295 295 replacement_user = User.get_first_super_admin().username
296 296 defaults.update({'user': replacement_user})
297 297
298 298 # fill repository users
299 299 for p in repo_info.repo_to_perm:
300 300 defaults.update({'u_perm_%s' % p.user.user_id:
301 301 p.permission.permission_name})
302 302
303 303 # fill repository groups
304 304 for p in repo_info.users_group_to_perm:
305 305 defaults.update({'g_perm_%s' % p.users_group.users_group_id:
306 306 p.permission.permission_name})
307 307
308 308 return defaults
309 309
310 310 def update(self, repo, **kwargs):
311 311 try:
312 312 cur_repo = self._get_repo(repo)
313 313 source_repo_name = cur_repo.repo_name
314 314 if 'user' in kwargs:
315 315 cur_repo.user = User.get_by_username(kwargs['user'])
316 316
317 317 if 'repo_group' in kwargs:
318 318 cur_repo.group = RepoGroup.get(kwargs['repo_group'])
319 319 log.debug('Updating repo %s with params:%s', cur_repo, kwargs)
320 320
321 321 update_keys = [
322 322 (1, 'repo_description'),
323 323 (1, 'repo_landing_rev'),
324 324 (1, 'repo_private'),
325 325 (1, 'repo_enable_downloads'),
326 326 (1, 'repo_enable_locking'),
327 327 (1, 'repo_enable_statistics'),
328 328 (0, 'clone_uri'),
329 329 (0, 'fork_id')
330 330 ]
331 331 for strip, k in update_keys:
332 332 if k in kwargs:
333 333 val = kwargs[k]
334 334 if strip:
335 335 k = remove_prefix(k, 'repo_')
336 if k == 'clone_uri':
337 from rhodecode.model.validators import Missing
338 _change = kwargs.get('clone_uri_change')
339 if _change in [Missing, 'OLD']:
340 # we don't change the value, so use original one
341 val = cur_repo.clone_uri
342 336
343 337 setattr(cur_repo, k, val)
344 338
345 339 new_name = cur_repo.get_new_name(kwargs['repo_name'])
346 340 cur_repo.repo_name = new_name
347 341
348 342 # if private flag is set, reset default permission to NONE
349 343 if kwargs.get('repo_private'):
350 344 EMPTY_PERM = 'repository.none'
351 345 RepoModel().grant_user_permission(
352 346 repo=cur_repo, user=User.DEFAULT_USER, perm=EMPTY_PERM
353 347 )
354 348
355 349 # handle extra fields
356 350 for field in filter(lambda k: k.startswith(RepositoryField.PREFIX),
357 351 kwargs):
358 352 k = RepositoryField.un_prefix_key(field)
359 353 ex_field = RepositoryField.get_by_key_name(
360 354 key=k, repo=cur_repo)
361 355 if ex_field:
362 356 ex_field.field_value = kwargs[field]
363 357 self.sa.add(ex_field)
364 358 self.sa.add(cur_repo)
365 359
366 360 if source_repo_name != new_name:
367 361 # rename repository
368 362 self._rename_filesystem_repo(
369 363 old=source_repo_name, new=new_name)
370 364
371 365 return cur_repo
372 366 except Exception:
373 367 log.error(traceback.format_exc())
374 368 raise
375 369
376 370 def _create_repo(self, repo_name, repo_type, description, owner,
377 371 private=False, clone_uri=None, repo_group=None,
378 372 landing_rev='rev:tip', fork_of=None,
379 373 copy_fork_permissions=False, enable_statistics=False,
380 374 enable_locking=False, enable_downloads=False,
381 375 copy_group_permissions=False,
382 376 state=Repository.STATE_PENDING):
383 377 """
384 378 Create repository inside database with PENDING state, this should be
385 379 only executed by create() repo. With exception of importing existing
386 380 repos
387 381 """
388 382 from rhodecode.model.scm import ScmModel
389 383
390 384 owner = self._get_user(owner)
391 385 fork_of = self._get_repo(fork_of)
392 386 repo_group = self._get_repo_group(safe_int(repo_group))
393 387
394 388 try:
395 389 repo_name = safe_unicode(repo_name)
396 390 description = safe_unicode(description)
397 391 # repo name is just a name of repository
398 392 # while repo_name_full is a full qualified name that is combined
399 393 # with name and path of group
400 394 repo_name_full = repo_name
401 395 repo_name = repo_name.split(Repository.NAME_SEP)[-1]
402 396
403 397 new_repo = Repository()
404 398 new_repo.repo_state = state
405 399 new_repo.enable_statistics = False
406 400 new_repo.repo_name = repo_name_full
407 401 new_repo.repo_type = repo_type
408 402 new_repo.user = owner
409 403 new_repo.group = repo_group
410 404 new_repo.description = description or repo_name
411 405 new_repo.private = private
412 406 new_repo.clone_uri = clone_uri
413 407 new_repo.landing_rev = landing_rev
414 408
415 409 new_repo.enable_statistics = enable_statistics
416 410 new_repo.enable_locking = enable_locking
417 411 new_repo.enable_downloads = enable_downloads
418 412
419 413 if repo_group:
420 414 new_repo.enable_locking = repo_group.enable_locking
421 415
422 416 if fork_of:
423 417 parent_repo = fork_of
424 418 new_repo.fork = parent_repo
425 419
426 420 events.trigger(events.RepoPreCreateEvent(new_repo))
427 421
428 422 self.sa.add(new_repo)
429 423
430 424 EMPTY_PERM = 'repository.none'
431 425 if fork_of and copy_fork_permissions:
432 426 repo = fork_of
433 427 user_perms = UserRepoToPerm.query() \
434 428 .filter(UserRepoToPerm.repository == repo).all()
435 429 group_perms = UserGroupRepoToPerm.query() \
436 430 .filter(UserGroupRepoToPerm.repository == repo).all()
437 431
438 432 for perm in user_perms:
439 433 UserRepoToPerm.create(
440 434 perm.user, new_repo, perm.permission)
441 435
442 436 for perm in group_perms:
443 437 UserGroupRepoToPerm.create(
444 438 perm.users_group, new_repo, perm.permission)
445 439 # in case we copy permissions and also set this repo to private
446 440 # override the default user permission to make it a private
447 441 # repo
448 442 if private:
449 443 RepoModel(self.sa).grant_user_permission(
450 444 repo=new_repo, user=User.DEFAULT_USER, perm=EMPTY_PERM)
451 445
452 446 elif repo_group and copy_group_permissions:
453 447 user_perms = UserRepoGroupToPerm.query() \
454 448 .filter(UserRepoGroupToPerm.group == repo_group).all()
455 449
456 450 group_perms = UserGroupRepoGroupToPerm.query() \
457 451 .filter(UserGroupRepoGroupToPerm.group == repo_group).all()
458 452
459 453 for perm in user_perms:
460 454 perm_name = perm.permission.permission_name.replace(
461 455 'group.', 'repository.')
462 456 perm_obj = Permission.get_by_key(perm_name)
463 457 UserRepoToPerm.create(perm.user, new_repo, perm_obj)
464 458
465 459 for perm in group_perms:
466 460 perm_name = perm.permission.permission_name.replace(
467 461 'group.', 'repository.')
468 462 perm_obj = Permission.get_by_key(perm_name)
469 463 UserGroupRepoToPerm.create(
470 464 perm.users_group, new_repo, perm_obj)
471 465
472 466 if private:
473 467 RepoModel(self.sa).grant_user_permission(
474 468 repo=new_repo, user=User.DEFAULT_USER, perm=EMPTY_PERM)
475 469
476 470 else:
477 471 perm_obj = self._create_default_perms(new_repo, private)
478 472 self.sa.add(perm_obj)
479 473
480 474 # now automatically start following this repository as owner
481 475 ScmModel(self.sa).toggle_following_repo(new_repo.repo_id,
482 476 owner.user_id)
483 477
484 478 # we need to flush here, in order to check if database won't
485 479 # throw any exceptions, create filesystem dirs at the very end
486 480 self.sa.flush()
487 481 events.trigger(events.RepoCreateEvent(new_repo))
488 482 return new_repo
489 483
490 484 except Exception:
491 485 log.error(traceback.format_exc())
492 486 raise
493 487
494 488 def create(self, form_data, cur_user):
495 489 """
496 490 Create repository using celery tasks
497 491
498 492 :param form_data:
499 493 :param cur_user:
500 494 """
501 495 from rhodecode.lib.celerylib import tasks, run_task
502 496 return run_task(tasks.create_repo, form_data, cur_user)
503 497
504 498 def update_permissions(self, repo, perm_additions=None, perm_updates=None,
505 499 perm_deletions=None, check_perms=True,
506 500 cur_user=None):
507 501 if not perm_additions:
508 502 perm_additions = []
509 503 if not perm_updates:
510 504 perm_updates = []
511 505 if not perm_deletions:
512 506 perm_deletions = []
513 507
514 508 req_perms = ('usergroup.read', 'usergroup.write', 'usergroup.admin')
515 509
516 510 # update permissions
517 511 for member_id, perm, member_type in perm_updates:
518 512 member_id = int(member_id)
519 513 if member_type == 'user':
520 514 # this updates also current one if found
521 515 self.grant_user_permission(
522 516 repo=repo, user=member_id, perm=perm)
523 517 else: # set for user group
524 518 # check if we have permissions to alter this usergroup
525 519 member_name = UserGroup.get(member_id).users_group_name
526 520 if not check_perms or HasUserGroupPermissionAny(
527 521 *req_perms)(member_name, user=cur_user):
528 522 self.grant_user_group_permission(
529 523 repo=repo, group_name=member_id, perm=perm)
530 524
531 525 # set new permissions
532 526 for member_id, perm, member_type in perm_additions:
533 527 member_id = int(member_id)
534 528 if member_type == 'user':
535 529 self.grant_user_permission(
536 530 repo=repo, user=member_id, perm=perm)
537 531 else: # set for user group
538 532 # check if we have permissions to alter this usergroup
539 533 member_name = UserGroup.get(member_id).users_group_name
540 534 if not check_perms or HasUserGroupPermissionAny(
541 535 *req_perms)(member_name, user=cur_user):
542 536 self.grant_user_group_permission(
543 537 repo=repo, group_name=member_id, perm=perm)
544 538
545 539 # delete permissions
546 540 for member_id, perm, member_type in perm_deletions:
547 541 member_id = int(member_id)
548 542 if member_type == 'user':
549 543 self.revoke_user_permission(repo=repo, user=member_id)
550 544 else: # set for user group
551 545 # check if we have permissions to alter this usergroup
552 546 member_name = UserGroup.get(member_id).users_group_name
553 547 if not check_perms or HasUserGroupPermissionAny(
554 548 *req_perms)(member_name, user=cur_user):
555 549 self.revoke_user_group_permission(
556 550 repo=repo, group_name=member_id)
557 551
558 552 def create_fork(self, form_data, cur_user):
559 553 """
560 554 Simple wrapper into executing celery task for fork creation
561 555
562 556 :param form_data:
563 557 :param cur_user:
564 558 """
565 559 from rhodecode.lib.celerylib import tasks, run_task
566 560 return run_task(tasks.create_repo_fork, form_data, cur_user)
567 561
568 562 def delete(self, repo, forks=None, fs_remove=True, cur_user=None):
569 563 """
570 564 Delete given repository, forks parameter defines what do do with
571 565 attached forks. Throws AttachedForksError if deleted repo has attached
572 566 forks
573 567
574 568 :param repo:
575 569 :param forks: str 'delete' or 'detach'
576 570 :param fs_remove: remove(archive) repo from filesystem
577 571 """
578 572 if not cur_user:
579 573 cur_user = getattr(get_current_rhodecode_user(), 'username', None)
580 574 repo = self._get_repo(repo)
581 575 if repo:
582 576 if forks == 'detach':
583 577 for r in repo.forks:
584 578 r.fork = None
585 579 self.sa.add(r)
586 580 elif forks == 'delete':
587 581 for r in repo.forks:
588 582 self.delete(r, forks='delete')
589 583 elif [f for f in repo.forks]:
590 584 raise AttachedForksError()
591 585
592 586 old_repo_dict = repo.get_dict()
593 587 events.trigger(events.RepoPreDeleteEvent(repo))
594 588 try:
595 589 self.sa.delete(repo)
596 590 if fs_remove:
597 591 self._delete_filesystem_repo(repo)
598 592 else:
599 593 log.debug('skipping removal from filesystem')
600 594 old_repo_dict.update({
601 595 'deleted_by': cur_user,
602 596 'deleted_on': time.time(),
603 597 })
604 598 log_delete_repository(**old_repo_dict)
605 599 events.trigger(events.RepoDeleteEvent(repo))
606 600 except Exception:
607 601 log.error(traceback.format_exc())
608 602 raise
609 603
610 604 def grant_user_permission(self, repo, user, perm):
611 605 """
612 606 Grant permission for user on given repository, or update existing one
613 607 if found
614 608
615 609 :param repo: Instance of Repository, repository_id, or repository name
616 610 :param user: Instance of User, user_id or username
617 611 :param perm: Instance of Permission, or permission_name
618 612 """
619 613 user = self._get_user(user)
620 614 repo = self._get_repo(repo)
621 615 permission = self._get_perm(perm)
622 616
623 617 # check if we have that permission already
624 618 obj = self.sa.query(UserRepoToPerm) \
625 619 .filter(UserRepoToPerm.user == user) \
626 620 .filter(UserRepoToPerm.repository == repo) \
627 621 .scalar()
628 622 if obj is None:
629 623 # create new !
630 624 obj = UserRepoToPerm()
631 625 obj.repository = repo
632 626 obj.user = user
633 627 obj.permission = permission
634 628 self.sa.add(obj)
635 629 log.debug('Granted perm %s to %s on %s', perm, user, repo)
636 630 action_logger_generic(
637 631 'granted permission: {} to user: {} on repo: {}'.format(
638 632 perm, user, repo), namespace='security.repo')
639 633 return obj
640 634
641 635 def revoke_user_permission(self, repo, user):
642 636 """
643 637 Revoke permission for user on given repository
644 638
645 639 :param repo: Instance of Repository, repository_id, or repository name
646 640 :param user: Instance of User, user_id or username
647 641 """
648 642
649 643 user = self._get_user(user)
650 644 repo = self._get_repo(repo)
651 645
652 646 obj = self.sa.query(UserRepoToPerm) \
653 647 .filter(UserRepoToPerm.repository == repo) \
654 648 .filter(UserRepoToPerm.user == user) \
655 649 .scalar()
656 650 if obj:
657 651 self.sa.delete(obj)
658 652 log.debug('Revoked perm on %s on %s', repo, user)
659 653 action_logger_generic(
660 654 'revoked permission from user: {} on repo: {}'.format(
661 655 user, repo), namespace='security.repo')
662 656
663 657 def grant_user_group_permission(self, repo, group_name, perm):
664 658 """
665 659 Grant permission for user group on given repository, or update
666 660 existing one if found
667 661
668 662 :param repo: Instance of Repository, repository_id, or repository name
669 663 :param group_name: Instance of UserGroup, users_group_id,
670 664 or user group name
671 665 :param perm: Instance of Permission, or permission_name
672 666 """
673 667 repo = self._get_repo(repo)
674 668 group_name = self._get_user_group(group_name)
675 669 permission = self._get_perm(perm)
676 670
677 671 # check if we have that permission already
678 672 obj = self.sa.query(UserGroupRepoToPerm) \
679 673 .filter(UserGroupRepoToPerm.users_group == group_name) \
680 674 .filter(UserGroupRepoToPerm.repository == repo) \
681 675 .scalar()
682 676
683 677 if obj is None:
684 678 # create new
685 679 obj = UserGroupRepoToPerm()
686 680
687 681 obj.repository = repo
688 682 obj.users_group = group_name
689 683 obj.permission = permission
690 684 self.sa.add(obj)
691 685 log.debug('Granted perm %s to %s on %s', perm, group_name, repo)
692 686 action_logger_generic(
693 687 'granted permission: {} to usergroup: {} on repo: {}'.format(
694 688 perm, group_name, repo), namespace='security.repo')
695 689
696 690 return obj
697 691
698 692 def revoke_user_group_permission(self, repo, group_name):
699 693 """
700 694 Revoke permission for user group on given repository
701 695
702 696 :param repo: Instance of Repository, repository_id, or repository name
703 697 :param group_name: Instance of UserGroup, users_group_id,
704 698 or user group name
705 699 """
706 700 repo = self._get_repo(repo)
707 701 group_name = self._get_user_group(group_name)
708 702
709 703 obj = self.sa.query(UserGroupRepoToPerm) \
710 704 .filter(UserGroupRepoToPerm.repository == repo) \
711 705 .filter(UserGroupRepoToPerm.users_group == group_name) \
712 706 .scalar()
713 707 if obj:
714 708 self.sa.delete(obj)
715 709 log.debug('Revoked perm to %s on %s', repo, group_name)
716 710 action_logger_generic(
717 711 'revoked permission from usergroup: {} on repo: {}'.format(
718 712 group_name, repo), namespace='security.repo')
719 713
720 714 def delete_stats(self, repo_name):
721 715 """
722 716 removes stats for given repo
723 717
724 718 :param repo_name:
725 719 """
726 720 repo = self._get_repo(repo_name)
727 721 try:
728 722 obj = self.sa.query(Statistics) \
729 723 .filter(Statistics.repository == repo).scalar()
730 724 if obj:
731 725 self.sa.delete(obj)
732 726 except Exception:
733 727 log.error(traceback.format_exc())
734 728 raise
735 729
736 730 def add_repo_field(self, repo_name, field_key, field_label, field_value='',
737 731 field_type='str', field_desc=''):
738 732
739 733 repo = self._get_repo(repo_name)
740 734
741 735 new_field = RepositoryField()
742 736 new_field.repository = repo
743 737 new_field.field_key = field_key
744 738 new_field.field_type = field_type # python type
745 739 new_field.field_value = field_value
746 740 new_field.field_desc = field_desc
747 741 new_field.field_label = field_label
748 742 self.sa.add(new_field)
749 743 return new_field
750 744
751 745 def delete_repo_field(self, repo_name, field_key):
752 746 repo = self._get_repo(repo_name)
753 747 field = RepositoryField.get_by_key_name(field_key, repo)
754 748 if field:
755 749 self.sa.delete(field)
756 750
757 751 def _create_filesystem_repo(self, repo_name, repo_type, repo_group,
758 752 clone_uri=None, repo_store_location=None,
759 753 use_global_config=False):
760 754 """
761 755 makes repository on filesystem. It's group aware means it'll create
762 756 a repository within a group, and alter the paths accordingly of
763 757 group location
764 758
765 759 :param repo_name:
766 760 :param alias:
767 761 :param parent:
768 762 :param clone_uri:
769 763 :param repo_store_location:
770 764 """
771 765 from rhodecode.lib.utils import is_valid_repo, is_valid_repo_group
772 766 from rhodecode.model.scm import ScmModel
773 767
774 768 if Repository.NAME_SEP in repo_name:
775 769 raise ValueError(
776 770 'repo_name must not contain groups got `%s`' % repo_name)
777 771
778 772 if isinstance(repo_group, RepoGroup):
779 773 new_parent_path = os.sep.join(repo_group.full_path_splitted)
780 774 else:
781 775 new_parent_path = repo_group or ''
782 776
783 777 if repo_store_location:
784 778 _paths = [repo_store_location]
785 779 else:
786 780 _paths = [self.repos_path, new_parent_path, repo_name]
787 781 # we need to make it str for mercurial
788 782 repo_path = os.path.join(*map(lambda x: safe_str(x), _paths))
789 783
790 784 # check if this path is not a repository
791 785 if is_valid_repo(repo_path, self.repos_path):
792 786 raise Exception('This path %s is a valid repository' % repo_path)
793 787
794 788 # check if this path is a group
795 789 if is_valid_repo_group(repo_path, self.repos_path):
796 790 raise Exception('This path %s is a valid group' % repo_path)
797 791
798 792 log.info('creating repo %s in %s from url: `%s`',
799 793 repo_name, safe_unicode(repo_path),
800 794 obfuscate_url_pw(clone_uri))
801 795
802 796 backend = get_backend(repo_type)
803 797
804 798 config_repo = None if use_global_config else repo_name
805 799 if config_repo and new_parent_path:
806 800 config_repo = Repository.NAME_SEP.join(
807 801 (new_parent_path, config_repo))
808 802 config = make_db_config(clear_session=False, repo=config_repo)
809 803 config.set('extensions', 'largefiles', '')
810 804
811 805 # patch and reset hooks section of UI config to not run any
812 806 # hooks on creating remote repo
813 807 config.clear_section('hooks')
814 808
815 809 # TODO: johbo: Unify this, hardcoded "bare=True" does not look nice
816 810 if repo_type == 'git':
817 811 repo = backend(
818 812 repo_path, config=config, create=True, src_url=clone_uri,
819 813 bare=True)
820 814 else:
821 815 repo = backend(
822 816 repo_path, config=config, create=True, src_url=clone_uri)
823 817
824 818 ScmModel().install_hooks(repo, repo_type=repo_type)
825 819
826 820 log.debug('Created repo %s with %s backend',
827 821 safe_unicode(repo_name), safe_unicode(repo_type))
828 822 return repo
829 823
830 824 def _rename_filesystem_repo(self, old, new):
831 825 """
832 826 renames repository on filesystem
833 827
834 828 :param old: old name
835 829 :param new: new name
836 830 """
837 831 log.info('renaming repo from %s to %s', old, new)
838 832
839 833 old_path = os.path.join(self.repos_path, old)
840 834 new_path = os.path.join(self.repos_path, new)
841 835 if os.path.isdir(new_path):
842 836 raise Exception(
843 837 'Was trying to rename to already existing dir %s' % new_path
844 838 )
845 839 shutil.move(old_path, new_path)
846 840
847 841 def _delete_filesystem_repo(self, repo):
848 842 """
849 843 removes repo from filesystem, the removal is acctually made by
850 844 added rm__ prefix into dir, and rename internat .hg/.git dirs so this
851 845 repository is no longer valid for rhodecode, can be undeleted later on
852 846 by reverting the renames on this repository
853 847
854 848 :param repo: repo object
855 849 """
856 850 rm_path = os.path.join(self.repos_path, repo.repo_name)
857 851 repo_group = repo.group
858 852 log.info("Removing repository %s", rm_path)
859 853 # disable hg/git internal that it doesn't get detected as repo
860 854 alias = repo.repo_type
861 855
862 856 config = make_db_config(clear_session=False)
863 857 config.set('extensions', 'largefiles', '')
864 858 bare = getattr(repo.scm_instance(config=config), 'bare', False)
865 859
866 860 # skip this for bare git repos
867 861 if not bare:
868 862 # disable VCS repo
869 863 vcs_path = os.path.join(rm_path, '.%s' % alias)
870 864 if os.path.exists(vcs_path):
871 865 shutil.move(vcs_path, os.path.join(rm_path, 'rm__.%s' % alias))
872 866
873 867 _now = datetime.now()
874 868 _ms = str(_now.microsecond).rjust(6, '0')
875 869 _d = 'rm__%s__%s' % (_now.strftime('%Y%m%d_%H%M%S_' + _ms),
876 870 repo.just_name)
877 871 if repo_group:
878 872 # if repository is in group, prefix the removal path with the group
879 873 args = repo_group.full_path_splitted + [_d]
880 874 _d = os.path.join(*args)
881 875
882 876 if os.path.isdir(rm_path):
883 877 shutil.move(rm_path, os.path.join(self.repos_path, _d))
884 878
885 879
886 880 class ReadmeFinder:
887 881 """
888 882 Utility which knows how to find a readme for a specific commit.
889 883
890 884 The main idea is that this is a configurable algorithm. When creating an
891 885 instance you can define parameters, currently only the `default_renderer`.
892 886 Based on this configuration the method :meth:`search` behaves slightly
893 887 different.
894 888 """
895 889
896 890 readme_re = re.compile(r'^readme(\.[^\.]+)?$', re.IGNORECASE)
897 891 path_re = re.compile(r'^docs?', re.IGNORECASE)
898 892
899 893 default_priorities = {
900 894 None: 0,
901 895 '.text': 2,
902 896 '.txt': 3,
903 897 '.rst': 1,
904 898 '.rest': 2,
905 899 '.md': 1,
906 900 '.mkdn': 2,
907 901 '.mdown': 3,
908 902 '.markdown': 4,
909 903 }
910 904
911 905 path_priority = {
912 906 'doc': 0,
913 907 'docs': 1,
914 908 }
915 909
916 910 FALLBACK_PRIORITY = 99
917 911
918 912 RENDERER_TO_EXTENSION = {
919 913 'rst': ['.rst', '.rest'],
920 914 'markdown': ['.md', 'mkdn', '.mdown', '.markdown'],
921 915 }
922 916
923 917 def __init__(self, default_renderer=None):
924 918 self._default_renderer = default_renderer
925 919 self._renderer_extensions = self.RENDERER_TO_EXTENSION.get(
926 920 default_renderer, [])
927 921
928 922 def search(self, commit, path='/'):
929 923 """
930 924 Find a readme in the given `commit`.
931 925 """
932 926 nodes = commit.get_nodes(path)
933 927 matches = self._match_readmes(nodes)
934 928 matches = self._sort_according_to_priority(matches)
935 929 if matches:
936 930 return matches[0].node
937 931
938 932 paths = self._match_paths(nodes)
939 933 paths = self._sort_paths_according_to_priority(paths)
940 934 for path in paths:
941 935 match = self.search(commit, path=path)
942 936 if match:
943 937 return match
944 938
945 939 return None
946 940
947 941 def _match_readmes(self, nodes):
948 942 for node in nodes:
949 943 if not node.is_file():
950 944 continue
951 945 path = node.path.rsplit('/', 1)[-1]
952 946 match = self.readme_re.match(path)
953 947 if match:
954 948 extension = match.group(1)
955 949 yield ReadmeMatch(node, match, self._priority(extension))
956 950
957 951 def _match_paths(self, nodes):
958 952 for node in nodes:
959 953 if not node.is_dir():
960 954 continue
961 955 match = self.path_re.match(node.path)
962 956 if match:
963 957 yield node.path
964 958
965 959 def _priority(self, extension):
966 960 renderer_priority = (
967 961 0 if extension in self._renderer_extensions else 1)
968 962 extension_priority = self.default_priorities.get(
969 963 extension, self.FALLBACK_PRIORITY)
970 964 return (renderer_priority, extension_priority)
971 965
972 966 def _sort_according_to_priority(self, matches):
973 967
974 968 def priority_and_path(match):
975 969 return (match.priority, match.path)
976 970
977 971 return sorted(matches, key=priority_and_path)
978 972
979 973 def _sort_paths_according_to_priority(self, paths):
980 974
981 975 def priority_and_path(path):
982 976 return (self.path_priority.get(path, self.FALLBACK_PRIORITY), path)
983 977
984 978 return sorted(paths, key=priority_and_path)
985 979
986 980
987 981 class ReadmeMatch:
988 982
989 983 def __init__(self, node, match, priority):
990 984 self.node = node
991 985 self._match = match
992 986 self.priority = priority
993 987
994 988 @property
995 989 def path(self):
996 990 return self.node.path
997 991
998 992 def __repr__(self):
999 993 return '<ReadmeMatch {} priority={}'.format(self.path, self.priority)
@@ -1,116 +1,116 b''
1 1
2 2 /******************************************************************************
3 3 * *
4 4 * DO NOT CHANGE THIS FILE MANUALLY *
5 5 * *
6 6 * *
7 7 * This file is automatically generated when the app starts up with *
8 8 * generate_js_files = true *
9 9 * *
10 10 * To add a route here pass jsroute=True to the route definition in the app *
11 11 * *
12 12 ******************************************************************************/
13 13 function registerRCRoutes() {
14 14 // routes registration
15 15 pyroutes.register('home', '/', []);
16 16 pyroutes.register('new_repo', '/_admin/create_repository', []);
17 17 pyroutes.register('edit_user', '/_admin/users/%(user_id)s/edit', ['user_id']);
18 18 pyroutes.register('edit_user_group_members', '/_admin/user_groups/%(user_group_id)s/edit/members', ['user_group_id']);
19 19 pyroutes.register('gists', '/_admin/gists', []);
20 20 pyroutes.register('new_gist', '/_admin/gists/new', []);
21 21 pyroutes.register('toggle_following', '/_admin/toggle_following', []);
22 22 pyroutes.register('repo_stats', '/%(repo_name)s/repo_stats/%(commit_id)s', ['repo_name', 'commit_id']);
23 23 pyroutes.register('repo_refs_data', '/%(repo_name)s/refs-data', ['repo_name']);
24 24 pyroutes.register('repo_refs_changelog_data', '/%(repo_name)s/refs-data-changelog', ['repo_name']);
25 25 pyroutes.register('repo_default_reviewers_data', '/%(repo_name)s/default-reviewers', ['repo_name']);
26 26 pyroutes.register('changeset_home', '/%(repo_name)s/changeset/%(revision)s', ['repo_name', 'revision']);
27 pyroutes.register('edit_repo', '/%(repo_name)s/settings', ['repo_name']);
28 27 pyroutes.register('edit_repo_perms', '/%(repo_name)s/settings/permissions', ['repo_name']);
29 28 pyroutes.register('changeset_comment', '/%(repo_name)s/changeset/%(revision)s/comment', ['repo_name', 'revision']);
30 29 pyroutes.register('changeset_comment_preview', '/%(repo_name)s/changeset/comment/preview', ['repo_name']);
31 30 pyroutes.register('changeset_comment_delete', '/%(repo_name)s/changeset/comment/%(comment_id)s/delete', ['repo_name', 'comment_id']);
32 31 pyroutes.register('changeset_info', '/%(repo_name)s/changeset_info/%(revision)s', ['repo_name', 'revision']);
33 32 pyroutes.register('compare_url', '/%(repo_name)s/compare/%(source_ref_type)s@%(source_ref)s...%(target_ref_type)s@%(target_ref)s', ['repo_name', 'source_ref_type', 'source_ref', 'target_ref_type', 'target_ref']);
34 33 pyroutes.register('pullrequest_home', '/%(repo_name)s/pull-request/new', ['repo_name']);
35 34 pyroutes.register('pullrequest', '/%(repo_name)s/pull-request/new', ['repo_name']);
36 35 pyroutes.register('pullrequest_repo_refs', '/%(repo_name)s/pull-request/refs/%(target_repo_name)s', ['repo_name', 'target_repo_name']);
37 36 pyroutes.register('pullrequest_repo_destinations', '/%(repo_name)s/pull-request/repo-destinations', ['repo_name']);
38 37 pyroutes.register('pullrequest_show', '/%(repo_name)s/pull-request/%(pull_request_id)s', ['repo_name', 'pull_request_id']);
39 38 pyroutes.register('pullrequest_update', '/%(repo_name)s/pull-request/%(pull_request_id)s', ['repo_name', 'pull_request_id']);
40 39 pyroutes.register('pullrequest_show_all', '/%(repo_name)s/pull-request', ['repo_name']);
41 40 pyroutes.register('pullrequest_comment', '/%(repo_name)s/pull-request-comment/%(pull_request_id)s', ['repo_name', 'pull_request_id']);
42 41 pyroutes.register('pullrequest_comment_delete', '/%(repo_name)s/pull-request-comment/%(comment_id)s/delete', ['repo_name', 'comment_id']);
43 42 pyroutes.register('changelog_home', '/%(repo_name)s/changelog', ['repo_name']);
44 43 pyroutes.register('changelog_file_home', '/%(repo_name)s/changelog/%(revision)s/%(f_path)s', ['repo_name', 'revision', 'f_path']);
45 44 pyroutes.register('changelog_elements', '/%(repo_name)s/changelog_details', ['repo_name']);
46 45 pyroutes.register('files_home', '/%(repo_name)s/files/%(revision)s/%(f_path)s', ['repo_name', 'revision', 'f_path']);
47 46 pyroutes.register('files_history_home', '/%(repo_name)s/history/%(revision)s/%(f_path)s', ['repo_name', 'revision', 'f_path']);
48 47 pyroutes.register('files_authors_home', '/%(repo_name)s/authors/%(revision)s/%(f_path)s', ['repo_name', 'revision', 'f_path']);
49 48 pyroutes.register('files_annotate_home', '/%(repo_name)s/annotate/%(revision)s/%(f_path)s', ['repo_name', 'revision', 'f_path']);
50 49 pyroutes.register('files_annotate_previous', '/%(repo_name)s/annotate-previous/%(revision)s/%(f_path)s', ['repo_name', 'revision', 'f_path']);
51 50 pyroutes.register('files_archive_home', '/%(repo_name)s/archive/%(fname)s', ['repo_name', 'fname']);
52 51 pyroutes.register('files_nodelist_home', '/%(repo_name)s/nodelist/%(revision)s/%(f_path)s', ['repo_name', 'revision', 'f_path']);
53 52 pyroutes.register('files_nodetree_full', '/%(repo_name)s/nodetree_full/%(commit_id)s/%(f_path)s', ['repo_name', 'commit_id', 'f_path']);
54 53 pyroutes.register('summary_home_slash', '/%(repo_name)s/', ['repo_name']);
55 54 pyroutes.register('summary_home', '/%(repo_name)s', ['repo_name']);
56 55 pyroutes.register('favicon', '/favicon.ico', []);
57 56 pyroutes.register('robots', '/robots.txt', []);
58 57 pyroutes.register('auth_home', '/_admin/auth*traverse', []);
59 58 pyroutes.register('global_integrations_new', '/_admin/integrations/new', []);
60 59 pyroutes.register('global_integrations_home', '/_admin/integrations', []);
61 60 pyroutes.register('global_integrations_list', '/_admin/integrations/%(integration)s', ['integration']);
62 61 pyroutes.register('global_integrations_create', '/_admin/integrations/%(integration)s/new', ['integration']);
63 62 pyroutes.register('global_integrations_edit', '/_admin/integrations/%(integration)s/%(integration_id)s', ['integration', 'integration_id']);
64 63 pyroutes.register('repo_group_integrations_home', '%(repo_group_name)s/settings/integrations', ['repo_group_name']);
65 64 pyroutes.register('repo_group_integrations_list', '%(repo_group_name)s/settings/integrations/%(integration)s', ['repo_group_name', 'integration']);
66 65 pyroutes.register('repo_group_integrations_new', '%(repo_group_name)s/settings/integrations/new', ['repo_group_name']);
67 66 pyroutes.register('repo_group_integrations_create', '%(repo_group_name)s/settings/integrations/%(integration)s/new', ['repo_group_name', 'integration']);
68 67 pyroutes.register('repo_group_integrations_edit', '%(repo_group_name)s/settings/integrations/%(integration)s/%(integration_id)s', ['repo_group_name', 'integration', 'integration_id']);
69 68 pyroutes.register('repo_integrations_home', '%(repo_name)s/settings/integrations', ['repo_name']);
70 69 pyroutes.register('repo_integrations_list', '%(repo_name)s/settings/integrations/%(integration)s', ['repo_name', 'integration']);
71 70 pyroutes.register('repo_integrations_new', '%(repo_name)s/settings/integrations/new', ['repo_name']);
72 71 pyroutes.register('repo_integrations_create', '%(repo_name)s/settings/integrations/%(integration)s/new', ['repo_name', 'integration']);
73 72 pyroutes.register('repo_integrations_edit', '%(repo_name)s/settings/integrations/%(integration)s/%(integration_id)s', ['repo_name', 'integration', 'integration_id']);
74 73 pyroutes.register('ops_ping', '_admin/ops/ping', []);
75 74 pyroutes.register('admin_settings_open_source', '_admin/settings/open_source', []);
76 75 pyroutes.register('admin_settings_vcs_svn_generate_cfg', '_admin/settings/vcs/svn_generate_cfg', []);
77 76 pyroutes.register('admin_settings_system', '_admin/settings/system', []);
78 77 pyroutes.register('admin_settings_system_update', '_admin/settings/system/updates', []);
79 78 pyroutes.register('admin_settings_sessions', '_admin/settings/sessions', []);
80 79 pyroutes.register('admin_settings_sessions_cleanup', '_admin/settings/sessions/cleanup', []);
81 80 pyroutes.register('users', '_admin/users', []);
82 81 pyroutes.register('users_data', '_admin/users_data', []);
83 82 pyroutes.register('edit_user_auth_tokens', '_admin/users/%(user_id)s/edit/auth_tokens', ['user_id']);
84 83 pyroutes.register('edit_user_auth_tokens_add', '_admin/users/%(user_id)s/edit/auth_tokens/new', ['user_id']);
85 84 pyroutes.register('edit_user_auth_tokens_delete', '_admin/users/%(user_id)s/edit/auth_tokens/delete', ['user_id']);
86 85 pyroutes.register('edit_user_groups_management', '_admin/users/%(user_id)s/edit/groups_management', ['user_id']);
87 86 pyroutes.register('edit_user_groups_management_updates', '_admin/users/%(user_id)s/edit/edit_user_groups_management/updates', ['user_id']);
88 87 pyroutes.register('edit_user_audit_logs', '_admin/users/%(user_id)s/edit/audit', ['user_id']);
89 88 pyroutes.register('channelstream_connect', '/_admin/channelstream/connect', []);
90 89 pyroutes.register('channelstream_subscribe', '/_admin/channelstream/subscribe', []);
91 90 pyroutes.register('channelstream_proxy', '/_channelstream', []);
92 91 pyroutes.register('login', '/_admin/login', []);
93 92 pyroutes.register('logout', '/_admin/logout', []);
94 93 pyroutes.register('register', '/_admin/register', []);
95 94 pyroutes.register('reset_password', '/_admin/password_reset', []);
96 95 pyroutes.register('reset_password_confirmation', '/_admin/password_reset_confirmation', []);
97 96 pyroutes.register('user_autocomplete_data', '/_users', []);
98 97 pyroutes.register('user_group_autocomplete_data', '/_user_groups', []);
99 98 pyroutes.register('repo_list_data', '/_repos', []);
100 99 pyroutes.register('goto_switcher_data', '/_goto_data', []);
100 pyroutes.register('edit_repo', '/%(repo_name)s/settings', ['repo_name']);
101 101 pyroutes.register('repo_maintenance', '/%(repo_name)s/maintenance', ['repo_name']);
102 102 pyroutes.register('repo_maintenance_execute', '/%(repo_name)s/maintenance/execute', ['repo_name']);
103 103 pyroutes.register('strip', '/%(repo_name)s/strip', ['repo_name']);
104 104 pyroutes.register('strip_check', '/%(repo_name)s/strip_check', ['repo_name']);
105 105 pyroutes.register('strip_execute', '/%(repo_name)s/strip_execute', ['repo_name']);
106 106 pyroutes.register('search', '/_admin/search', []);
107 107 pyroutes.register('search_repo', '/%(repo_name)s/search', ['repo_name']);
108 108 pyroutes.register('user_profile', '/_profiles/%(username)s', ['username']);
109 109 pyroutes.register('my_account_profile', '/_admin/my_account/profile', []);
110 110 pyroutes.register('my_account_password', '/_admin/my_account/password', []);
111 111 pyroutes.register('my_account_password_update', '/_admin/my_account/password', []);
112 112 pyroutes.register('my_account_auth_tokens', '/_admin/my_account/auth_tokens', []);
113 113 pyroutes.register('my_account_auth_tokens_add', '/_admin/my_account/auth_tokens/new', []);
114 114 pyroutes.register('my_account_auth_tokens_delete', '/_admin/my_account/auth_tokens/delete', []);
115 115 pyroutes.register('apiv2', '/_admin/api', []);
116 116 }
@@ -1,69 +1,69 b''
1 1 ## -*- coding: utf-8 -*-
2 2 <%inherit file="base.mako"/>
3 3
4 4 <%def name="breadcrumbs_links()">
5 5 %if c.repo:
6 ${h.link_to('Settings',h.url('edit_repo', repo_name=c.repo.repo_name))}
6 ${h.link_to('Settings',h.route_path('edit_repo', repo_name=c.repo.repo_name))}
7 7 &raquo;
8 8 ${h.link_to(_('Integrations'),request.route_url(route_name='repo_integrations_home', repo_name=c.repo.repo_name))}
9 9 &raquo;
10 10 ${h.link_to(current_IntegrationType.display_name,
11 11 request.route_url(route_name='repo_integrations_list',
12 12 repo_name=c.repo.repo_name,
13 13 integration=current_IntegrationType.key))}
14 14 %elif c.repo_group:
15 15 ${h.link_to(_('Admin'),h.url('admin_home'))}
16 16 &raquo;
17 17 ${h.link_to(_('Repository Groups'),h.url('repo_groups'))}
18 18 &raquo;
19 19 ${h.link_to(c.repo_group.group_name,h.url('edit_repo_group', group_name=c.repo_group.group_name))}
20 20 &raquo;
21 21 ${h.link_to(_('Integrations'),request.route_url(route_name='repo_group_integrations_home', repo_group_name=c.repo_group.group_name))}
22 22 &raquo;
23 23 ${h.link_to(current_IntegrationType.display_name,
24 24 request.route_url(route_name='repo_group_integrations_list',
25 25 repo_group_name=c.repo_group.group_name,
26 26 integration=current_IntegrationType.key))}
27 27 %else:
28 28 ${h.link_to(_('Admin'),h.url('admin_home'))}
29 29 &raquo;
30 30 ${h.link_to(_('Settings'),h.url('admin_settings'))}
31 31 &raquo;
32 32 ${h.link_to(_('Integrations'),request.route_url(route_name='global_integrations_home'))}
33 33 &raquo;
34 34 ${h.link_to(current_IntegrationType.display_name,
35 35 request.route_url(route_name='global_integrations_list',
36 36 integration=current_IntegrationType.key))}
37 37 %endif
38 38
39 39 %if integration:
40 40 &raquo;
41 41 ${integration.name}
42 42 %elif current_IntegrationType:
43 43 &raquo;
44 44 ${current_IntegrationType.display_name}
45 45 %endif
46 46 </%def>
47 47
48 48 <style>
49 49 .control-inputs.item-options, .control-inputs.item-settings {
50 50 float: left;
51 51 width: 100%;
52 52 }
53 53 </style>
54 54 <div class="panel panel-default">
55 55 <div class="panel-heading">
56 56 <h2 class="panel-title">
57 57 %if integration:
58 58 ${current_IntegrationType.display_name} - ${integration.name}
59 59 %else:
60 60 ${_('Create New %(integration_type)s Integration') % {
61 61 'integration_type': current_IntegrationType.display_name
62 62 }}
63 63 %endif
64 64 </h2>
65 65 </div>
66 66 <div class="panel-body">
67 67 ${form.render() | n}
68 68 </div>
69 69 </div>
@@ -1,252 +1,252 b''
1 1 ## -*- coding: utf-8 -*-
2 2 <%inherit file="base.mako"/>
3 3
4 4 <%def name="breadcrumbs_links()">
5 5 %if c.repo:
6 ${h.link_to('Settings',h.url('edit_repo', repo_name=c.repo.repo_name))}
6 ${h.link_to('Settings',h.route_path('edit_repo', repo_name=c.repo.repo_name))}
7 7 %elif c.repo_group:
8 8 ${h.link_to(_('Admin'),h.url('admin_home'))}
9 9 &raquo;
10 10 ${h.link_to(_('Repository Groups'),h.url('repo_groups'))}
11 11 &raquo;
12 12 ${h.link_to(c.repo_group.group_name,h.url('edit_repo_group', group_name=c.repo_group.group_name))}
13 13 %else:
14 14 ${h.link_to(_('Admin'),h.url('admin_home'))}
15 15 &raquo;
16 16 ${h.link_to(_('Settings'),h.url('admin_settings'))}
17 17 %endif
18 18 %if current_IntegrationType:
19 19 &raquo;
20 20 %if c.repo:
21 21 ${h.link_to(_('Integrations'),
22 22 request.route_url(route_name='repo_integrations_home',
23 23 repo_name=c.repo.repo_name))}
24 24 %elif c.repo_group:
25 25 ${h.link_to(_('Integrations'),
26 26 request.route_url(route_name='repo_group_integrations_home',
27 27 repo_group_name=c.repo_group.group_name))}
28 28 %else:
29 29 ${h.link_to(_('Integrations'),
30 30 request.route_url(route_name='global_integrations_home'))}
31 31 %endif
32 32 &raquo;
33 33 ${current_IntegrationType.display_name}
34 34 %else:
35 35 &raquo;
36 36 ${_('Integrations')}
37 37 %endif
38 38 </%def>
39 39
40 40 <div class="panel panel-default">
41 41 <div class="panel-heading">
42 42 <h3 class="panel-title">
43 43 %if c.repo:
44 44 ${_('Current Integrations for Repository: {repo_name}').format(repo_name=c.repo.repo_name)}
45 45 %elif c.repo_group:
46 46 ${_('Current Integrations for repository group: {repo_group_name}').format(repo_group_name=c.repo_group.group_name)}
47 47 %else:
48 48 ${_('Current Integrations')}
49 49 %endif
50 50 </h3>
51 51 </div>
52 52 <div class="panel-body">
53 53 <%
54 54 if c.repo:
55 55 home_url = request.route_path('repo_integrations_home',
56 56 repo_name=c.repo.repo_name)
57 57 elif c.repo_group:
58 58 home_url = request.route_path('repo_group_integrations_home',
59 59 repo_group_name=c.repo_group.group_name)
60 60 else:
61 61 home_url = request.route_path('global_integrations_home')
62 62 %>
63 63
64 64 <a href="${home_url}" class="btn ${not current_IntegrationType and 'btn-primary' or ''}">${_('All')}</a>
65 65
66 66 %for integration_key, IntegrationType in available_integrations.items():
67 67 <%
68 68 if c.repo:
69 69 list_url = request.route_path('repo_integrations_list',
70 70 repo_name=c.repo.repo_name,
71 71 integration=integration_key)
72 72 elif c.repo_group:
73 73 list_url = request.route_path('repo_group_integrations_list',
74 74 repo_group_name=c.repo_group.group_name,
75 75 integration=integration_key)
76 76 else:
77 77 list_url = request.route_path('global_integrations_list',
78 78 integration=integration_key)
79 79 %>
80 80 <a href="${list_url}"
81 81 class="btn ${current_IntegrationType and integration_key == current_IntegrationType.key and 'btn-primary' or ''}">
82 82 ${IntegrationType.display_name}
83 83 </a>
84 84 %endfor
85 85
86 86 <%
87 87 if c.repo:
88 88 create_url = h.route_path('repo_integrations_new', repo_name=c.repo.repo_name)
89 89 elif c.repo_group:
90 90 create_url = h.route_path('repo_group_integrations_new', repo_group_name=c.repo_group.group_name)
91 91 else:
92 92 create_url = h.route_path('global_integrations_new')
93 93 %>
94 94 <p class="pull-right">
95 95 <a href="${create_url}" class="btn btn-small btn-success">${_(u'Create new integration')}</a>
96 96 </p>
97 97
98 98 <table class="rctable integrations">
99 99 <thead>
100 100 <tr>
101 101 <th><a href="?sort=enabled:${rev_sort_dir}">${_('Enabled')}</a></th>
102 102 <th><a href="?sort=name:${rev_sort_dir}">${_('Name')}</a></th>
103 103 <th colspan="2"><a href="?sort=integration_type:${rev_sort_dir}">${_('Type')}</a></th>
104 104 <th><a href="?sort=scope:${rev_sort_dir}">${_('Scope')}</a></th>
105 105 <th>${_('Actions')}</th>
106 106 <th></th>
107 107 </tr>
108 108 </thead>
109 109 <tbody>
110 110 %if not integrations_list:
111 111 <tr>
112 112 <td colspan="7">
113 113 <% integration_type = current_IntegrationType and current_IntegrationType.display_name or '' %>
114 114 %if c.repo:
115 115 ${_('No {type} integrations for repo {repo} exist yet.').format(type=integration_type, repo=c.repo.repo_name)}
116 116 %elif c.repo_group:
117 117 ${_('No {type} integrations for repogroup {repogroup} exist yet.').format(type=integration_type, repogroup=c.repo_group.group_name)}
118 118 %else:
119 119 ${_('No {type} integrations exist yet.').format(type=integration_type)}
120 120 %endif
121 121
122 122 %if current_IntegrationType:
123 123 <%
124 124 if c.repo:
125 125 create_url = h.route_path('repo_integrations_create', repo_name=c.repo.repo_name, integration=current_IntegrationType.key)
126 126 elif c.repo_group:
127 127 create_url = h.route_path('repo_group_integrations_create', repo_group_name=c.repo_group.group_name, integration=current_IntegrationType.key)
128 128 else:
129 129 create_url = h.route_path('global_integrations_create', integration=current_IntegrationType.key)
130 130 %>
131 131 %endif
132 132
133 133 <a href="${create_url}">${_(u'Create one')}</a>
134 134 </td>
135 135 </tr>
136 136 %endif
137 137 %for IntegrationType, integration in integrations_list:
138 138 <tr id="integration_${integration.integration_id}">
139 139 <td class="td-enabled">
140 140 %if integration.enabled:
141 141 <div class="flag_status approved pull-left"></div>
142 142 %else:
143 143 <div class="flag_status rejected pull-left"></div>
144 144 %endif
145 145 </td>
146 146 <td class="td-description">
147 147 ${integration.name}
148 148 </td>
149 149 <td class="td-icon">
150 150 %if integration.integration_type in available_integrations:
151 151 <div class="integration-icon">
152 152 ${available_integrations[integration.integration_type].icon|n}
153 153 </div>
154 154 %else:
155 155 ?
156 156 %endif
157 157 </td>
158 158 <td class="td-type">
159 159 ${integration.integration_type}
160 160 </td>
161 161 <td class="td-scope">
162 162 %if integration.repo:
163 163 <a href="${h.url('summary_home', repo_name=integration.repo.repo_name)}">
164 164 ${_('repo')}:${integration.repo.repo_name}
165 165 </a>
166 166 %elif integration.repo_group:
167 167 <a href="${h.url('repo_group_home', group_name=integration.repo_group.group_name)}">
168 168 ${_('repogroup')}:${integration.repo_group.group_name}
169 169 %if integration.child_repos_only:
170 170 ${_('child repos only')}
171 171 %else:
172 172 ${_('cascade to all')}
173 173 %endif
174 174 </a>
175 175 %else:
176 176 %if integration.child_repos_only:
177 177 ${_('top level repos only')}
178 178 %else:
179 179 ${_('global')}
180 180 %endif
181 181 </td>
182 182 %endif
183 183 <td class="td-action">
184 184 %if not IntegrationType:
185 185 ${_('unknown integration')}
186 186 %else:
187 187 <%
188 188 if c.repo:
189 189 edit_url = request.route_path('repo_integrations_edit',
190 190 repo_name=c.repo.repo_name,
191 191 integration=integration.integration_type,
192 192 integration_id=integration.integration_id)
193 193 elif c.repo_group:
194 194 edit_url = request.route_path('repo_group_integrations_edit',
195 195 repo_group_name=c.repo_group.group_name,
196 196 integration=integration.integration_type,
197 197 integration_id=integration.integration_id)
198 198 else:
199 199 edit_url = request.route_path('global_integrations_edit',
200 200 integration=integration.integration_type,
201 201 integration_id=integration.integration_id)
202 202 %>
203 203 <div class="grid_edit">
204 204 <a href="${edit_url}">${_('Edit')}</a>
205 205 </div>
206 206 <div class="grid_delete">
207 207 <a href="${edit_url}"
208 208 class="btn btn-link btn-danger delete_integration_entry"
209 209 data-desc="${integration.name}"
210 210 data-uid="${integration.integration_id}">
211 211 ${_('Delete')}
212 212 </a>
213 213 </div>
214 214 %endif
215 215 </td>
216 216 </tr>
217 217 %endfor
218 218 <tr id="last-row"></tr>
219 219 </tbody>
220 220 </table>
221 221 <div class="integrations-paginator">
222 222 <div class="pagination-wh pagination-left">
223 223 ${integrations_list.pager('$link_previous ~2~ $link_next')}
224 224 </div>
225 225 </div>
226 226 </div>
227 227 </div>
228 228 <script type="text/javascript">
229 229 var delete_integration = function(entry) {
230 230 if (confirm("Confirm to remove this integration: "+$(entry).data('desc'))) {
231 231 var request = $.ajax({
232 232 type: "POST",
233 233 url: $(entry).attr('href'),
234 234 data: {
235 235 'delete': 'delete',
236 236 'csrf_token': CSRF_TOKEN
237 237 },
238 238 success: function(){
239 239 location.reload();
240 240 },
241 241 error: function(data, textStatus, errorThrown){
242 242 alert("Error while deleting entry.\nError code {0} ({1}). URL: {2}".format(data.status,data.statusText,$(entry)[0].url));
243 243 }
244 244 });
245 245 };
246 246 };
247 247
248 248 $('.delete_integration_entry').on('click', function(e){
249 249 e.preventDefault();
250 250 delete_integration(this);
251 251 });
252 252 </script> No newline at end of file
@@ -1,66 +1,66 b''
1 1 ## -*- coding: utf-8 -*-
2 2 <%inherit file="base.mako"/>
3 3 <%namespace name="widgets" file="/widgets.mako"/>
4 4
5 5 <%def name="breadcrumbs_links()">
6 6 %if c.repo:
7 ${h.link_to('Settings',h.url('edit_repo', repo_name=c.repo.repo_name))}
7 ${h.link_to('Settings',h.route_path('edit_repo', repo_name=c.repo.repo_name))}
8 8 &raquo;
9 9 ${h.link_to(_('Integrations'),request.route_url(route_name='repo_integrations_home', repo_name=c.repo.repo_name))}
10 10 %elif c.repo_group:
11 11 ${h.link_to(_('Admin'),h.url('admin_home'))}
12 12 &raquo;
13 13 ${h.link_to(_('Repository Groups'),h.url('repo_groups'))}
14 14 &raquo;
15 15 ${h.link_to(c.repo_group.group_name,h.url('edit_repo_group', group_name=c.repo_group.group_name))}
16 16 &raquo;
17 17 ${h.link_to(_('Integrations'),request.route_url(route_name='repo_group_integrations_home', repo_group_name=c.repo_group.group_name))}
18 18 %else:
19 19 ${h.link_to(_('Admin'),h.url('admin_home'))}
20 20 &raquo;
21 21 ${h.link_to(_('Settings'),h.url('admin_settings'))}
22 22 &raquo;
23 23 ${h.link_to(_('Integrations'),request.route_url(route_name='global_integrations_home'))}
24 24 %endif
25 25 &raquo;
26 26 ${_('Create new integration')}
27 27 </%def>
28 28 <%widgets:panel class_='integrations'>
29 29 <%def name="title()">
30 30 %if c.repo:
31 31 ${_('Create New Integration for repository: {repo_name}').format(repo_name=c.repo.repo_name)}
32 32 %elif c.repo_group:
33 33 ${_('Create New Integration for repository group: {repo_group_name}').format(repo_group_name=c.repo_group.group_name)}
34 34 %else:
35 35 ${_('Create New Global Integration')}
36 36 %endif
37 37 </%def>
38 38
39 39 %for integration, IntegrationType in available_integrations.items():
40 40 <%
41 41 if c.repo:
42 42 create_url = request.route_path('repo_integrations_create',
43 43 repo_name=c.repo.repo_name,
44 44 integration=integration)
45 45 elif c.repo_group:
46 46 create_url = request.route_path('repo_group_integrations_create',
47 47 repo_group_name=c.repo_group.group_name,
48 48 integration=integration)
49 49 else:
50 50 create_url = request.route_path('global_integrations_create',
51 51 integration=integration)
52 52 %>
53 53 <a href="${create_url}" class="integration-box">
54 54 <%widgets:panel>
55 55 <h2>
56 56 <div class="integration-icon">
57 57 ${IntegrationType.icon|n}
58 58 </div>
59 59 ${IntegrationType.display_name}
60 60 </h2>
61 61 ${IntegrationType.description or _('No description available')}
62 62 </%widgets:panel>
63 63 </a>
64 64 %endfor
65 65 <div style="clear:both"></div>
66 66 </%widgets:panel>
@@ -1,106 +1,106 b''
1 1 ## -*- coding: utf-8 -*-
2 2 ##
3 3 ## See also repo_settings.html
4 4 ##
5 5 <%inherit file="/base/base.mako"/>
6 6
7 7 <%def name="title()">
8 8 ${_('%s repository settings') % c.repo_info.repo_name}
9 9 %if c.rhodecode_name:
10 10 &middot; ${h.branding(c.rhodecode_name)}
11 11 %endif
12 12 </%def>
13 13
14 14 <%def name="breadcrumbs_links()">
15 15 ${_('Settings')}
16 16 </%def>
17 17
18 18 <%def name="menu_bar_nav()">
19 19 ${self.menu_items(active='repositories')}
20 20 </%def>
21 21
22 22 <%def name="menu_bar_subnav()">
23 23 ${self.repo_menu(active='options')}
24 24 </%def>
25 25
26 26 <%def name="main_content()">
27 27 <%include file="/admin/repos/repo_edit_${c.active}.mako"/>
28 28 </%def>
29 29
30 30
31 31 <%def name="main()">
32 32 <div class="box">
33 33 <div class="title">
34 34 ${self.repo_page_title(c.rhodecode_db_repo)}
35 35 ${self.breadcrumbs()}
36 36 </div>
37 37
38 38 <div class="sidebar-col-wrapper scw-small">
39 39 ##main
40 40 <div class="sidebar">
41 41 <ul class="nav nav-pills nav-stacked">
42 42 <li class="${'active' if c.active=='settings' else ''}">
43 <a href="${h.url('edit_repo', repo_name=c.repo_name)}">${_('Settings')}</a>
43 <a href="${h.route_path('edit_repo', repo_name=c.repo_name)}">${_('Settings')}</a>
44 44 </li>
45 45 <li class="${'active' if c.active=='permissions' else ''}">
46 46 <a href="${h.url('edit_repo_perms', repo_name=c.repo_name)}">${_('Permissions')}</a>
47 47 </li>
48 48 <li class="${'active' if c.active=='advanced' else ''}">
49 49 <a href="${h.url('edit_repo_advanced', repo_name=c.repo_name)}">${_('Advanced')}</a>
50 50 </li>
51 51 <li class="${'active' if c.active=='vcs' else ''}">
52 52 <a href="${h.url('repo_vcs_settings', repo_name=c.repo_name)}">${_('VCS')}</a>
53 53 </li>
54 54 <li class="${'active' if c.active=='fields' else ''}">
55 55 <a href="${h.url('edit_repo_fields', repo_name=c.repo_name)}">${_('Extra Fields')}</a>
56 56 </li>
57 57 <li class="${'active' if c.active=='issuetracker' else ''}">
58 58 <a href="${h.url('repo_settings_issuetracker', repo_name=c.repo_name)}">${_('Issue Tracker')}</a>
59 59 </li>
60 60 <li class="${'active' if c.active=='caches' else ''}">
61 61 <a href="${h.url('edit_repo_caches', repo_name=c.repo_name)}">${_('Caches')}</a>
62 62 </li>
63 63 %if c.repo_info.repo_type != 'svn':
64 64 <li class="${'active' if c.active=='remote' else ''}">
65 65 <a href="${h.url('edit_repo_remote', repo_name=c.repo_name)}">${_('Remote')}</a>
66 66 </li>
67 67 %endif
68 68 <li class="${'active' if c.active=='statistics' else ''}">
69 69 <a href="${h.url('edit_repo_statistics', repo_name=c.repo_name)}">${_('Statistics')}</a>
70 70 </li>
71 71 <li class="${'active' if c.active=='integrations' else ''}">
72 72 <a href="${h.route_path('repo_integrations_home', repo_name=c.repo_name)}">${_('Integrations')}</a>
73 73 </li>
74 74 <li class="${'active' if c.active=='maintenance' else ''}">
75 75 <a href="${h.route_path('repo_maintenance', repo_name=c.repo_name)}">${_('Maintenance')}</a>
76 76 </li>
77 77 <li class="${'active' if c.active=='strip' else ''}">
78 78 <a href="${h.route_path('strip', repo_name=c.repo_name)}">${_('Strip')}</a>
79 79 </li>
80 80 ## TODO: dan: replace repo navigation with navlist registry like with
81 81 ## admin menu. First must find way to allow runtime configuration
82 82 ## it to account for the c.repo_info.repo_type != 'svn' call above
83 83 <%
84 84 reviewer_settings = False
85 85 try:
86 86 import rc_reviewers
87 87 reviewer_settings = True
88 88 except ImportError:
89 89 pass
90 90 %>
91 91 %if reviewer_settings:
92 92 <li class="${'active' if c.active=='reviewers' else ''}">
93 93 <a href="${h.route_path('repo_reviewers_home', repo_name=c.repo_name)}">${_('Reviewers')}</a>
94 94 </li>
95 95 %endif
96 96 </ul>
97 97 </div>
98 98
99 99 <div class="main-content-full-width">
100 100 ${self.main_content()}
101 101 </div>
102 102
103 103 </div>
104 104 </div>
105 105
106 106 </%def> No newline at end of file
@@ -1,240 +1,249 b''
1 1 ## -*- coding: utf-8 -*-
2 2 <%namespace name="base" file="/base/base.mako"/>
3 3
4 4 <div class="panel panel-default">
5 5 <div class="panel-heading">
6 <h3 class="panel-title">${_('Settings for Repository: %s') % c.repo_info.repo_name}</h3>
6 <h3 class="panel-title">${_('Settings for Repository: %s') % c.rhodecode_db_repo.repo_name}</h3>
7 7 </div>
8 8 <div class="panel-body">
9 ${h.secure_form(url('repo', repo_name=c.repo_info.repo_name),method='put')}
9 ${h.secure_form(h.route_path('edit_repo', repo_name=c.rhodecode_db_repo.repo_name), method='POST')}
10 10 <div class="form">
11 11 <!-- fields -->
12 12 <div class="fields">
13
13 14 <div class="field">
14 15 <div class="label">
15 16 <label for="repo_name">${_('Name')}:</label>
16 17 </div>
17 18 <div class="input">
18 ${h.text('repo_name',class_="medium")}
19 <p class="help-block">${_('Non-changeable id')}: `_${c.repo_info.repo_id}` <span><a id="show_more_clone_id" href="#">${_('what is that ?')}</a></span></p>
19 ${c.form['repo_name'].render(css_class='medium', oid='repo_name')|n}
20 ${c.form.render_error(request, c.form['repo_name'])|n}
21
22 <p class="help-block">${_('Non-changeable id')}: `_${c.rhodecode_db_repo.repo_id}` <span><a href="#" onclick="$('#clone_id').toggle();return false">${_('what is that ?')}</a></span></p>
20 23 <p id="clone_id" style="display:none;">
21 ${_('URL by id')}: `${c.repo_info.clone_url(with_id=True)}` </br>
24 ${_('URL by id')}: `${c.rhodecode_db_repo.clone_url(with_id=True)}` <br/>
22 25 ${_('''In case this repository is renamed or moved into another group the repository url changes.
23 26 Using above url guarantees that this repository will always be accessible under such url.
24 27 Useful for CI systems, or any other cases that you need to hardcode the url into 3rd party service.''')}</p>
25 28 </div>
26 29 </div>
27 % if c.repo_info.repo_type != 'svn':
30
31 <div class="field">
32 <div class="label">
33 <label for="repo_group">${_('Repository group')}:</label>
34 </div>
35 <div class="select">
36 ${c.form['repo_group'].render(css_class='medium', oid='repo_group')|n}
37 ${c.form.render_error(request, c.form['repo_group'])|n}
38
39 % if c.personal_repo_group:
40 <a class="btn" href="#" data-personal-group-name="${c.personal_repo_group.group_name}" data-personal-group-id="${c.personal_repo_group.group_id}" onclick="selectMyGroup(this); return false">
41 ${_('Select my personal group (`%(repo_group_name)s`)') % {'repo_group_name': c.personal_repo_group.group_name}}
42 </a>
43 % endif
44 <p class="help-block">${_('Optional select a group to put this repository into.')}</p>
45 </div>
46 </div>
47
48 % if c.rhodecode_db_repo.repo_type != 'svn':
28 49 <div class="field">
29 50 <div class="label">
30 51 <label for="clone_uri">${_('Remote uri')}:</label>
31 52 </div>
32 53 <div class="input">
33 %if c.repo_info.clone_uri:
54 %if c.rhodecode_db_repo.clone_uri:
55 ## display
34 56 <div id="clone_uri_hidden" class='text-as-placeholder'>
35 <span id="clone_uri_hidden_value">${c.repo_info.clone_uri_hidden}</span>
57 <span id="clone_uri_hidden_value">${c.rhodecode_db_repo.clone_uri_hidden}</span>
36 58 <span class="link" id="edit_clone_uri"><i class="icon-edit"></i>${_('edit')}</span>
37 59 </div>
60 ## alter field
38 61 <div id="alter_clone_uri" style="display: none">
39 ${h.text('clone_uri',class_="medium", placeholder=_('new value, leave empty to remove'))}
40 ${h.hidden('clone_uri_change', 'OLD')}
62 ${c.form['repo_clone_uri'].render(css_class='medium', oid='clone_uri', placeholder=_('enter new value, or leave empty to remove'))|n}
63 ${c.form.render_error(request, c.form['repo_clone_uri'])|n}
64 ${h.hidden('repo_clone_uri_change', 'OLD')}
65
41 66 <span class="link" id="cancel_edit_clone_uri">${_('cancel')}</span>
42 67 </div>
43 68 %else:
44 69 ## not set yet, display form to set it
45 ${h.text('clone_uri',class_="medium")}
46 ${h.hidden('clone_uri_change', 'NEW')}
70 ${c.form['repo_clone_uri'].render(css_class='medium', oid='clone_uri')|n}
71 ${c.form.render_error(request, c.form['repo_clone_uri'])|n}
72 ${h.hidden('repo_clone_uri_change', 'NEW')}
47 73 %endif
48 <p id="alter_clone_uri_help_block" class="help-block">${_('http[s] url where from repository was imported, also used for doing remote pulls.')}</p>
74 <p id="alter_clone_uri_help_block" class="help-block">
75 <% pull_link = h.literal(h.link_to('remote sync', h.url('edit_repo_remote', repo_name=c.repo_name))) %>
76 ${_('http[s] url where from repository was imported, this field can used for doing {pull_link}.').format(pull_link=pull_link)|n} <br/>
77 ${_('This field is stored encrypted inside Database, a format of http://user:password@server.com/repo_name can be used and will be hidden from display.')}
78 </p>
49 79 </div>
50 80 </div>
51 81 % else:
52 ${h.hidden('clone_uri', '')}
82 ${h.hidden('repo_clone_uri', '')}
53 83 % endif
84
54 85 <div class="field">
55 86 <div class="label">
56 <label for="repo_group">${_('Repository group')}:</label>
87 <label for="repo_landing_commit_ref">${_('Landing commit')}:</label>
57 88 </div>
58 89 <div class="select">
59 ${h.select('repo_group','',c.repo_groups,class_="medium")}
60 % if c.personal_repo_group:
61 <a class="btn" href="#" id="select_my_group" data-personal-group-id="${c.personal_repo_group.group_id}">
62 ${_('Select my personal group (%(repo_group_name)s)') % {'repo_group_name': c.personal_repo_group.group_name}}
63 </a>
64 % endif
65 <p class="help-block">${_('Optional select a group to put this repository into.')}</p>
66 </div>
67 </div>
68 <div class="field">
69 <div class="label">
70 <label for="repo_landing_rev">${_('Landing commit')}:</label>
71 </div>
72 <div class="select">
73 ${h.select('repo_landing_rev','',c.landing_revs,class_="medium")}
74 <p class="help-block">${_('Default commit for files page, downloads, whoosh and readme')}</p>
90 ${c.form['repo_landing_commit_ref'].render(css_class='medium', oid='repo_landing_commit_ref')|n}
91 ${c.form.render_error(request, c.form['repo_landing_commit_ref'])|n}
92 <p class="help-block">${_('Default commit for files page, downloads, full text search index and readme')}</p>
75 93 </div>
76 94 </div>
77 95
78 96 <div class="field badged-field">
79 97 <div class="label">
80 <label for="user">${_('Owner')}:</label>
98 <label for="repo_owner">${_('Owner')}:</label>
81 99 </div>
82 100 <div class="input">
83 101 <div class="badge-input-container">
84 102 <div class="user-badge">
85 ${base.gravatar_with_user(c.repo_info.user.email, show_disabled=not c.repo_info.user.active)}
103 ${base.gravatar_with_user(c.rhodecode_db_repo.user.email, show_disabled=not c.rhodecode_db_repo.user.active)}
86 104 </div>
87 105 <div class="badge-input-wrap">
88 ${h.text('user', class_="medium", autocomplete="off")}
106 ${c.form['repo_owner'].render(css_class='medium', oid='repo_owner')|n}
89 107 </div>
90 108 </div>
91 <form:error name="user"/>
109 ${c.form.render_error(request, c.form['repo_owner'])|n}
92 110 <p class="help-block">${_('Change owner of this repository.')}</p>
93 111 </div>
94 112 </div>
95 113
96 114 <div class="field">
97 115 <div class="label label-textarea">
98 116 <label for="repo_description">${_('Description')}:</label>
99 117 </div>
100 118 <div class="textarea text-area editor">
101 ${h.textarea('repo_description', )}
119 ${c.form['repo_description'].render(css_class='medium', oid='repo_description')|n}
120 ${c.form.render_error(request, c.form['repo_description'])|n}
102 121 <p class="help-block">${_('Keep it short and to the point. Use a README file for longer descriptions.')}</p>
103 122 </div>
104 123 </div>
105 124
106 125 <div class="field">
107 126 <div class="label label-checkbox">
108 <label for="repo_private">${_('Private repository')}:</label>
127 <label for="${c.form['repo_private'].oid}">${_('Private repository')}:</label>
109 128 </div>
110 129 <div class="checkboxes">
111 ${h.checkbox('repo_private',value="True")}
130 ${c.form['repo_private'].render(css_class='medium')|n}
131 ${c.form.render_error(request, c.form['repo_private'])|n}
112 132 <span class="help-block">${_('Private repositories are only visible to people explicitly added as collaborators.')}</span>
113 133 </div>
114 134 </div>
115 135 <div class="field">
116 136 <div class="label label-checkbox">
117 <label for="repo_enable_statistics">${_('Enable statistics')}:</label>
137 <label for="${c.form['repo_enable_statistics'].oid}">${_('Enable statistics')}:</label>
118 138 </div>
119 139 <div class="checkboxes">
120 ${h.checkbox('repo_enable_statistics',value="True")}
140 ${c.form['repo_enable_statistics'].render(css_class='medium')|n}
141 ${c.form.render_error(request, c.form['repo_enable_statistics'])|n}
121 142 <span class="help-block">${_('Enable statistics window on summary page.')}</span>
122 143 </div>
123 144 </div>
124 145 <div class="field">
125 146 <div class="label label-checkbox">
126 <label for="repo_enable_downloads">${_('Enable downloads')}:</label>
147 <label for="${c.form['repo_enable_downloads'].oid}">${_('Enable downloads')}:</label>
127 148 </div>
128 149 <div class="checkboxes">
129 ${h.checkbox('repo_enable_downloads',value="True")}
150 ${c.form['repo_enable_downloads'].render(css_class='medium')|n}
151 ${c.form.render_error(request, c.form['repo_enable_downloads'])|n}
130 152 <span class="help-block">${_('Enable download menu on summary page.')}</span>
131 153 </div>
132 154 </div>
133 155 <div class="field">
134 156 <div class="label label-checkbox">
135 <label for="repo_enable_locking">${_('Enable automatic locking')}:</label>
157 <label for="${c.form['repo_enable_locking'].oid}">${_('Enable automatic locking')}:</label>
136 158 </div>
137 159 <div class="checkboxes">
138 ${h.checkbox('repo_enable_locking',value="True")}
160 ${c.form['repo_enable_locking'].render(css_class='medium')|n}
161 ${c.form.render_error(request, c.form['repo_enable_locking'])|n}
139 162 <span class="help-block">${_('Enable automatic locking on repository. Pulling from this repository creates a lock that can be released by pushing back by the same user')}</span>
140 163 </div>
141 164 </div>
142 165
143 166 %if c.visual.repository_fields:
144 167 ## EXTRA FIELDS
145 168 %for field in c.repo_fields:
146 169 <div class="field">
147 170 <div class="label">
148 171 <label for="${field.field_key_prefixed}">${field.field_label} (${field.field_key}):</label>
149 172 </div>
150 173 <div class="input input-medium">
151 174 ${h.text(field.field_key_prefixed, field.field_value, class_='medium')}
152 175 %if field.field_desc:
153 176 <span class="help-block">${field.field_desc}</span>
154 177 %endif
155 178 </div>
156 179 </div>
157 180 %endfor
158 181 %endif
159 182 <div class="buttons">
160 183 ${h.submit('save',_('Save'),class_="btn")}
161 184 ${h.reset('reset',_('Reset'),class_="btn")}
162 185 </div>
163 186 </div>
164 187 </div>
165 188 ${h.end_form()}
166 189 </div>
167 190 </div>
168 191
169 192 <script>
170 193 $(document).ready(function(){
171 var select2Options = {
172 'containerCssClass': "drop-menu",
173 'dropdownCssClass': "drop-menu-dropdown",
174 'dropdownAutoWidth': true
175 };
176
177 194 var cloneUrl = function() {
178 195 var alterButton = $('#alter_clone_uri');
179 196 var editButton = $('#edit_clone_uri');
180 197 var cancelEditButton = $('#cancel_edit_clone_uri');
181 198 var hiddenUrl = $('#clone_uri_hidden');
182 199 var hiddenUrlValue = $('#clone_uri_hidden_value');
183 200 var input = $('#clone_uri');
184 201 var helpBlock = $('#alter_clone_uri_help_block');
185 var changedFlag = $('#clone_uri_change');
202 var changedFlag = $('#repo_clone_uri_change');
186 203 var originalText = helpBlock.html();
187 204 var obfuscatedUrl = hiddenUrlValue.html();
188 205
189 206 var edit = function(e) {
190 207 alterButton.show();
191 208 editButton.hide();
192 209 hiddenUrl.hide();
193 210
194 211 //add the old value next to input for verification
195 212 helpBlock.html("(" + obfuscatedUrl + ")" + "<br\>" + originalText);
196 213 changedFlag.val('MOD');
197 214 };
198 215
199 216 var cancelEdit = function(e) {
200 217 alterButton.hide();
201 218 editButton.show();
202 219 hiddenUrl.show();
203 220
204 221 helpBlock.html(originalText);
205 222 changedFlag.val('OLD');
206 223 input.val('');
207 224 };
208 225
209 226 var initEvents = function() {
210 227 editButton.on('click', edit);
211 228 cancelEditButton.on('click', cancelEdit);
212 229 };
213 230
214 231 var setInitialState = function() {
215 232 if (input.hasClass('error')) {
216 233 alterButton.show();
217 234 editButton.hide();
218 235 hiddenUrl.hide();
219 236 }
220 237 };
221 238
222 239 setInitialState();
223 240 initEvents();
224 241 }();
225 242
226 $('#show_more_clone_id').on('click', function(e){
227 $('#clone_id').show();
228 e.preventDefault();
229 });
243 selectMyGroup = function(element) {
244 $("#repo_group").val($(element).data('personalGroupId')).trigger("change");
245 };
230 246
231 $('#repo_landing_rev').select2(select2Options);
232 $('#repo_group').select2(select2Options);
233
234 UsersAutoComplete('user', '${c.rhodecode_user.user_id}');
235 $('#select_my_group').on('click', function(e){
236 e.preventDefault();
237 $("#repo_group").val($(this).data('personalGroupId')).trigger("change");
238 });
247 UsersAutoComplete('repo_owner', '${c.rhodecode_user.user_id}');
239 248 });
240 249 </script>
@@ -1,601 +1,601 b''
1 1 ## -*- coding: utf-8 -*-
2 2 <%inherit file="root.mako"/>
3 3
4 4 <div class="outerwrapper">
5 5 <!-- HEADER -->
6 6 <div class="header">
7 7 <div id="header-inner" class="wrapper">
8 8 <div id="logo">
9 9 <div class="logo-wrapper">
10 10 <a href="${h.url('home')}"><img src="${h.asset('images/rhodecode-logo-white-216x60.png')}" alt="RhodeCode"/></a>
11 11 </div>
12 12 %if c.rhodecode_name:
13 13 <div class="branding">- ${h.branding(c.rhodecode_name)}</div>
14 14 %endif
15 15 </div>
16 16 <!-- MENU BAR NAV -->
17 17 ${self.menu_bar_nav()}
18 18 <!-- END MENU BAR NAV -->
19 19 </div>
20 20 </div>
21 21 ${self.menu_bar_subnav()}
22 22 <!-- END HEADER -->
23 23
24 24 <!-- CONTENT -->
25 25 <div id="content" class="wrapper">
26 26
27 27 <rhodecode-toast id="notifications"></rhodecode-toast>
28 28
29 29 <div class="main">
30 30 ${next.main()}
31 31 </div>
32 32 </div>
33 33 <!-- END CONTENT -->
34 34
35 35 </div>
36 36 <!-- FOOTER -->
37 37 <div id="footer">
38 38 <div id="footer-inner" class="title wrapper">
39 39 <div>
40 40 <p class="footer-link-right">
41 41 % if c.visual.show_version:
42 42 RhodeCode Enterprise ${c.rhodecode_version} ${c.rhodecode_edition}
43 43 % endif
44 44 &copy; 2010-${h.datetime.today().year}, <a href="${h.route_url('rhodecode_official')}" target="_blank">RhodeCode GmbH</a>. All rights reserved.
45 45 % if c.visual.rhodecode_support_url:
46 46 <a href="${c.visual.rhodecode_support_url}" target="_blank">${_('Support')}</a>
47 47 % endif
48 48 </p>
49 49 <% sid = 'block' if request.GET.get('showrcid') else 'none' %>
50 50 <p class="server-instance" style="display:${sid}">
51 51 ## display hidden instance ID if specially defined
52 52 % if c.rhodecode_instanceid:
53 53 ${_('RhodeCode instance id: %s') % c.rhodecode_instanceid}
54 54 % endif
55 55 </p>
56 56 </div>
57 57 </div>
58 58 </div>
59 59
60 60 <!-- END FOOTER -->
61 61
62 62 ### MAKO DEFS ###
63 63
64 64 <%def name="menu_bar_subnav()">
65 65 </%def>
66 66
67 67 <%def name="breadcrumbs(class_='breadcrumbs')">
68 68 <div class="${class_}">
69 69 ${self.breadcrumbs_links()}
70 70 </div>
71 71 </%def>
72 72
73 73 <%def name="admin_menu()">
74 74 <ul class="admin_menu submenu">
75 75 <li><a href="${h.url('admin_home')}">${_('Admin journal')}</a></li>
76 76 <li><a href="${h.url('repos')}">${_('Repositories')}</a></li>
77 77 <li><a href="${h.url('repo_groups')}">${_('Repository groups')}</a></li>
78 78 <li><a href="${h.route_path('users')}">${_('Users')}</a></li>
79 79 <li><a href="${h.url('users_groups')}">${_('User groups')}</a></li>
80 80 <li><a href="${h.url('admin_permissions_application')}">${_('Permissions')}</a></li>
81 81 <li><a href="${h.route_path('auth_home', traverse='')}">${_('Authentication')}</a></li>
82 82 <li><a href="${h.route_path('global_integrations_home')}">${_('Integrations')}</a></li>
83 83 <li><a href="${h.url('admin_defaults_repositories')}">${_('Defaults')}</a></li>
84 84 <li class="last"><a href="${h.url('admin_settings')}">${_('Settings')}</a></li>
85 85 </ul>
86 86 </%def>
87 87
88 88
89 89 <%def name="dt_info_panel(elements)">
90 90 <dl class="dl-horizontal">
91 91 %for dt, dd, title, show_items in elements:
92 92 <dt>${dt}:</dt>
93 93 <dd title="${title}">
94 94 %if callable(dd):
95 95 ## allow lazy evaluation of elements
96 96 ${dd()}
97 97 %else:
98 98 ${dd}
99 99 %endif
100 100 %if show_items:
101 101 <span class="btn-collapse" data-toggle="item-${h.md5_safe(dt)[:6]}-details">${_('Show More')} </span>
102 102 %endif
103 103 </dd>
104 104
105 105 %if show_items:
106 106 <div class="collapsable-content" data-toggle="item-${h.md5_safe(dt)[:6]}-details" style="display: none">
107 107 %for item in show_items:
108 108 <dt></dt>
109 109 <dd>${item}</dd>
110 110 %endfor
111 111 </div>
112 112 %endif
113 113
114 114 %endfor
115 115 </dl>
116 116 </%def>
117 117
118 118
119 119 <%def name="gravatar(email, size=16)">
120 120 <%
121 121 if (size > 16):
122 122 gravatar_class = 'gravatar gravatar-large'
123 123 else:
124 124 gravatar_class = 'gravatar'
125 125 %>
126 126 <%doc>
127 127 TODO: johbo: For now we serve double size images to make it smooth
128 128 for retina. This is how it worked until now. Should be replaced
129 129 with a better solution at some point.
130 130 </%doc>
131 131 <img class="${gravatar_class}" src="${h.gravatar_url(email, size * 2)}" height="${size}" width="${size}">
132 132 </%def>
133 133
134 134
135 135 <%def name="gravatar_with_user(contact, size=16, show_disabled=False)">
136 136 <% email = h.email_or_none(contact) %>
137 137 <div class="rc-user tooltip" title="${h.author_string(email)}">
138 138 ${self.gravatar(email, size)}
139 139 <span class="${'user user-disabled' if show_disabled else 'user'}"> ${h.link_to_user(contact)}</span>
140 140 </div>
141 141 </%def>
142 142
143 143
144 144 ## admin menu used for people that have some admin resources
145 145 <%def name="admin_menu_simple(repositories=None, repository_groups=None, user_groups=None)">
146 146 <ul class="submenu">
147 147 %if repositories:
148 148 <li class="local-admin-repos"><a href="${h.url('repos')}">${_('Repositories')}</a></li>
149 149 %endif
150 150 %if repository_groups:
151 151 <li class="local-admin-repo-groups"><a href="${h.url('repo_groups')}">${_('Repository groups')}</a></li>
152 152 %endif
153 153 %if user_groups:
154 154 <li class="local-admin-user-groups"><a href="${h.url('users_groups')}">${_('User groups')}</a></li>
155 155 %endif
156 156 </ul>
157 157 </%def>
158 158
159 159 <%def name="repo_page_title(repo_instance)">
160 160 <div class="title-content">
161 161 <div class="title-main">
162 162 ## SVN/HG/GIT icons
163 163 %if h.is_hg(repo_instance):
164 164 <i class="icon-hg"></i>
165 165 %endif
166 166 %if h.is_git(repo_instance):
167 167 <i class="icon-git"></i>
168 168 %endif
169 169 %if h.is_svn(repo_instance):
170 170 <i class="icon-svn"></i>
171 171 %endif
172 172
173 173 ## public/private
174 174 %if repo_instance.private:
175 175 <i class="icon-repo-private"></i>
176 176 %else:
177 177 <i class="icon-repo-public"></i>
178 178 %endif
179 179
180 180 ## repo name with group name
181 181 ${h.breadcrumb_repo_link(c.rhodecode_db_repo)}
182 182
183 183 </div>
184 184
185 185 ## FORKED
186 186 %if repo_instance.fork:
187 187 <p>
188 188 <i class="icon-code-fork"></i> ${_('Fork of')}
189 189 <a href="${h.url('summary_home',repo_name=repo_instance.fork.repo_name)}">${repo_instance.fork.repo_name}</a>
190 190 </p>
191 191 %endif
192 192
193 193 ## IMPORTED FROM REMOTE
194 194 %if repo_instance.clone_uri:
195 195 <p>
196 196 <i class="icon-code-fork"></i> ${_('Clone from')}
197 197 <a href="${h.url(h.safe_str(h.hide_credentials(repo_instance.clone_uri)))}">${h.hide_credentials(repo_instance.clone_uri)}</a>
198 198 </p>
199 199 %endif
200 200
201 201 ## LOCKING STATUS
202 202 %if repo_instance.locked[0]:
203 203 <p class="locking_locked">
204 204 <i class="icon-repo-lock"></i>
205 205 ${_('Repository locked by %(user)s') % {'user': h.person_by_id(repo_instance.locked[0])}}
206 206 </p>
207 207 %elif repo_instance.enable_locking:
208 208 <p class="locking_unlocked">
209 209 <i class="icon-repo-unlock"></i>
210 210 ${_('Repository not locked. Pull repository to lock it.')}
211 211 </p>
212 212 %endif
213 213
214 214 </div>
215 215 </%def>
216 216
217 217 <%def name="repo_menu(active=None)">
218 218 <%
219 219 def is_active(selected):
220 220 if selected == active:
221 221 return "active"
222 222 %>
223 223
224 224 <!--- CONTEXT BAR -->
225 225 <div id="context-bar">
226 226 <div class="wrapper">
227 227 <ul id="context-pages" class="horizontal-list navigation">
228 228 <li class="${is_active('summary')}"><a class="menulink" href="${h.url('summary_home', repo_name=c.repo_name)}"><div class="menulabel">${_('Summary')}</div></a></li>
229 229 <li class="${is_active('changelog')}"><a class="menulink" href="${h.url('changelog_home', repo_name=c.repo_name)}"><div class="menulabel">${_('Changelog')}</div></a></li>
230 230 <li class="${is_active('files')}"><a class="menulink" href="${h.url('files_home', repo_name=c.repo_name, revision=c.rhodecode_db_repo.landing_rev[1])}"><div class="menulabel">${_('Files')}</div></a></li>
231 231 <li class="${is_active('compare')}">
232 232 <a class="menulink" href="${h.url('compare_home',repo_name=c.repo_name)}"><div class="menulabel">${_('Compare')}</div></a>
233 233 </li>
234 234 ## TODO: anderson: ideally it would have a function on the scm_instance "enable_pullrequest() and enable_fork()"
235 235 %if c.rhodecode_db_repo.repo_type in ['git','hg']:
236 236 <li class="${is_active('showpullrequest')}">
237 237 <a class="menulink" href="${h.url('pullrequest_show_all',repo_name=c.repo_name)}" title="${_('Show Pull Requests for %s') % c.repo_name}">
238 238 %if c.repository_pull_requests:
239 239 <span class="pr_notifications">${c.repository_pull_requests}</span>
240 240 %endif
241 241 <div class="menulabel">${_('Pull Requests')}</div>
242 242 </a>
243 243 </li>
244 244 %endif
245 245 <li class="${is_active('options')}">
246 246 <a class="menulink" href="#" class="dropdown"><div class="menulabel">${_('Options')} <div class="show_more"></div></div></a>
247 247 <ul class="submenu">
248 248 %if h.HasRepoPermissionAll('repository.admin')(c.repo_name):
249 <li><a href="${h.url('edit_repo',repo_name=c.repo_name)}">${_('Settings')}</a></li>
249 <li><a href="${h.route_path('edit_repo',repo_name=c.repo_name)}">${_('Settings')}</a></li>
250 250 %endif
251 251 %if c.rhodecode_db_repo.fork:
252 252 <li><a href="${h.url('compare_url',repo_name=c.rhodecode_db_repo.fork.repo_name,source_ref_type=c.rhodecode_db_repo.landing_rev[0],source_ref=c.rhodecode_db_repo.landing_rev[1], target_repo=c.repo_name,target_ref_type='branch' if request.GET.get('branch') else c.rhodecode_db_repo.landing_rev[0],target_ref=request.GET.get('branch') or c.rhodecode_db_repo.landing_rev[1], merge=1)}">
253 253 ${_('Compare fork')}</a></li>
254 254 %endif
255 255
256 256 <li><a href="${h.route_path('search_repo',repo_name=c.repo_name)}">${_('Search')}</a></li>
257 257
258 258 %if h.HasRepoPermissionAny('repository.write','repository.admin')(c.repo_name) and c.rhodecode_db_repo.enable_locking:
259 259 %if c.rhodecode_db_repo.locked[0]:
260 260 <li><a class="locking_del" href="${h.url('toggle_locking',repo_name=c.repo_name)}">${_('Unlock')}</a></li>
261 261 %else:
262 262 <li><a class="locking_add" href="${h.url('toggle_locking',repo_name=c.repo_name)}">${_('Lock')}</a></li>
263 263 %endif
264 264 %endif
265 265 %if c.rhodecode_user.username != h.DEFAULT_USER:
266 266 %if c.rhodecode_db_repo.repo_type in ['git','hg']:
267 267 <li><a href="${h.url('repo_fork_home',repo_name=c.repo_name)}">${_('Fork')}</a></li>
268 268 <li><a href="${h.url('pullrequest_home',repo_name=c.repo_name)}">${_('Create Pull Request')}</a></li>
269 269 %endif
270 270 %endif
271 271 </ul>
272 272 </li>
273 273 </ul>
274 274 </div>
275 275 <div class="clear"></div>
276 276 </div>
277 277 <!--- END CONTEXT BAR -->
278 278
279 279 </%def>
280 280
281 281 <%def name="usermenu(active=False)">
282 282 ## USER MENU
283 283 <li id="quick_login_li" class="${'active' if active else ''}">
284 284 <a id="quick_login_link" class="menulink childs">
285 285 ${gravatar(c.rhodecode_user.email, 20)}
286 286 <span class="user">
287 287 %if c.rhodecode_user.username != h.DEFAULT_USER:
288 288 <span class="menu_link_user">${c.rhodecode_user.username}</span><div class="show_more"></div>
289 289 %else:
290 290 <span>${_('Sign in')}</span>
291 291 %endif
292 292 </span>
293 293 </a>
294 294
295 295 <div class="user-menu submenu">
296 296 <div id="quick_login">
297 297 %if c.rhodecode_user.username == h.DEFAULT_USER:
298 298 <h4>${_('Sign in to your account')}</h4>
299 299 ${h.form(h.route_path('login', _query={'came_from': h.url.current()}), needs_csrf_token=False)}
300 300 <div class="form form-vertical">
301 301 <div class="fields">
302 302 <div class="field">
303 303 <div class="label">
304 304 <label for="username">${_('Username')}:</label>
305 305 </div>
306 306 <div class="input">
307 307 ${h.text('username',class_='focus',tabindex=1)}
308 308 </div>
309 309
310 310 </div>
311 311 <div class="field">
312 312 <div class="label">
313 313 <label for="password">${_('Password')}:</label>
314 314 %if h.HasPermissionAny('hg.password_reset.enabled')():
315 315 <span class="forgot_password">${h.link_to(_('(Forgot password?)'),h.route_path('reset_password'), class_='pwd_reset')}</span>
316 316 %endif
317 317 </div>
318 318 <div class="input">
319 319 ${h.password('password',class_='focus',tabindex=2)}
320 320 </div>
321 321 </div>
322 322 <div class="buttons">
323 323 <div class="register">
324 324 %if h.HasPermissionAny('hg.admin', 'hg.register.auto_activate', 'hg.register.manual_activate')():
325 325 ${h.link_to(_("Don't have an account ?"),h.route_path('register'))}
326 326 %endif
327 327 </div>
328 328 <div class="submit">
329 329 ${h.submit('sign_in',_('Sign In'),class_="btn btn-small",tabindex=3)}
330 330 </div>
331 331 </div>
332 332 </div>
333 333 </div>
334 334 ${h.end_form()}
335 335 %else:
336 336 <div class="">
337 337 <div class="big_gravatar">${gravatar(c.rhodecode_user.email, 48)}</div>
338 338 <div class="full_name">${c.rhodecode_user.full_name_or_username}</div>
339 339 <div class="email">${c.rhodecode_user.email}</div>
340 340 </div>
341 341 <div class="">
342 342 <ol class="links">
343 343 <li>${h.link_to(_(u'My account'),h.route_path('my_account_profile'))}</li>
344 344 % if c.rhodecode_user.personal_repo_group:
345 345 <li>${h.link_to(_(u'My personal group'), h.url('repo_group_home', group_name=c.rhodecode_user.personal_repo_group.group_name))}</li>
346 346 % endif
347 347 <li class="logout">
348 348 ${h.secure_form(h.route_path('logout'))}
349 349 ${h.submit('log_out', _(u'Sign Out'),class_="btn btn-primary")}
350 350 ${h.end_form()}
351 351 </li>
352 352 </ol>
353 353 </div>
354 354 %endif
355 355 </div>
356 356 </div>
357 357 %if c.rhodecode_user.username != h.DEFAULT_USER:
358 358 <div class="pill_container">
359 359 % if c.unread_notifications == 0:
360 360 <a class="menu_link_notifications empty" href="${h.url('notifications')}">${c.unread_notifications}</a>
361 361 % else:
362 362 <a class="menu_link_notifications" href="${h.url('notifications')}">${c.unread_notifications}</a>
363 363 % endif
364 364 </div>
365 365 % endif
366 366 </li>
367 367 </%def>
368 368
369 369 <%def name="menu_items(active=None)">
370 370 <%
371 371 def is_active(selected):
372 372 if selected == active:
373 373 return "active"
374 374 return ""
375 375 %>
376 376 <ul id="quick" class="main_nav navigation horizontal-list">
377 377 <!-- repo switcher -->
378 378 <li class="${is_active('repositories')} repo_switcher_li has_select2">
379 379 <input id="repo_switcher" name="repo_switcher" type="hidden">
380 380 </li>
381 381
382 382 ## ROOT MENU
383 383 %if c.rhodecode_user.username != h.DEFAULT_USER:
384 384 <li class="${is_active('journal')}">
385 385 <a class="menulink" title="${_('Show activity journal')}" href="${h.url('journal')}">
386 386 <div class="menulabel">${_('Journal')}</div>
387 387 </a>
388 388 </li>
389 389 %else:
390 390 <li class="${is_active('journal')}">
391 391 <a class="menulink" title="${_('Show Public activity journal')}" href="${h.url('public_journal')}">
392 392 <div class="menulabel">${_('Public journal')}</div>
393 393 </a>
394 394 </li>
395 395 %endif
396 396 <li class="${is_active('gists')}">
397 397 <a class="menulink childs" title="${_('Show Gists')}" href="${h.url('gists')}">
398 398 <div class="menulabel">${_('Gists')}</div>
399 399 </a>
400 400 </li>
401 401 <li class="${is_active('search')}">
402 402 <a class="menulink" title="${_('Search in repositories you have access to')}" href="${h.route_path('search')}">
403 403 <div class="menulabel">${_('Search')}</div>
404 404 </a>
405 405 </li>
406 406 % if h.HasPermissionAll('hg.admin')('access admin main page'):
407 407 <li class="${is_active('admin')}">
408 408 <a class="menulink childs" title="${_('Admin settings')}" href="#" onclick="return false;">
409 409 <div class="menulabel">${_('Admin')} <div class="show_more"></div></div>
410 410 </a>
411 411 ${admin_menu()}
412 412 </li>
413 413 % elif c.rhodecode_user.repositories_admin or c.rhodecode_user.repository_groups_admin or c.rhodecode_user.user_groups_admin:
414 414 <li class="${is_active('admin')}">
415 415 <a class="menulink childs" title="${_('Delegated Admin settings')}">
416 416 <div class="menulabel">${_('Admin')} <div class="show_more"></div></div>
417 417 </a>
418 418 ${admin_menu_simple(c.rhodecode_user.repositories_admin,
419 419 c.rhodecode_user.repository_groups_admin,
420 420 c.rhodecode_user.user_groups_admin or h.HasPermissionAny('hg.usergroup.create.true')())}
421 421 </li>
422 422 % endif
423 423 % if c.debug_style:
424 424 <li class="${is_active('debug_style')}">
425 425 <a class="menulink" title="${_('Style')}" href="${h.url('debug_style_home')}">
426 426 <div class="menulabel">${_('Style')}</div>
427 427 </a>
428 428 </li>
429 429 % endif
430 430 ## render extra user menu
431 431 ${usermenu(active=(active=='my_account'))}
432 432 </ul>
433 433
434 434 <script type="text/javascript">
435 435 var visual_show_public_icon = "${c.visual.show_public_icon}" == "True";
436 436
437 437 /*format the look of items in the list*/
438 438 var format = function(state, escapeMarkup){
439 439 if (!state.id){
440 440 return state.text; // optgroup
441 441 }
442 442 var obj_dict = state.obj;
443 443 var tmpl = '';
444 444
445 445 if(obj_dict && state.type == 'repo'){
446 446 if(obj_dict['repo_type'] === 'hg'){
447 447 tmpl += '<i class="icon-hg"></i> ';
448 448 }
449 449 else if(obj_dict['repo_type'] === 'git'){
450 450 tmpl += '<i class="icon-git"></i> ';
451 451 }
452 452 else if(obj_dict['repo_type'] === 'svn'){
453 453 tmpl += '<i class="icon-svn"></i> ';
454 454 }
455 455 if(obj_dict['private']){
456 456 tmpl += '<i class="icon-lock" ></i> ';
457 457 }
458 458 else if(visual_show_public_icon){
459 459 tmpl += '<i class="icon-unlock-alt"></i> ';
460 460 }
461 461 }
462 462 if(obj_dict && state.type == 'commit') {
463 463 tmpl += '<i class="icon-tag"></i>';
464 464 }
465 465 if(obj_dict && state.type == 'group'){
466 466 tmpl += '<i class="icon-folder-close"></i> ';
467 467 }
468 468 tmpl += escapeMarkup(state.text);
469 469 return tmpl;
470 470 };
471 471
472 472 var formatResult = function(result, container, query, escapeMarkup) {
473 473 return format(result, escapeMarkup);
474 474 };
475 475
476 476 var formatSelection = function(data, container, escapeMarkup) {
477 477 return format(data, escapeMarkup);
478 478 };
479 479
480 480 $("#repo_switcher").select2({
481 481 cachedDataSource: {},
482 482 minimumInputLength: 2,
483 483 placeholder: '<div class="menulabel">${_('Go to')} <div class="show_more"></div></div>',
484 484 dropdownAutoWidth: true,
485 485 formatResult: formatResult,
486 486 formatSelection: formatSelection,
487 487 containerCssClass: "repo-switcher",
488 488 dropdownCssClass: "repo-switcher-dropdown",
489 489 escapeMarkup: function(m){
490 490 // don't escape our custom placeholder
491 491 if(m.substr(0,23) == '<div class="menulabel">'){
492 492 return m;
493 493 }
494 494
495 495 return Select2.util.escapeMarkup(m);
496 496 },
497 497 query: $.debounce(250, function(query){
498 498 self = this;
499 499 var cacheKey = query.term;
500 500 var cachedData = self.cachedDataSource[cacheKey];
501 501
502 502 if (cachedData) {
503 503 query.callback({results: cachedData.results});
504 504 } else {
505 505 $.ajax({
506 506 url: pyroutes.url('goto_switcher_data'),
507 507 data: {'query': query.term},
508 508 dataType: 'json',
509 509 type: 'GET',
510 510 success: function(data) {
511 511 self.cachedDataSource[cacheKey] = data;
512 512 query.callback({results: data.results});
513 513 },
514 514 error: function(data, textStatus, errorThrown) {
515 515 alert("Error while fetching entries.\nError code {0} ({1}).".format(data.status, data.statusText));
516 516 }
517 517 })
518 518 }
519 519 })
520 520 });
521 521
522 522 $("#repo_switcher").on('select2-selecting', function(e){
523 523 e.preventDefault();
524 524 window.location = e.choice.url;
525 525 });
526 526
527 527 </script>
528 528 <script src="${h.asset('js/rhodecode/base/keyboard-bindings.js', ver=c.rhodecode_version_hash)}"></script>
529 529 </%def>
530 530
531 531 <div class="modal" id="help_kb" tabindex="-1" role="dialog" aria-labelledby="myModalLabel" aria-hidden="true">
532 532 <div class="modal-dialog">
533 533 <div class="modal-content">
534 534 <div class="modal-header">
535 535 <button type="button" class="close" data-dismiss="modal" aria-hidden="true">&times;</button>
536 536 <h4 class="modal-title" id="myModalLabel">${_('Keyboard shortcuts')}</h4>
537 537 </div>
538 538 <div class="modal-body">
539 539 <div class="block-left">
540 540 <table class="keyboard-mappings">
541 541 <tbody>
542 542 <tr>
543 543 <th></th>
544 544 <th>${_('Site-wide shortcuts')}</th>
545 545 </tr>
546 546 <%
547 547 elems = [
548 548 ('/', 'Open quick search box'),
549 549 ('g h', 'Goto home page'),
550 550 ('g g', 'Goto my private gists page'),
551 551 ('g G', 'Goto my public gists page'),
552 552 ('n r', 'New repository page'),
553 553 ('n g', 'New gist page'),
554 554 ]
555 555 %>
556 556 %for key, desc in elems:
557 557 <tr>
558 558 <td class="keys">
559 559 <span class="key tag">${key}</span>
560 560 </td>
561 561 <td>${desc}</td>
562 562 </tr>
563 563 %endfor
564 564 </tbody>
565 565 </table>
566 566 </div>
567 567 <div class="block-left">
568 568 <table class="keyboard-mappings">
569 569 <tbody>
570 570 <tr>
571 571 <th></th>
572 572 <th>${_('Repositories')}</th>
573 573 </tr>
574 574 <%
575 575 elems = [
576 576 ('g s', 'Goto summary page'),
577 577 ('g c', 'Goto changelog page'),
578 578 ('g f', 'Goto files page'),
579 579 ('g F', 'Goto files page with file search activated'),
580 580 ('g p', 'Goto pull requests page'),
581 581 ('g o', 'Goto repository settings'),
582 582 ('g O', 'Goto repository permissions settings'),
583 583 ]
584 584 %>
585 585 %for key, desc in elems:
586 586 <tr>
587 587 <td class="keys">
588 588 <span class="key tag">${key}</span>
589 589 </td>
590 590 <td>${desc}</td>
591 591 </tr>
592 592 %endfor
593 593 </tbody>
594 594 </table>
595 595 </div>
596 596 </div>
597 597 <div class="modal-footer">
598 598 </div>
599 599 </div><!-- /.modal-content -->
600 600 </div><!-- /.modal-dialog -->
601 601 </div><!-- /.modal -->
@@ -1,317 +1,317 b''
1 1 ## DATA TABLE RE USABLE ELEMENTS
2 2 ## usage:
3 3 ## <%namespace name="dt" file="/data_table/_dt_elements.mako"/>
4 4 <%namespace name="base" file="/base/base.mako"/>
5 5
6 6 ## REPOSITORY RENDERERS
7 7 <%def name="quick_menu(repo_name)">
8 8 <i class="pointer icon-more"></i>
9 9 <div class="menu_items_container hidden">
10 10 <ul class="menu_items">
11 11 <li>
12 12 <a title="${_('Summary')}" href="${h.url('summary_home',repo_name=repo_name)}">
13 13 <span>${_('Summary')}</span>
14 14 </a>
15 15 </li>
16 16 <li>
17 17 <a title="${_('Changelog')}" href="${h.url('changelog_home',repo_name=repo_name)}">
18 18 <span>${_('Changelog')}</span>
19 19 </a>
20 20 </li>
21 21 <li>
22 22 <a title="${_('Files')}" href="${h.url('files_home',repo_name=repo_name)}">
23 23 <span>${_('Files')}</span>
24 24 </a>
25 25 </li>
26 26 <li>
27 27 <a title="${_('Fork')}" href="${h.url('repo_fork_home',repo_name=repo_name)}">
28 28 <span>${_('Fork')}</span>
29 29 </a>
30 30 </li>
31 31 </ul>
32 32 </div>
33 33 </%def>
34 34
35 35 <%def name="repo_name(name,rtype,rstate,private,fork_of,short_name=False,admin=False)">
36 36 <%
37 37 def get_name(name,short_name=short_name):
38 38 if short_name:
39 39 return name.split('/')[-1]
40 40 else:
41 41 return name
42 42 %>
43 43 <div class="${'repo_state_pending' if rstate == 'repo_state_pending' else ''} truncate">
44 44 ##NAME
45 <a href="${h.url('edit_repo' if admin else 'summary_home',repo_name=name)}">
45 <a href="${h.route_path('edit_repo',repo_name=name) if admin else h.url('summary_home',repo_name=name)}">
46 46
47 47 ##TYPE OF REPO
48 48 %if h.is_hg(rtype):
49 49 <span title="${_('Mercurial repository')}"><i class="icon-hg"></i></span>
50 50 %elif h.is_git(rtype):
51 51 <span title="${_('Git repository')}"><i class="icon-git"></i></span>
52 52 %elif h.is_svn(rtype):
53 53 <span title="${_('Subversion repository')}"><i class="icon-svn"></i></span>
54 54 %endif
55 55
56 56 ##PRIVATE/PUBLIC
57 57 %if private and c.visual.show_private_icon:
58 58 <i class="icon-lock" title="${_('Private repository')}"></i>
59 59 %elif not private and c.visual.show_public_icon:
60 60 <i class="icon-unlock-alt" title="${_('Public repository')}"></i>
61 61 %else:
62 62 <span></span>
63 63 %endif
64 64 ${get_name(name)}
65 65 </a>
66 66 %if fork_of:
67 67 <a href="${h.url('summary_home',repo_name=fork_of.repo_name)}"><i class="icon-code-fork"></i></a>
68 68 %endif
69 69 %if rstate == 'repo_state_pending':
70 70 <i class="icon-cogs" title="${_('Repository creating in progress...')}"></i>
71 71 %endif
72 72 </div>
73 73 </%def>
74 74
75 75 <%def name="repo_desc(description)">
76 76 <div class="truncate-wrap">${description}</div>
77 77 </%def>
78 78
79 79 <%def name="last_change(last_change)">
80 80 ${h.age_component(last_change)}
81 81 </%def>
82 82
83 83 <%def name="revision(name,rev,tip,author,last_msg)">
84 84 <div>
85 85 %if rev >= 0:
86 86 <code><a title="${h.tooltip('%s:\n\n%s' % (author,last_msg))}" class="tooltip" href="${h.url('changeset_home',repo_name=name,revision=tip)}">${'r%s:%s' % (rev,h.short_id(tip))}</a></code>
87 87 %else:
88 88 ${_('No commits yet')}
89 89 %endif
90 90 </div>
91 91 </%def>
92 92
93 93 <%def name="rss(name)">
94 94 %if c.rhodecode_user.username != h.DEFAULT_USER:
95 95 <a title="${_('Subscribe to %s rss feed')% name}" href="${h.url('rss_feed_home',repo_name=name,auth_token=c.rhodecode_user.feed_token)}"><i class="icon-rss-sign"></i></a>
96 96 %else:
97 97 <a title="${_('Subscribe to %s rss feed')% name}" href="${h.url('rss_feed_home',repo_name=name)}"><i class="icon-rss-sign"></i></a>
98 98 %endif
99 99 </%def>
100 100
101 101 <%def name="atom(name)">
102 102 %if c.rhodecode_user.username != h.DEFAULT_USER:
103 103 <a title="${_('Subscribe to %s atom feed')% name}" href="${h.url('atom_feed_home',repo_name=name,auth_token=c.rhodecode_user.feed_token)}"><i class="icon-rss-sign"></i></a>
104 104 %else:
105 105 <a title="${_('Subscribe to %s atom feed')% name}" href="${h.url('atom_feed_home',repo_name=name)}"><i class="icon-rss-sign"></i></a>
106 106 %endif
107 107 </%def>
108 108
109 109 <%def name="user_gravatar(email, size=16)">
110 110 <div class="rc-user tooltip" title="${h.author_string(email)}">
111 111 ${base.gravatar(email, 16)}
112 112 </div>
113 113 </%def>
114 114
115 115 <%def name="repo_actions(repo_name, super_user=True)">
116 116 <div>
117 117 <div class="grid_edit">
118 <a href="${h.url('edit_repo',repo_name=repo_name)}" title="${_('Edit')}">
118 <a href="${h.route_path('edit_repo',repo_name=repo_name)}" title="${_('Edit')}">
119 119 <i class="icon-pencil"></i>Edit</a>
120 120 </div>
121 121 <div class="grid_delete">
122 122 ${h.secure_form(h.url('repo', repo_name=repo_name),method='delete')}
123 123 ${h.submit('remove_%s' % repo_name,_('Delete'),class_="btn btn-link btn-danger",
124 124 onclick="return confirm('"+_('Confirm to delete this repository: %s') % repo_name+"');")}
125 125 ${h.end_form()}
126 126 </div>
127 127 </div>
128 128 </%def>
129 129
130 130 <%def name="repo_state(repo_state)">
131 131 <div>
132 132 %if repo_state == 'repo_state_pending':
133 133 <div class="tag tag4">${_('Creating')}</div>
134 134 %elif repo_state == 'repo_state_created':
135 135 <div class="tag tag1">${_('Created')}</div>
136 136 %else:
137 137 <div class="tag alert2" title="${repo_state}">invalid</div>
138 138 %endif
139 139 </div>
140 140 </%def>
141 141
142 142
143 143 ## REPO GROUP RENDERERS
144 144 <%def name="quick_repo_group_menu(repo_group_name)">
145 145 <i class="pointer icon-more"></i>
146 146 <div class="menu_items_container hidden">
147 147 <ul class="menu_items">
148 148 <li>
149 149 <a href="${h.url('repo_group_home',group_name=repo_group_name)}">
150 150 <span class="icon">
151 151 <i class="icon-file-text"></i>
152 152 </span>
153 153 <span>${_('Summary')}</span>
154 154 </a>
155 155 </li>
156 156
157 157 </ul>
158 158 </div>
159 159 </%def>
160 160
161 161 <%def name="repo_group_name(repo_group_name, children_groups=None)">
162 162 <div>
163 163 <a href="${h.url('repo_group_home',group_name=repo_group_name)}">
164 164 <i class="icon-folder-close" title="${_('Repository group')}"></i>
165 165 %if children_groups:
166 166 ${h.literal(' &raquo; '.join(children_groups))}
167 167 %else:
168 168 ${repo_group_name}
169 169 %endif
170 170 </a>
171 171 </div>
172 172 </%def>
173 173
174 174 <%def name="repo_group_desc(description)">
175 175 <div class="truncate-wrap">${description}</div>
176 176 </%def>
177 177
178 178 <%def name="repo_group_actions(repo_group_id, repo_group_name, gr_count)">
179 179 <div class="grid_edit">
180 180 <a href="${h.url('edit_repo_group',group_name=repo_group_name)}" title="${_('Edit')}">Edit</a>
181 181 </div>
182 182 <div class="grid_delete">
183 183 ${h.secure_form(h.url('delete_repo_group', group_name=repo_group_name),method='delete')}
184 184 ${h.submit('remove_%s' % repo_group_name,_('Delete'),class_="btn btn-link btn-danger",
185 185 onclick="return confirm('"+ungettext('Confirm to delete this group: %s with %s repository','Confirm to delete this group: %s with %s repositories',gr_count) % (repo_group_name, gr_count)+"');")}
186 186 ${h.end_form()}
187 187 </div>
188 188 </%def>
189 189
190 190
191 191 <%def name="user_actions(user_id, username)">
192 192 <div class="grid_edit">
193 193 <a href="${h.url('edit_user',user_id=user_id)}" title="${_('Edit')}">
194 194 <i class="icon-pencil"></i>Edit</a>
195 195 </div>
196 196 <div class="grid_delete">
197 197 ${h.secure_form(h.url('delete_user', user_id=user_id),method='delete')}
198 198 ${h.submit('remove_',_('Delete'),id="remove_user_%s" % user_id, class_="btn btn-link btn-danger",
199 199 onclick="return confirm('"+_('Confirm to delete this user: %s') % username+"');")}
200 200 ${h.end_form()}
201 201 </div>
202 202 </%def>
203 203
204 204 <%def name="user_group_actions(user_group_id, user_group_name)">
205 205 <div class="grid_edit">
206 206 <a href="${h.url('edit_users_group', user_group_id=user_group_id)}" title="${_('Edit')}">Edit</a>
207 207 </div>
208 208 <div class="grid_delete">
209 209 ${h.secure_form(h.url('delete_users_group', user_group_id=user_group_id),method='delete')}
210 210 ${h.submit('remove_',_('Delete'),id="remove_group_%s" % user_group_id, class_="btn btn-link btn-danger",
211 211 onclick="return confirm('"+_('Confirm to delete this user group: %s') % user_group_name+"');")}
212 212 ${h.end_form()}
213 213 </div>
214 214 </%def>
215 215
216 216
217 217 <%def name="user_name(user_id, username)">
218 218 ${h.link_to(h.person(username, 'username_or_name_or_email'), h.url('edit_user', user_id=user_id))}
219 219 </%def>
220 220
221 221 <%def name="user_profile(username)">
222 222 ${base.gravatar_with_user(username, 16)}
223 223 </%def>
224 224
225 225 <%def name="user_group_name(user_group_id, user_group_name)">
226 226 <div>
227 227 <a href="${h.url('edit_users_group', user_group_id=user_group_id)}">
228 228 <i class="icon-group" title="${_('User group')}"></i> ${user_group_name}</a>
229 229 </div>
230 230 </%def>
231 231
232 232
233 233 ## GISTS
234 234
235 235 <%def name="gist_gravatar(full_contact)">
236 236 <div class="gist_gravatar">
237 237 ${base.gravatar(full_contact, 30)}
238 238 </div>
239 239 </%def>
240 240
241 241 <%def name="gist_access_id(gist_access_id, full_contact)">
242 242 <div>
243 243 <b>
244 244 <a href="${h.url('gist',gist_id=gist_access_id)}">gist: ${gist_access_id}</a>
245 245 </b>
246 246 </div>
247 247 </%def>
248 248
249 249 <%def name="gist_author(full_contact, created_on, expires)">
250 250 ${base.gravatar_with_user(full_contact, 16)}
251 251 </%def>
252 252
253 253
254 254 <%def name="gist_created(created_on)">
255 255 <div class="created">
256 256 ${h.age_component(created_on, time_is_local=True)}
257 257 </div>
258 258 </%def>
259 259
260 260 <%def name="gist_expires(expires)">
261 261 <div class="created">
262 262 %if expires == -1:
263 263 ${_('never')}
264 264 %else:
265 265 ${h.age_component(h.time_to_utcdatetime(expires))}
266 266 %endif
267 267 </div>
268 268 </%def>
269 269
270 270 <%def name="gist_type(gist_type)">
271 271 %if gist_type != 'public':
272 272 <div class="tag">${_('Private')}</div>
273 273 %endif
274 274 </%def>
275 275
276 276 <%def name="gist_description(gist_description)">
277 277 ${gist_description}
278 278 </%def>
279 279
280 280
281 281 ## PULL REQUESTS GRID RENDERERS
282 282
283 283 <%def name="pullrequest_target_repo(repo_name)">
284 284 <div class="truncate">
285 285 ${h.link_to(repo_name,h.url('summary_home',repo_name=repo_name))}
286 286 </div>
287 287 </%def>
288 288 <%def name="pullrequest_status(status)">
289 289 <div class="${'flag_status %s' % status} pull-left"></div>
290 290 </%def>
291 291
292 292 <%def name="pullrequest_title(title, description)">
293 293 ${title} <br/>
294 294 ${h.shorter(description, 40)}
295 295 </%def>
296 296
297 297 <%def name="pullrequest_comments(comments_nr)">
298 298 <i class="icon-comment"></i> ${comments_nr}
299 299 </%def>
300 300
301 301 <%def name="pullrequest_name(pull_request_id, target_repo_name, short=False)">
302 302 <a href="${h.url('pullrequest_show',repo_name=target_repo_name,pull_request_id=pull_request_id)}">
303 303 % if short:
304 304 #${pull_request_id}
305 305 % else:
306 306 ${_('Pull request #%(pr_number)s') % {'pr_number': pull_request_id,}}
307 307 % endif
308 308 </a>
309 309 </%def>
310 310
311 311 <%def name="pullrequest_updated_on(updated_on)">
312 312 ${h.age_component(h.time_to_utcdatetime(updated_on))}
313 313 </%def>
314 314
315 315 <%def name="pullrequest_author(full_contact)">
316 316 ${base.gravatar_with_user(full_contact, 16)}
317 317 </%def>
@@ -1,202 +1,202 b''
1 1 <%def name="refs_counters(branches, closed_branches, tags, bookmarks)">
2 2 <span class="branchtag tag">
3 3 <a href="${h.url('branches_home',repo_name=c.repo_name)}" class="childs">
4 4 <i class="icon-branch"></i>${ungettext(
5 5 '%(num)s Branch','%(num)s Branches', len(branches)) % {'num': len(branches)}}</a>
6 6 </span>
7 7
8 8 %if closed_branches:
9 9 <span class="branchtag tag">
10 10 <a href="${h.url('branches_home',repo_name=c.repo_name)}" class="childs">
11 11 <i class="icon-branch"></i>${ungettext(
12 12 '%(num)s Closed Branch', '%(num)s Closed Branches', len(closed_branches)) % {'num': len(closed_branches)}}</a>
13 13 </span>
14 14 %endif
15 15
16 16 <span class="tagtag tag">
17 17 <a href="${h.url('tags_home',repo_name=c.repo_name)}" class="childs">
18 18 <i class="icon-tag"></i>${ungettext(
19 19 '%(num)s Tag', '%(num)s Tags', len(tags)) % {'num': len(tags)}}</a>
20 20 </span>
21 21
22 22 %if bookmarks:
23 23 <span class="booktag tag">
24 24 <a href="${h.url('bookmarks_home',repo_name=c.repo_name)}" class="childs">
25 25 <i class="icon-bookmark"></i>${ungettext(
26 26 '%(num)s Bookmark', '%(num)s Bookmarks', len(bookmarks)) % {'num': len(bookmarks)}}</a>
27 27 </span>
28 28 %endif
29 29 </%def>
30 30
31 31 <%def name="summary_detail(breadcrumbs_links, show_downloads=True)">
32 32 <% summary = lambda n:{False:'summary-short'}.get(n) %>
33 33
34 34 <div id="summary-menu-stats" class="summary-detail">
35 35 <div class="summary-detail-header">
36 36 <div class="breadcrumbs files_location">
37 37 <h4>
38 38 ${breadcrumbs_links}
39 39 </h4>
40 40 </div>
41 41 <div id="summary_details_expand" class="btn-collapse" data-toggle="summary-details">
42 42 ${_('Show More')}
43 43 </div>
44 44 </div>
45 45
46 46 <div class="fieldset">
47 47 %if h.is_svn_without_proxy(c.rhodecode_db_repo):
48 48 <div class="left-label disabled">
49 49 ${_('Read-only url')}:
50 50 </div>
51 51 <div class="right-content disabled">
52 52 <input type="text" class="input-monospace" id="clone_url" disabled value="${c.clone_repo_url}"/>
53 53 <input type="text" class="input-monospace" id="clone_url_id" disabled value="${c.clone_repo_url_id}" style="display: none;"/>
54 54 <a id="clone_by_name" class="clone" style="display: none;">${_('Show by Name')}</a>
55 55 <a id="clone_by_id" class="clone">${_('Show by ID')}</a>
56 56 <p class="help-block">${_('SVN Protocol is disabled. To enable it, see the')} <a href="${h.route_url('enterprise_svn_setup')}" target="_blank">${_('documentation here')}</a>.</p>
57 57 </div>
58 58 %else:
59 59 <div class="left-label">
60 60 ${_('Clone url')}:
61 61 </div>
62 62 <div class="right-content">
63 63 <input type="text" class="input-monospace" id="clone_url" readonly="readonly" value="${c.clone_repo_url}"/>
64 64 <input type="text" class="input-monospace" id="clone_url_id" readonly="readonly" value="${c.clone_repo_url_id}" style="display: none;"/>
65 65 <a id="clone_by_name" class="clone" style="display: none;">${_('Show by Name')}</a>
66 66 <a id="clone_by_id" class="clone">${_('Show by ID')}</a>
67 67 </div>
68 68 %endif
69 69 </div>
70 70
71 71 <div class="fieldset collapsable-content" data-toggle="summary-details" style="display: none;">
72 72 <div class="left-label">
73 73 ${_('Description')}:
74 74 </div>
75 75 <div class="right-content">
76 76 %if c.visual.stylify_metatags:
77 77 <div class="input ${summary(c.show_stats)} desc">${h.urlify_text(h.escaped_stylize(c.rhodecode_db_repo.description))}</div>
78 78 %else:
79 79 <div class="input ${summary(c.show_stats)} desc">${h.urlify_text(h.html_escape(c.rhodecode_db_repo.description))}</div>
80 80 %endif
81 81 </div>
82 82 </div>
83 83
84 84 <div class="fieldset collapsable-content" data-toggle="summary-details" style="display: none;">
85 85 <div class="left-label">
86 86 ${_('Information')}:
87 87 </div>
88 88 <div class="right-content">
89 89
90 90 <div class="repo-size">
91 91 <% commit_rev = c.rhodecode_db_repo.changeset_cache.get('revision') %>
92 92
93 93 ## commits
94 94 % if commit_rev == -1:
95 95 ${ungettext('%(num)s Commit', '%(num)s Commits', 0) % {'num': 0}},
96 96 % else:
97 97 <a href="${h.url('changelog_home', repo_name=c.repo_name)}">
98 98 ${ungettext('%(num)s Commit', '%(num)s Commits', commit_rev) % {'num': commit_rev}}</a>,
99 99 % endif
100 100
101 101 ## forks
102 102 <a title="${_('Number of Repository Forks')}" href="${h.url('repo_forks_home', repo_name=c.repo_name)}">
103 103 ${c.repository_forks} ${ungettext('Fork', 'Forks', c.repository_forks)}</a>,
104 104
105 105 ## repo size
106 106 % if commit_rev == -1:
107 107 <span class="stats-bullet">0 B</span>
108 108 % else:
109 109 <span class="stats-bullet" id="repo_size_container">
110 110 ${_('Calculating Repository Size...')}
111 111 </span>
112 112 % endif
113 113 </div>
114 114
115 115 <div class="commit-info">
116 116 <div class="tags">
117 117 % if c.rhodecode_repo:
118 118 ${refs_counters(
119 119 c.rhodecode_repo.branches,
120 120 c.rhodecode_repo.branches_closed,
121 121 c.rhodecode_repo.tags,
122 122 c.rhodecode_repo.bookmarks)}
123 123 % else:
124 124 ## missing requirements can make c.rhodecode_repo None
125 125 ${refs_counters([], [], [], [])}
126 126 % endif
127 127 </div>
128 128 </div>
129 129
130 130 </div>
131 131 </div>
132 132
133 133 <div class="fieldset collapsable-content" data-toggle="summary-details" style="display: none;">
134 134 <div class="left-label">
135 135 ${_('Statistics')}:
136 136 </div>
137 137 <div class="right-content">
138 138 <div class="input ${summary(c.show_stats)} statistics">
139 139 % if c.show_stats:
140 140 <div id="lang_stats" class="enabled">
141 141 ${_('Calculating Code Statistics...')}
142 142 </div>
143 143 % else:
144 144 <span class="disabled">
145 145 ${_('Statistics are disabled for this repository')}
146 146 </span>
147 147 % if h.HasPermissionAll('hg.admin')('enable stats on from summary'):
148 , ${h.link_to(_('enable statistics'),h.url('edit_repo',repo_name=c.repo_name, anchor='repo_enable_statistics'))}
148 , ${h.link_to(_('enable statistics'),h.route_path('edit_repo',repo_name=c.repo_name, anchor='repo_enable_statistics'))}
149 149 % endif
150 150 % endif
151 151 </div>
152 152
153 153 </div>
154 154 </div>
155 155
156 156 % if show_downloads:
157 157 <div class="fieldset collapsable-content" data-toggle="summary-details" style="display: none;">
158 158 <div class="left-label">
159 159 ${_('Downloads')}:
160 160 </div>
161 161 <div class="right-content">
162 162 <div class="input ${summary(c.show_stats)} downloads">
163 163 % if c.rhodecode_repo and len(c.rhodecode_repo.revisions) == 0:
164 164 <span class="disabled">
165 165 ${_('There are no downloads yet')}
166 166 </span>
167 167 % elif not c.enable_downloads:
168 168 <span class="disabled">
169 169 ${_('Downloads are disabled for this repository')}
170 170 </span>
171 171 % if h.HasPermissionAll('hg.admin')('enable downloads on from summary'):
172 , ${h.link_to(_('enable downloads'),h.url('edit_repo',repo_name=c.repo_name, anchor='repo_enable_downloads'))}
172 , ${h.link_to(_('enable downloads'),h.route_path('edit_repo',repo_name=c.repo_name, anchor='repo_enable_downloads'))}
173 173 % endif
174 174 % else:
175 175 <span class="enabled">
176 176 <a id="archive_link" class="btn btn-small" href="${h.url('files_archive_home',repo_name=c.rhodecode_db_repo.repo_name,fname='tip.zip')}">
177 177 <i class="icon-archive"></i> tip.zip
178 178 ## replaced by some JS on select
179 179 </a>
180 180 </span>
181 181 ${h.hidden('download_options')}
182 182 % endif
183 183 </div>
184 184 </div>
185 185 </div>
186 186 % endif
187 187
188 188 </div><!--end summary-detail-->
189 189 </%def>
190 190
191 191 <%def name="summary_stats(gravatar_function)">
192 192 <div class="sidebar-right">
193 193 <div class="summary-detail-header">
194 194 <h4 class="item">
195 195 ${_('Owner')}
196 196 </h4>
197 197 </div>
198 198 <div class="sidebar-right-content">
199 199 ${gravatar_function(c.rhodecode_db_repo.user.email, 16)}
200 200 </div>
201 201 </div><!--end sidebar-right-->
202 202 </%def>
General Comments 0
You need to be logged in to leave comments. Login now