##// END OF EJS Templates
authn: Allow users to store plugin ID's starting with the legacy plugin prefix.
johbo -
r133:1c4d75a0 default
parent child Browse files
Show More
@@ -1,1076 +1,1077 b''
1 1 # -*- coding: utf-8 -*-
2 2
3 3 # Copyright (C) 2010-2016 RhodeCode GmbH
4 4 #
5 5 # This program is free software: you can redistribute it and/or modify
6 6 # it under the terms of the GNU Affero General Public License, version 3
7 7 # (only), as published by the Free Software Foundation.
8 8 #
9 9 # This program is distributed in the hope that it will be useful,
10 10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 12 # GNU General Public License for more details.
13 13 #
14 14 # You should have received a copy of the GNU Affero General Public License
15 15 # along with this program. If not, see <http://www.gnu.org/licenses/>.
16 16 #
17 17 # This program is dual-licensed. If you wish to learn more about the
18 18 # RhodeCode Enterprise Edition, including its added features, Support services,
19 19 # and proprietary license terms, please see https://rhodecode.com/licenses/
20 20
21 21 """
22 22 Set of generic validators
23 23 """
24 24
25 25 import logging
26 26 import os
27 27 import re
28 28 from collections import defaultdict
29 29
30 30 import formencode
31 31 import ipaddress
32 32 from formencode.validators import (
33 33 UnicodeString, OneOf, Int, Number, Regex, Email, Bool, StringBoolean, Set,
34 34 NotEmpty, IPAddress, CIDR, String, FancyValidator
35 35 )
36 36 from pylons.i18n.translation import _
37 37 from sqlalchemy.sql.expression import true
38 38 from sqlalchemy.util import OrderedSet
39 39 from webhelpers.pylonslib.secure_form import authentication_token
40 40
41 from rhodecode.authentication import legacy_plugin_prefix
41 42 from rhodecode.config.routing import ADMIN_PREFIX
42 43 from rhodecode.lib.auth import HasRepoGroupPermissionAny, HasPermissionAny
43 from rhodecode.lib.exceptions import LdapImportError
44 44 from rhodecode.lib.utils import repo_name_slug, make_db_config
45 45 from rhodecode.lib.utils2 import safe_int, str2bool, aslist, md5
46 46 from rhodecode.lib.vcs.backends.git.repository import GitRepository
47 47 from rhodecode.lib.vcs.backends.hg.repository import MercurialRepository
48 48 from rhodecode.lib.vcs.backends.svn.repository import SubversionRepository
49 49 from rhodecode.model.db import (
50 50 RepoGroup, Repository, UserGroup, User, ChangesetStatus, Gist)
51 51 from rhodecode.model.settings import VcsSettingsModel
52 52
53 53 # silence warnings and pylint
54 54 UnicodeString, OneOf, Int, Number, Regex, Email, Bool, StringBoolean, Set, \
55 55 NotEmpty, IPAddress, CIDR, String, FancyValidator
56 56
57 57 log = logging.getLogger(__name__)
58 58
59 59
60 60 class _Missing(object):
61 61 pass
62 62
63 63 Missing = _Missing()
64 64
65 65
66 66 class StateObj(object):
67 67 """
68 68 this is needed to translate the messages using _() in validators
69 69 """
70 70 _ = staticmethod(_)
71 71
72 72
73 73 def M(self, key, state=None, **kwargs):
74 74 """
75 75 returns string from self.message based on given key,
76 76 passed kw params are used to substitute %(named)s params inside
77 77 translated strings
78 78
79 79 :param msg:
80 80 :param state:
81 81 """
82 82 if state is None:
83 83 state = StateObj()
84 84 else:
85 85 state._ = staticmethod(_)
86 86 # inject validator into state object
87 87 return self.message(key, state, **kwargs)
88 88
89 89
90 90 def UniqueList(convert=None):
91 91 class _UniqueList(formencode.FancyValidator):
92 92 """
93 93 Unique List !
94 94 """
95 95 messages = {
96 96 'empty': _(u'Value cannot be an empty list'),
97 97 'missing_value': _(u'Value cannot be an empty list'),
98 98 }
99 99
100 100 def _to_python(self, value, state):
101 101 ret_val = []
102 102
103 103 def make_unique(value):
104 104 seen = []
105 105 return [c for c in value if not (c in seen or seen.append(c))]
106 106
107 107 if isinstance(value, list):
108 108 ret_val = make_unique(value)
109 109 elif isinstance(value, set):
110 110 ret_val = make_unique(list(value))
111 111 elif isinstance(value, tuple):
112 112 ret_val = make_unique(list(value))
113 113 elif value is None:
114 114 ret_val = []
115 115 else:
116 116 ret_val = [value]
117 117
118 118 if convert:
119 119 ret_val = map(convert, ret_val)
120 120 return ret_val
121 121
122 122 def empty_value(self, value):
123 123 return []
124 124
125 125 return _UniqueList
126 126
127 127
128 128 def UniqueListFromString():
129 129 class _UniqueListFromString(UniqueList()):
130 130 def _to_python(self, value, state):
131 131 if isinstance(value, basestring):
132 132 value = aslist(value, ',')
133 133 return super(_UniqueListFromString, self)._to_python(value, state)
134 134 return _UniqueListFromString
135 135
136 136
137 137 def ValidSvnPattern(section, repo_name=None):
138 138 class _validator(formencode.validators.FancyValidator):
139 139 messages = {
140 140 'pattern_exists': _(u'Pattern already exists'),
141 141 }
142 142
143 143 def validate_python(self, value, state):
144 144 if not value:
145 145 return
146 146 model = VcsSettingsModel(repo=repo_name)
147 147 ui_settings = model.get_svn_patterns(section=section)
148 148 for entry in ui_settings:
149 149 if value == entry.value:
150 150 msg = M(self, 'pattern_exists', state)
151 151 raise formencode.Invalid(msg, value, state)
152 152 return _validator
153 153
154 154
155 155 def ValidUsername(edit=False, old_data={}):
156 156 class _validator(formencode.validators.FancyValidator):
157 157 messages = {
158 158 'username_exists': _(u'Username "%(username)s" already exists'),
159 159 'system_invalid_username':
160 160 _(u'Username "%(username)s" is forbidden'),
161 161 'invalid_username':
162 162 _(u'Username may only contain alphanumeric characters '
163 163 u'underscores, periods or dashes and must begin with '
164 164 u'alphanumeric character or underscore')
165 165 }
166 166
167 167 def validate_python(self, value, state):
168 168 if value in ['default', 'new_user']:
169 169 msg = M(self, 'system_invalid_username', state, username=value)
170 170 raise formencode.Invalid(msg, value, state)
171 171 # check if user is unique
172 172 old_un = None
173 173 if edit:
174 174 old_un = User.get(old_data.get('user_id')).username
175 175
176 176 if old_un != value or not edit:
177 177 if User.get_by_username(value, case_insensitive=True):
178 178 msg = M(self, 'username_exists', state, username=value)
179 179 raise formencode.Invalid(msg, value, state)
180 180
181 181 if (re.match(r'^[\w]{1}[\w\-\.]{0,254}$', value)
182 182 is None):
183 183 msg = M(self, 'invalid_username', state)
184 184 raise formencode.Invalid(msg, value, state)
185 185 return _validator
186 186
187 187
188 188 def ValidRegex(msg=None):
189 189 class _validator(formencode.validators.Regex):
190 190 messages = {'invalid': msg or _(u'The input is not valid')}
191 191 return _validator
192 192
193 193
194 194 def ValidRepoUser():
195 195 class _validator(formencode.validators.FancyValidator):
196 196 messages = {
197 197 'invalid_username': _(u'Username %(username)s is not valid')
198 198 }
199 199
200 200 def validate_python(self, value, state):
201 201 try:
202 202 User.query().filter(User.active == true())\
203 203 .filter(User.username == value).one()
204 204 except Exception:
205 205 msg = M(self, 'invalid_username', state, username=value)
206 206 raise formencode.Invalid(
207 207 msg, value, state, error_dict={'username': msg}
208 208 )
209 209
210 210 return _validator
211 211
212 212
213 213 def ValidUserGroup(edit=False, old_data={}):
214 214 class _validator(formencode.validators.FancyValidator):
215 215 messages = {
216 216 'invalid_group': _(u'Invalid user group name'),
217 217 'group_exist': _(u'User group "%(usergroup)s" already exists'),
218 218 'invalid_usergroup_name':
219 219 _(u'user group name may only contain alphanumeric '
220 220 u'characters underscores, periods or dashes and must begin '
221 221 u'with alphanumeric character')
222 222 }
223 223
224 224 def validate_python(self, value, state):
225 225 if value in ['default']:
226 226 msg = M(self, 'invalid_group', state)
227 227 raise formencode.Invalid(
228 228 msg, value, state, error_dict={'users_group_name': msg}
229 229 )
230 230 # check if group is unique
231 231 old_ugname = None
232 232 if edit:
233 233 old_id = old_data.get('users_group_id')
234 234 old_ugname = UserGroup.get(old_id).users_group_name
235 235
236 236 if old_ugname != value or not edit:
237 237 is_existing_group = UserGroup.get_by_group_name(
238 238 value, case_insensitive=True)
239 239 if is_existing_group:
240 240 msg = M(self, 'group_exist', state, usergroup=value)
241 241 raise formencode.Invalid(
242 242 msg, value, state, error_dict={'users_group_name': msg}
243 243 )
244 244
245 245 if re.match(r'^[a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+$', value) is None:
246 246 msg = M(self, 'invalid_usergroup_name', state)
247 247 raise formencode.Invalid(
248 248 msg, value, state, error_dict={'users_group_name': msg}
249 249 )
250 250
251 251 return _validator
252 252
253 253
254 254 def ValidRepoGroup(edit=False, old_data={}, can_create_in_root=False):
255 255 class _validator(formencode.validators.FancyValidator):
256 256 messages = {
257 257 'group_parent_id': _(u'Cannot assign this group as parent'),
258 258 'group_exists': _(u'Group "%(group_name)s" already exists'),
259 259 'repo_exists': _(u'Repository with name "%(group_name)s" '
260 260 u'already exists'),
261 261 'permission_denied': _(u"no permission to store repository group"
262 262 u"in this location"),
263 263 'permission_denied_root': _(
264 264 u"no permission to store repository group "
265 265 u"in root location")
266 266 }
267 267
268 268 def _to_python(self, value, state):
269 269 group_name = repo_name_slug(value.get('group_name', ''))
270 270 group_parent_id = safe_int(value.get('group_parent_id'))
271 271 gr = RepoGroup.get(group_parent_id)
272 272 if gr:
273 273 parent_group_path = gr.full_path
274 274 # value needs to be aware of group name in order to check
275 275 # db key This is an actual just the name to store in the
276 276 # database
277 277 group_name_full = (
278 278 parent_group_path + RepoGroup.url_sep() + group_name)
279 279 else:
280 280 group_name_full = group_name
281 281
282 282 value['group_name'] = group_name
283 283 value['group_name_full'] = group_name_full
284 284 value['group_parent_id'] = group_parent_id
285 285 return value
286 286
287 287 def validate_python(self, value, state):
288 288
289 289 old_group_name = None
290 290 group_name = value.get('group_name')
291 291 group_name_full = value.get('group_name_full')
292 292 group_parent_id = safe_int(value.get('group_parent_id'))
293 293 if group_parent_id == -1:
294 294 group_parent_id = None
295 295
296 296 group_obj = RepoGroup.get(old_data.get('group_id'))
297 297 parent_group_changed = False
298 298 if edit:
299 299 old_group_name = group_obj.group_name
300 300 old_group_parent_id = group_obj.group_parent_id
301 301
302 302 if group_parent_id != old_group_parent_id:
303 303 parent_group_changed = True
304 304
305 305 # TODO: mikhail: the following if statement is not reached
306 306 # since group_parent_id's OneOf validation fails before.
307 307 # Can be removed.
308 308
309 309 # check against setting a parent of self
310 310 parent_of_self = (
311 311 old_data['group_id'] == group_parent_id
312 312 if group_parent_id else False
313 313 )
314 314 if parent_of_self:
315 315 msg = M(self, 'group_parent_id', state)
316 316 raise formencode.Invalid(
317 317 msg, value, state, error_dict={'group_parent_id': msg}
318 318 )
319 319
320 320 # group we're moving current group inside
321 321 child_group = None
322 322 if group_parent_id:
323 323 child_group = RepoGroup.query().filter(
324 324 RepoGroup.group_id == group_parent_id).scalar()
325 325
326 326 # do a special check that we cannot move a group to one of
327 327 # it's children
328 328 if edit and child_group:
329 329 parents = [x.group_id for x in child_group.parents]
330 330 move_to_children = old_data['group_id'] in parents
331 331 if move_to_children:
332 332 msg = M(self, 'group_parent_id', state)
333 333 raise formencode.Invalid(
334 334 msg, value, state, error_dict={'group_parent_id': msg})
335 335
336 336 # Check if we have permission to store in the parent.
337 337 # Only check if the parent group changed.
338 338 if parent_group_changed:
339 339 if child_group is None:
340 340 if not can_create_in_root:
341 341 msg = M(self, 'permission_denied_root', state)
342 342 raise formencode.Invalid(
343 343 msg, value, state,
344 344 error_dict={'group_parent_id': msg})
345 345 else:
346 346 valid = HasRepoGroupPermissionAny('group.admin')
347 347 forbidden = not valid(
348 348 child_group.group_name, 'can create group validator')
349 349 if forbidden:
350 350 msg = M(self, 'permission_denied', state)
351 351 raise formencode.Invalid(
352 352 msg, value, state,
353 353 error_dict={'group_parent_id': msg})
354 354
355 355 # if we change the name or it's new group, check for existing names
356 356 # or repositories with the same name
357 357 if old_group_name != group_name_full or not edit:
358 358 # check group
359 359 gr = RepoGroup.get_by_group_name(group_name_full)
360 360 if gr:
361 361 msg = M(self, 'group_exists', state, group_name=group_name)
362 362 raise formencode.Invalid(
363 363 msg, value, state, error_dict={'group_name': msg})
364 364
365 365 # check for same repo
366 366 repo = Repository.get_by_repo_name(group_name_full)
367 367 if repo:
368 368 msg = M(self, 'repo_exists', state, group_name=group_name)
369 369 raise formencode.Invalid(
370 370 msg, value, state, error_dict={'group_name': msg})
371 371
372 372 return _validator
373 373
374 374
375 375 def ValidPassword():
376 376 class _validator(formencode.validators.FancyValidator):
377 377 messages = {
378 378 'invalid_password':
379 379 _(u'Invalid characters (non-ascii) in password')
380 380 }
381 381
382 382 def validate_python(self, value, state):
383 383 try:
384 384 (value or '').decode('ascii')
385 385 except UnicodeError:
386 386 msg = M(self, 'invalid_password', state)
387 387 raise formencode.Invalid(msg, value, state,)
388 388 return _validator
389 389
390 390
391 391 def ValidOldPassword(username):
392 392 class _validator(formencode.validators.FancyValidator):
393 393 messages = {
394 394 'invalid_password': _(u'Invalid old password')
395 395 }
396 396
397 397 def validate_python(self, value, state):
398 398 from rhodecode.authentication.base import authenticate, HTTP_TYPE
399 399 if not authenticate(username, value, '', HTTP_TYPE):
400 400 msg = M(self, 'invalid_password', state)
401 401 raise formencode.Invalid(
402 402 msg, value, state, error_dict={'current_password': msg}
403 403 )
404 404 return _validator
405 405
406 406
407 407 def ValidPasswordsMatch(
408 408 passwd='new_password', passwd_confirmation='password_confirmation'):
409 409 class _validator(formencode.validators.FancyValidator):
410 410 messages = {
411 411 'password_mismatch': _(u'Passwords do not match'),
412 412 }
413 413
414 414 def validate_python(self, value, state):
415 415
416 416 pass_val = value.get('password') or value.get(passwd)
417 417 if pass_val != value[passwd_confirmation]:
418 418 msg = M(self, 'password_mismatch', state)
419 419 raise formencode.Invalid(
420 420 msg, value, state,
421 421 error_dict={passwd: msg, passwd_confirmation: msg}
422 422 )
423 423 return _validator
424 424
425 425
426 426 def ValidAuth():
427 427 class _validator(formencode.validators.FancyValidator):
428 428 messages = {
429 429 'invalid_password': _(u'invalid password'),
430 430 'invalid_username': _(u'invalid user name'),
431 431 'disabled_account': _(u'Your account is disabled')
432 432 }
433 433
434 434 def validate_python(self, value, state):
435 435 from rhodecode.authentication.base import authenticate, HTTP_TYPE
436 436
437 437 password = value['password']
438 438 username = value['username']
439 439
440 440 if not authenticate(username, password, '', HTTP_TYPE,
441 441 skip_missing=True):
442 442 user = User.get_by_username(username)
443 443 if user and not user.active:
444 444 log.warning('user %s is disabled', username)
445 445 msg = M(self, 'disabled_account', state)
446 446 raise formencode.Invalid(
447 447 msg, value, state, error_dict={'username': msg}
448 448 )
449 449 else:
450 450 log.warning('user `%s` failed to authenticate', username)
451 451 msg = M(self, 'invalid_username', state)
452 452 msg2 = M(self, 'invalid_password', state)
453 453 raise formencode.Invalid(
454 454 msg, value, state,
455 455 error_dict={'username': msg, 'password': msg2}
456 456 )
457 457 return _validator
458 458
459 459
460 460 def ValidAuthToken():
461 461 class _validator(formencode.validators.FancyValidator):
462 462 messages = {
463 463 'invalid_token': _(u'Token mismatch')
464 464 }
465 465
466 466 def validate_python(self, value, state):
467 467 if value != authentication_token():
468 468 msg = M(self, 'invalid_token', state)
469 469 raise formencode.Invalid(msg, value, state)
470 470 return _validator
471 471
472 472
473 473 def ValidRepoName(edit=False, old_data={}):
474 474 class _validator(formencode.validators.FancyValidator):
475 475 messages = {
476 476 'invalid_repo_name':
477 477 _(u'Repository name %(repo)s is disallowed'),
478 478 # top level
479 479 'repository_exists': _(u'Repository with name %(repo)s '
480 480 u'already exists'),
481 481 'group_exists': _(u'Repository group with name "%(repo)s" '
482 482 u'already exists'),
483 483 # inside a group
484 484 'repository_in_group_exists': _(u'Repository with name %(repo)s '
485 485 u'exists in group "%(group)s"'),
486 486 'group_in_group_exists': _(
487 487 u'Repository group with name "%(repo)s" '
488 488 u'exists in group "%(group)s"'),
489 489 }
490 490
491 491 def _to_python(self, value, state):
492 492 repo_name = repo_name_slug(value.get('repo_name', ''))
493 493 repo_group = value.get('repo_group')
494 494 if repo_group:
495 495 gr = RepoGroup.get(repo_group)
496 496 group_path = gr.full_path
497 497 group_name = gr.group_name
498 498 # value needs to be aware of group name in order to check
499 499 # db key This is an actual just the name to store in the
500 500 # database
501 501 repo_name_full = group_path + RepoGroup.url_sep() + repo_name
502 502 else:
503 503 group_name = group_path = ''
504 504 repo_name_full = repo_name
505 505
506 506 value['repo_name'] = repo_name
507 507 value['repo_name_full'] = repo_name_full
508 508 value['group_path'] = group_path
509 509 value['group_name'] = group_name
510 510 return value
511 511
512 512 def validate_python(self, value, state):
513 513
514 514 repo_name = value.get('repo_name')
515 515 repo_name_full = value.get('repo_name_full')
516 516 group_path = value.get('group_path')
517 517 group_name = value.get('group_name')
518 518
519 519 if repo_name in [ADMIN_PREFIX, '']:
520 520 msg = M(self, 'invalid_repo_name', state, repo=repo_name)
521 521 raise formencode.Invalid(
522 522 msg, value, state, error_dict={'repo_name': msg})
523 523
524 524 rename = old_data.get('repo_name') != repo_name_full
525 525 create = not edit
526 526 if rename or create:
527 527
528 528 if group_path:
529 529 if Repository.get_by_repo_name(repo_name_full):
530 530 msg = M(self, 'repository_in_group_exists', state,
531 531 repo=repo_name, group=group_name)
532 532 raise formencode.Invalid(
533 533 msg, value, state, error_dict={'repo_name': msg})
534 534 if RepoGroup.get_by_group_name(repo_name_full):
535 535 msg = M(self, 'group_in_group_exists', state,
536 536 repo=repo_name, group=group_name)
537 537 raise formencode.Invalid(
538 538 msg, value, state, error_dict={'repo_name': msg})
539 539 else:
540 540 if RepoGroup.get_by_group_name(repo_name_full):
541 541 msg = M(self, 'group_exists', state, repo=repo_name)
542 542 raise formencode.Invalid(
543 543 msg, value, state, error_dict={'repo_name': msg})
544 544
545 545 if Repository.get_by_repo_name(repo_name_full):
546 546 msg = M(
547 547 self, 'repository_exists', state, repo=repo_name)
548 548 raise formencode.Invalid(
549 549 msg, value, state, error_dict={'repo_name': msg})
550 550 return value
551 551 return _validator
552 552
553 553
554 554 def ValidForkName(*args, **kwargs):
555 555 return ValidRepoName(*args, **kwargs)
556 556
557 557
558 558 def SlugifyName():
559 559 class _validator(formencode.validators.FancyValidator):
560 560
561 561 def _to_python(self, value, state):
562 562 return repo_name_slug(value)
563 563
564 564 def validate_python(self, value, state):
565 565 pass
566 566
567 567 return _validator
568 568
569 569
570 570 def ValidCloneUri():
571 571 class InvalidCloneUrl(Exception):
572 572 allowed_prefixes = ()
573 573
574 574 def url_handler(repo_type, url):
575 575 config = make_db_config(clear_session=False)
576 576 if repo_type == 'hg':
577 577 allowed_prefixes = ('http', 'svn+http', 'git+http')
578 578
579 579 if 'http' in url[:4]:
580 580 # initially check if it's at least the proper URL
581 581 # or does it pass basic auth
582 582 MercurialRepository.check_url(url, config)
583 583 elif 'svn+http' in url[:8]: # svn->hg import
584 584 SubversionRepository.check_url(url, config)
585 585 elif 'git+http' in url[:8]: # git->hg import
586 586 raise NotImplementedError()
587 587 else:
588 588 exc = InvalidCloneUrl('Clone from URI %s not allowed. '
589 589 'Allowed url must start with one of %s'
590 590 % (url, ','.join(allowed_prefixes)))
591 591 exc.allowed_prefixes = allowed_prefixes
592 592 raise exc
593 593
594 594 elif repo_type == 'git':
595 595 allowed_prefixes = ('http', 'svn+http', 'hg+http')
596 596 if 'http' in url[:4]:
597 597 # initially check if it's at least the proper URL
598 598 # or does it pass basic auth
599 599 GitRepository.check_url(url, config)
600 600 elif 'svn+http' in url[:8]: # svn->git import
601 601 raise NotImplementedError()
602 602 elif 'hg+http' in url[:8]: # hg->git import
603 603 raise NotImplementedError()
604 604 else:
605 605 exc = InvalidCloneUrl('Clone from URI %s not allowed. '
606 606 'Allowed url must start with one of %s'
607 607 % (url, ','.join(allowed_prefixes)))
608 608 exc.allowed_prefixes = allowed_prefixes
609 609 raise exc
610 610
611 611 class _validator(formencode.validators.FancyValidator):
612 612 messages = {
613 613 'clone_uri': _(u'invalid clone url for %(rtype)s repository'),
614 614 'invalid_clone_uri': _(
615 615 u'Invalid clone url, provide a valid clone '
616 616 u'url starting with one of %(allowed_prefixes)s')
617 617 }
618 618
619 619 def validate_python(self, value, state):
620 620 repo_type = value.get('repo_type')
621 621 url = value.get('clone_uri')
622 622
623 623 if url:
624 624 try:
625 625 url_handler(repo_type, url)
626 626 except InvalidCloneUrl as e:
627 627 log.warning(e)
628 628 msg = M(self, 'invalid_clone_uri', rtype=repo_type,
629 629 allowed_prefixes=','.join(e.allowed_prefixes))
630 630 raise formencode.Invalid(msg, value, state,
631 631 error_dict={'clone_uri': msg})
632 632 except Exception:
633 633 log.exception('Url validation failed')
634 634 msg = M(self, 'clone_uri', rtype=repo_type)
635 635 raise formencode.Invalid(msg, value, state,
636 636 error_dict={'clone_uri': msg})
637 637 return _validator
638 638
639 639
640 640 def ValidForkType(old_data={}):
641 641 class _validator(formencode.validators.FancyValidator):
642 642 messages = {
643 643 'invalid_fork_type': _(u'Fork have to be the same type as parent')
644 644 }
645 645
646 646 def validate_python(self, value, state):
647 647 if old_data['repo_type'] != value:
648 648 msg = M(self, 'invalid_fork_type', state)
649 649 raise formencode.Invalid(
650 650 msg, value, state, error_dict={'repo_type': msg}
651 651 )
652 652 return _validator
653 653
654 654
655 655 def CanWriteGroup(old_data=None):
656 656 class _validator(formencode.validators.FancyValidator):
657 657 messages = {
658 658 'permission_denied': _(
659 659 u"You do not have the permission "
660 660 u"to create repositories in this group."),
661 661 'permission_denied_root': _(
662 662 u"You do not have the permission to store repositories in "
663 663 u"the root location.")
664 664 }
665 665
666 666 def _to_python(self, value, state):
667 667 # root location
668 668 if value in [-1, "-1"]:
669 669 return None
670 670 return value
671 671
672 672 def validate_python(self, value, state):
673 673 gr = RepoGroup.get(value)
674 674 gr_name = gr.group_name if gr else None # None means ROOT location
675 675 # create repositories with write permission on group is set to true
676 676 create_on_write = HasPermissionAny(
677 677 'hg.create.write_on_repogroup.true')()
678 678 group_admin = HasRepoGroupPermissionAny('group.admin')(
679 679 gr_name, 'can write into group validator')
680 680 group_write = HasRepoGroupPermissionAny('group.write')(
681 681 gr_name, 'can write into group validator')
682 682 forbidden = not (group_admin or (group_write and create_on_write))
683 683 can_create_repos = HasPermissionAny(
684 684 'hg.admin', 'hg.create.repository')
685 685 gid = (old_data['repo_group'].get('group_id')
686 686 if (old_data and 'repo_group' in old_data) else None)
687 687 value_changed = gid != safe_int(value)
688 688 new = not old_data
689 689 # do check if we changed the value, there's a case that someone got
690 690 # revoked write permissions to a repository, he still created, we
691 691 # don't need to check permission if he didn't change the value of
692 692 # groups in form box
693 693 if value_changed or new:
694 694 # parent group need to be existing
695 695 if gr and forbidden:
696 696 msg = M(self, 'permission_denied', state)
697 697 raise formencode.Invalid(
698 698 msg, value, state, error_dict={'repo_type': msg}
699 699 )
700 700 # check if we can write to root location !
701 701 elif gr is None and not can_create_repos():
702 702 msg = M(self, 'permission_denied_root', state)
703 703 raise formencode.Invalid(
704 704 msg, value, state, error_dict={'repo_type': msg}
705 705 )
706 706
707 707 return _validator
708 708
709 709
710 710 def ValidPerms(type_='repo'):
711 711 if type_ == 'repo_group':
712 712 EMPTY_PERM = 'group.none'
713 713 elif type_ == 'repo':
714 714 EMPTY_PERM = 'repository.none'
715 715 elif type_ == 'user_group':
716 716 EMPTY_PERM = 'usergroup.none'
717 717
718 718 class _validator(formencode.validators.FancyValidator):
719 719 messages = {
720 720 'perm_new_member_name':
721 721 _(u'This username or user group name is not valid')
722 722 }
723 723
724 724 def _to_python(self, value, state):
725 725 perm_updates = OrderedSet()
726 726 perm_additions = OrderedSet()
727 727 perm_deletions = OrderedSet()
728 728 # build a list of permission to update/delete and new permission
729 729
730 730 # Read the perm_new_member/perm_del_member attributes and group
731 731 # them by they IDs
732 732 new_perms_group = defaultdict(dict)
733 733 del_perms_group = defaultdict(dict)
734 734 for k, v in value.copy().iteritems():
735 735 if k.startswith('perm_del_member'):
736 736 # delete from org storage so we don't process that later
737 737 del value[k]
738 738 # part is `id`, `type`
739 739 _type, part = k.split('perm_del_member_')
740 740 args = part.split('_')
741 741 if len(args) == 2:
742 742 _key, pos = args
743 743 del_perms_group[pos][_key] = v
744 744 if k.startswith('perm_new_member'):
745 745 # delete from org storage so we don't process that later
746 746 del value[k]
747 747 # part is `id`, `type`, `perm`
748 748 _type, part = k.split('perm_new_member_')
749 749 args = part.split('_')
750 750 if len(args) == 2:
751 751 _key, pos = args
752 752 new_perms_group[pos][_key] = v
753 753
754 754 # store the deletes
755 755 for k in sorted(del_perms_group.keys()):
756 756 perm_dict = del_perms_group[k]
757 757 del_member = perm_dict.get('id')
758 758 del_type = perm_dict.get('type')
759 759 if del_member and del_type:
760 760 perm_deletions.add((del_member, None, del_type))
761 761
762 762 # store additions in order of how they were added in web form
763 763 for k in sorted(new_perms_group.keys()):
764 764 perm_dict = new_perms_group[k]
765 765 new_member = perm_dict.get('id')
766 766 new_type = perm_dict.get('type')
767 767 new_perm = perm_dict.get('perm')
768 768 if new_member and new_perm and new_type:
769 769 perm_additions.add((new_member, new_perm, new_type))
770 770
771 771 # get updates of permissions
772 772 # (read the existing radio button states)
773 773 for k, update_value in value.iteritems():
774 774 if k.startswith('u_perm_') or k.startswith('g_perm_'):
775 775 member = k[7:]
776 776 update_type = {'u': 'user',
777 777 'g': 'users_group'}[k[0]]
778 778 if member == User.DEFAULT_USER:
779 779 if str2bool(value.get('repo_private')):
780 780 # set none for default when updating to
781 781 # private repo protects agains form manipulation
782 782 update_value = EMPTY_PERM
783 783 perm_updates.add((member, update_value, update_type))
784 784 # check the deletes
785 785
786 786 value['perm_additions'] = list(perm_additions)
787 787 value['perm_updates'] = list(perm_updates)
788 788 value['perm_deletions'] = list(perm_deletions)
789 789
790 790 # validate users they exist and they are active !
791 791 for member_id, _perm, member_type in perm_additions:
792 792 try:
793 793 if member_type == 'user':
794 794 self.user_db = User.query()\
795 795 .filter(User.active == true())\
796 796 .filter(User.user_id == member_id).one()
797 797 if member_type == 'users_group':
798 798 self.user_db = UserGroup.query()\
799 799 .filter(UserGroup.users_group_active == true())\
800 800 .filter(UserGroup.users_group_id == member_id)\
801 801 .one()
802 802
803 803 except Exception:
804 804 log.exception('Updated permission failed: org_exc:')
805 805 msg = M(self, 'perm_new_member_type', state)
806 806 raise formencode.Invalid(
807 807 msg, value, state, error_dict={
808 808 'perm_new_member_name': msg}
809 809 )
810 810 return value
811 811 return _validator
812 812
813 813
814 814 def ValidSettings():
815 815 class _validator(formencode.validators.FancyValidator):
816 816 def _to_python(self, value, state):
817 817 # settings form for users that are not admin
818 818 # can't edit certain parameters, it's extra backup if they mangle
819 819 # with forms
820 820
821 821 forbidden_params = [
822 822 'user', 'repo_type', 'repo_enable_locking',
823 823 'repo_enable_downloads', 'repo_enable_statistics'
824 824 ]
825 825
826 826 for param in forbidden_params:
827 827 if param in value:
828 828 del value[param]
829 829 return value
830 830
831 831 def validate_python(self, value, state):
832 832 pass
833 833 return _validator
834 834
835 835
836 836 def ValidPath():
837 837 class _validator(formencode.validators.FancyValidator):
838 838 messages = {
839 839 'invalid_path': _(u'This is not a valid path')
840 840 }
841 841
842 842 def validate_python(self, value, state):
843 843 if not os.path.isdir(value):
844 844 msg = M(self, 'invalid_path', state)
845 845 raise formencode.Invalid(
846 846 msg, value, state, error_dict={'paths_root_path': msg}
847 847 )
848 848 return _validator
849 849
850 850
851 851 def UniqSystemEmail(old_data={}):
852 852 class _validator(formencode.validators.FancyValidator):
853 853 messages = {
854 854 'email_taken': _(u'This e-mail address is already taken')
855 855 }
856 856
857 857 def _to_python(self, value, state):
858 858 return value.lower()
859 859
860 860 def validate_python(self, value, state):
861 861 if (old_data.get('email') or '').lower() != value:
862 862 user = User.get_by_email(value, case_insensitive=True)
863 863 if user:
864 864 msg = M(self, 'email_taken', state)
865 865 raise formencode.Invalid(
866 866 msg, value, state, error_dict={'email': msg}
867 867 )
868 868 return _validator
869 869
870 870
871 871 def ValidSystemEmail():
872 872 class _validator(formencode.validators.FancyValidator):
873 873 messages = {
874 874 'non_existing_email': _(u'e-mail "%(email)s" does not exist.')
875 875 }
876 876
877 877 def _to_python(self, value, state):
878 878 return value.lower()
879 879
880 880 def validate_python(self, value, state):
881 881 user = User.get_by_email(value, case_insensitive=True)
882 882 if user is None:
883 883 msg = M(self, 'non_existing_email', state, email=value)
884 884 raise formencode.Invalid(
885 885 msg, value, state, error_dict={'email': msg}
886 886 )
887 887
888 888 return _validator
889 889
890 890
891 891 def NotReviewedRevisions(repo_id):
892 892 class _validator(formencode.validators.FancyValidator):
893 893 messages = {
894 894 'rev_already_reviewed':
895 895 _(u'Revisions %(revs)s are already part of pull request '
896 896 u'or have set status'),
897 897 }
898 898
899 899 def validate_python(self, value, state):
900 900 # check revisions if they are not reviewed, or a part of another
901 901 # pull request
902 902 statuses = ChangesetStatus.query()\
903 903 .filter(ChangesetStatus.revision.in_(value))\
904 904 .filter(ChangesetStatus.repo_id == repo_id)\
905 905 .all()
906 906
907 907 errors = []
908 908 for status in statuses:
909 909 if status.pull_request_id:
910 910 errors.append(['pull_req', status.revision[:12]])
911 911 elif status.status:
912 912 errors.append(['status', status.revision[:12]])
913 913
914 914 if errors:
915 915 revs = ','.join([x[1] for x in errors])
916 916 msg = M(self, 'rev_already_reviewed', state, revs=revs)
917 917 raise formencode.Invalid(
918 918 msg, value, state, error_dict={'revisions': revs})
919 919
920 920 return _validator
921 921
922 922
923 923 def ValidIp():
924 924 class _validator(CIDR):
925 925 messages = {
926 926 'badFormat': _(u'Please enter a valid IPv4 or IpV6 address'),
927 927 'illegalBits': _(
928 928 u'The network size (bits) must be within the range '
929 929 u'of 0-32 (not %(bits)r)'),
930 930 }
931 931
932 932 # we ovveride the default to_python() call
933 933 def to_python(self, value, state):
934 934 v = super(_validator, self).to_python(value, state)
935 935 v = v.strip()
936 936 net = ipaddress.ip_network(address=v, strict=False)
937 937 return str(net)
938 938
939 939 def validate_python(self, value, state):
940 940 try:
941 941 addr = value.strip()
942 942 # this raises an ValueError if address is not IpV4 or IpV6
943 943 ipaddress.ip_network(addr, strict=False)
944 944 except ValueError:
945 945 raise formencode.Invalid(self.message('badFormat', state),
946 946 value, state)
947 947
948 948 return _validator
949 949
950 950
951 951 def FieldKey():
952 952 class _validator(formencode.validators.FancyValidator):
953 953 messages = {
954 954 'badFormat': _(
955 955 u'Key name can only consist of letters, '
956 956 u'underscore, dash or numbers'),
957 957 }
958 958
959 959 def validate_python(self, value, state):
960 960 if not re.match('[a-zA-Z0-9_-]+$', value):
961 961 raise formencode.Invalid(self.message('badFormat', state),
962 962 value, state)
963 963 return _validator
964 964
965 965
966 966 def BasePath():
967 967 class _validator(formencode.validators.FancyValidator):
968 968 messages = {
969 969 'badPath': _(u'Filename cannot be inside a directory'),
970 970 }
971 971
972 972 def _to_python(self, value, state):
973 973 return value
974 974
975 975 def validate_python(self, value, state):
976 976 if value != os.path.basename(value):
977 977 raise formencode.Invalid(self.message('badPath', state),
978 978 value, state)
979 979 return _validator
980 980
981 981
982 982 def ValidAuthPlugins():
983 983 class _validator(formencode.validators.FancyValidator):
984 984 messages = {
985 985 'import_duplicate': _(
986 986 u'Plugins %(loaded)s and %(next_to_load)s '
987 987 u'both export the same name'),
988 988 }
989 989
990 990 def _to_python(self, value, state):
991 991 # filter empty values
992 992 return filter(lambda s: s not in [None, ''], value)
993 993
994 994 def validate_python(self, value, state):
995 995 from rhodecode.authentication.base import loadplugin
996 996 module_list = value
997 997 unique_names = {}
998 try:
998 999 for module in module_list:
1000 if module.startswith(legacy_plugin_prefix):
1001 continue
999 1002 plugin = loadplugin(module)
1000 if plugin is None:
1001 raise formencode.Invalid(
1002 _("Can't find plugin with id '{}'".format(module)),
1003 value, state)
1004 1003 plugin_name = plugin.name
1005 1004 if plugin_name in unique_names:
1006 1005 msg = M(self, 'import_duplicate', state,
1007 1006 loaded=unique_names[plugin_name],
1008 1007 next_to_load=plugin_name)
1009 1008 raise formencode.Invalid(msg, value, state)
1010 1009 unique_names[plugin_name] = plugin
1010 except (KeyError, AttributeError, TypeError) as e:
1011 raise formencode.Invalid(str(e), value, state)
1011 1012
1012 1013 return _validator
1013 1014
1014 1015
1015 1016 def UniqGistId():
1016 1017 class _validator(formencode.validators.FancyValidator):
1017 1018 messages = {
1018 1019 'gistid_taken': _(u'This gistid is already in use')
1019 1020 }
1020 1021
1021 1022 def _to_python(self, value, state):
1022 1023 return repo_name_slug(value.lower())
1023 1024
1024 1025 def validate_python(self, value, state):
1025 1026 existing = Gist.get_by_access_id(value)
1026 1027 if existing:
1027 1028 msg = M(self, 'gistid_taken', state)
1028 1029 raise formencode.Invalid(
1029 1030 msg, value, state, error_dict={'gistid': msg}
1030 1031 )
1031 1032
1032 1033 return _validator
1033 1034
1034 1035
1035 1036 def ValidPattern():
1036 1037
1037 1038 class _Validator(formencode.validators.FancyValidator):
1038 1039
1039 1040 def _to_python(self, value, state):
1040 1041 patterns = []
1041 1042
1042 1043 prefix = 'new_pattern'
1043 1044 for name, v in value.iteritems():
1044 1045 pattern_name = '_'.join((prefix, 'pattern'))
1045 1046 if name.startswith(pattern_name):
1046 1047 new_item_id = name[len(pattern_name)+1:]
1047 1048
1048 1049 def _field(name):
1049 1050 return '%s_%s_%s' % (prefix, name, new_item_id)
1050 1051
1051 1052 values = {
1052 1053 'issuetracker_pat': value.get(_field('pattern')),
1053 1054 'issuetracker_pat': value.get(_field('pattern')),
1054 1055 'issuetracker_url': value.get(_field('url')),
1055 1056 'issuetracker_pref': value.get(_field('prefix')),
1056 1057 'issuetracker_desc': value.get(_field('description'))
1057 1058 }
1058 1059 new_uid = md5(values['issuetracker_pat'])
1059 1060
1060 1061 has_required_fields = (
1061 1062 values['issuetracker_pat']
1062 1063 and values['issuetracker_url'])
1063 1064
1064 1065 if has_required_fields:
1065 1066 settings = [
1066 1067 ('_'.join((key, new_uid)), values[key], 'unicode')
1067 1068 for key in values]
1068 1069 patterns.append(settings)
1069 1070
1070 1071 value['patterns'] = patterns
1071 1072 delete_patterns = value.get('uid') or []
1072 1073 if not isinstance(delete_patterns, (list, tuple)):
1073 1074 delete_patterns = [delete_patterns]
1074 1075 value['delete_patterns'] = delete_patterns
1075 1076 return value
1076 1077 return _Validator
General Comments 0
You need to be logged in to leave comments. Login now