1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
# Copyright 2009-2011 Canonical Ltd. This software is licensed under the
# GNU Affero General Public License version 3 (see the file LICENSE).
# pylint: disable-msg=E0211,E0213
__metaclass__ = type
__all__ = [
'can_be_nominated_for_series',
'non_duplicate_branch',
'valid_bug_number',
'valid_cve_sequence',
'validate_new_team_email',
'validate_new_person_email',
'valid_password',
'validate_date_interval',
]
from cgi import escape
from textwrap import dedent
from zope.app.form.interfaces import WidgetsError
from zope.component import getUtility
from lp import _
from lp.app.errors import NotFoundError
from lp.app.validators import LaunchpadValidationError
from lp.app.validators.cve import valid_cve
from lp.app.validators.email import valid_email
from lp.services.identity.interfaces.emailaddress import IEmailAddressSet
from lp.services.webapp import canonical_url
from lp.services.webapp.interfaces import ILaunchBag
from lp.services.webapp.menu import structured
def can_be_nominated_for_series(series):
"""Can the bug be nominated for these series?"""
current_bug = getUtility(ILaunchBag).bug
unnominatable_series = []
for s in series:
if not current_bug.canBeNominatedFor(s):
unnominatable_series.append(s.name.capitalize())
if unnominatable_series:
series_str = ", ".join(unnominatable_series)
raise LaunchpadValidationError(_(
"This bug has already been nominated for these "
"series: ${series}", mapping={'series': series_str}))
return True
def non_duplicate_branch(value):
"""Ensure that this branch hasn't already been linked to this bug."""
current_bug = getUtility(ILaunchBag).bug
if current_bug.hasBranch(value):
raise LaunchpadValidationError(_(dedent("""
This branch is already registered on this bug.
""")))
return True
def valid_bug_number(value):
from lp.bugs.interfaces.bug import IBugSet
bugset = getUtility(IBugSet)
try:
bugset.get(value)
except NotFoundError:
raise LaunchpadValidationError(_(
"Bug ${bugid} doesn't exist.", mapping={'bugid': value}))
return True
def valid_cve_sequence(value):
"""Check if the given value is a valid CVE otherwise raise an exception.
"""
if valid_cve(value):
return True
else:
raise LaunchpadValidationError(_(
"${cve} is not a valid CVE number", mapping={'cve': value}))
def _validate_email(email):
if not valid_email(email):
raise LaunchpadValidationError(_(
"${email} isn't a valid email address.",
mapping={'email': email}))
def _check_email_availability(email):
email_address = getUtility(IEmailAddressSet).getByEmail(email)
if email_address is not None:
# The email already exists; determine what has it.
if email_address.person is not None:
person = email_address.person
message = _('${email} is already registered in Launchpad and is '
'associated with <a href="${url}">${person}</a>.',
mapping={'email': escape(email),
'url': canonical_url(person),
'person': escape(person.displayname)})
elif email_address.account is not None:
account = email_address.account
message = _('${email} is already registered in Launchpad and is '
'associated with the ${account} account.',
mapping={'email': escape(email),
'account': escape(account.displayname)})
else:
message = _('${email} is already registered in Launchpad.',
mapping={'email': escape(email)})
raise LaunchpadValidationError(structured(message))
def validate_new_team_email(email):
"""Check that the given email is valid and not registered to
another launchpad account.
"""
_validate_email(email)
_check_email_availability(email)
return True
def validate_new_person_email(email):
"""Check that the given email is valid and not registered to
another launchpad account.
This validator is supposed to be used only when creating a new profile
using the /people/+newperson page, as the message will say clearly to the
user that the profile he's trying to create already exists, so there's no
need to create another one.
"""
from lp.services.webapp.publisher import canonical_url
from lp.registry.interfaces.person import IPersonSet
_validate_email(email)
owner = getUtility(IPersonSet).getByEmail(email)
if owner is not None:
message = _("The profile you're trying to create already exists: "
'<a href="${url}">${owner}</a>.',
mapping={'url': canonical_url(owner),
'owner': escape(owner.displayname)})
raise LaunchpadValidationError(structured(message))
return True
def valid_password(password):
"""Return True if the argument is a valid password.
A valid password contains only ASCII characters in range(32,127).
No ASCII control characters are allowed.
password that contains only valid ASCII characters
>>> valid_password(u"All ascii password with spaces.:\\&/")
True
password that contains some non-ASCII character (value > 127)
>>> valid_password(u"password with some non-ascii" + unichr(195))
False
password that contains ASCII control characters (0 >= value >= 31)
>>> valid_password(u"password with control chars" + chr(20))
False
empty password.
>>> valid_password(u"")
True
"""
assert isinstance(password, unicode)
valid_chars = [chr(x) for x in range(32, 127)]
invalid = set(password) - set(valid_chars)
if invalid:
return False
else:
return True
def validate_date_interval(start_date, end_date, error_msg=None):
"""Check if start_date precedes end_date.
>>> from datetime import datetime
>>> start = datetime(2006, 7, 18)
>>> end = datetime(2006, 8, 18)
>>> validate_date_interval(start, end)
>>> validate_date_interval(end, start)
Traceback (most recent call last):
...
WidgetsError: LaunchpadValidationError: This event can't start after it
ends.
>>> validate_date_interval(end, start, error_msg="A custom error msg")
Traceback (most recent call last):
...
WidgetsError: LaunchpadValidationError: A custom error msg
"""
if error_msg is None:
error_msg = _("This event can't start after it ends.")
if start_date >= end_date:
raise WidgetsError([LaunchpadValidationError(error_msg)])
|