def form_valid(self, form):
if self.model.objects.all().count() > settings.MAX_REGISTERS:
date_now = datetime.now()
date_clean = datetime(date_now.year, date_now.month, date_now.day,
date_now.hour) + timedelta(hours=1)
date_diff = date_clean - date_now
errors = form._errors.setdefault("location", ErrorList())
errors.append(
_("Ha llegado al limite de registros. Quedan {} minutos para reestablecer la base de datos"
.format(date_diff.seconds / 60)))
return super(PhoneCreate, self).form_invalid(form)
if self._pk is not None:
contact = get_object_or_404(Contact, pk=self._pk)
form.instance.contact = contact
return super(PhoneCreate, self).form_valid(form)
def clean(self, value):
cleaned_data = []
errors = {}
for i, child in enumerate(value): # child is a BoundBlock instance
try:
cleaned_data.append(
(child.block.name, child.block.clean(child.value)))
except ValidationError as e:
errors[i] = ErrorList([e])
if errors:
# The message here is arbitrary - outputting error messages is delegated to the child blocks,
# which only involves the 'params' list
raise StreamBlockValidationError(block_errors=errors)
return StreamValue(self, cleaned_data)
def form_valid(self, form):
challenge = self.request.challenge
form.instance.user = self.request.user
form.instance.challenge = challenge
try:
redirect = super().form_valid(form)
if challenge.require_participant_review:
# Note, sending an email here rather than in signals as
# the function requires the request.
send_participation_request_notification_email(
self.request, self.object)
return redirect
except ValidationError as e:
form._errors[NON_FIELD_ERRORS] = ErrorList(e.messages)
return super().form_invalid(form)
def import_tasks(request):
""" View in the admin """
if request.method == 'POST':
form = ImportForm(request.POST, request.FILES)
if form.is_valid():
try:
Task.import_Tasks(form.files['file'], request.user, form.cleaned_data['is_template'])
messages.success(request, "The import was successful.")
return HttpResponseRedirect(reverse('admin:tasks_task_changelist'))
except Exception as e:
from django.forms.utils import ErrorList
msg = "An Error occured. The import file was probably malformed: %s" % str(e)
form._errors["file"] = ErrorList([msg])
else:
form = ImportForm()
return render(request, 'admin/tasks/task/import.html', {'form': form, 'title':"Import Task" })
def clean(self):
cleaned_data = super(AddLdapGroupsForm, self).clean()
groupname_pattern = cleaned_data.get("groupname_pattern")
dn = cleaned_data.get("dn")
try:
if dn:
validate_dn(groupname_pattern)
else:
validate_groupname(groupname_pattern)
except ValidationError as e:
errors = self._errors.setdefault('groupname_pattern', ErrorList())
errors.append(e.message)
raise forms.ValidationError(e.message)
return cleaned_data
def clean(self, value):
ret = super(MapBlock, self).clean(value)
if not any([
bool(value.get(val))
for val in ('people', 'events', 'projects', 'groups')
]):
errors = dict([
(val,
ErrorList(
[_('At least one type of Map object must be chosen!')]))
for val in ('people', 'events', 'projects', 'groups')
])
raise ValidationError(
_('At least one type of Map object must be chosen!'),
params=errors)
return ret
def form_valid(self, form):
main_key = UserProfile.objects.get_auth_key(self.request.user)
auth_key = form.cleaned_data['authenticate_key']
totp = pyotp.TOTP(main_key)
is_valid = totp.verify(auth_key)
if is_valid:
self.request.session['is_authenticated'] = True
return super(AuthenticateUserView, self).form_valid(form)
form_errors = form._errors.setdefault('authenticate_key', ErrorList())
form_errors.append("Invalid autnentication code")
return super(AuthenticateUserView, self).form_invalid(form)
def update_attestations(request):
""" View in the admin """
if request.method == 'POST':
form = ImportForm(request.POST, request.FILES)
if form.is_valid():
try:
Attestation.update_Attestations(request, form.files['file'])
return render(request, 'admin/attestation/update.html', {
'form': form,
'title': "Update Attestations"
})
except Exception, e:
from django.forms.utils import ErrorList
msg = "An Error occured. The import file was propably malformed.: %s" % str(
e)
form._errors["file"] = ErrorList([msg])
def perform_action(self):
"""
Upload the files
"""
errors = ErrorList()
for file in self.files.getlist('file_field'):
try:
ProjectFiles().fput(self.file_dir, file)
except FileExistsError:
errors.append(
format_html('Item named <i>{}</i> already exists',
file.name))
except OSError:
errors.append(
format_html('Unable to upload <i>{}</i>', file.name))
return 'Your files have been uploaded', errors
def perform_action(self):
"""
Create the folder
"""
errors = ErrorList()
name = self.cleaned_data['folder_name']
file_path = os.path.join(self.file_dir, name)
try:
ProjectFiles().mkdir(file_path)
except FileExistsError:
errors.append(
format_html('Item named <i>{}</i> already exists', name))
except OSError:
errors.append(format_html('Unable to create <i>{}</i>', name))
return 'Your folder has been created', errors
def is_valid(self, *args, **kwargs):
is_valid = super().is_valid(*args, **kwargs)
DEFAULT_FILTERS = [
"exclude_fields", "fields", "limit", "minimal", "offset", "page_size", "ordering"
]
for field in self.data.keys():
if field in DEFAULT_FILTERS:
continue
if field not in self.filters:
errors = self.form._errors.get("errors", ErrorList())
errors.extend(["Invalid Filter: '{field}'".format(field=field)])
self.form._errors["errors"] = errors
is_valid = False
return is_valid
def validate(self, value, errors=None):
'''Performs validation of the StreamBlock.'''
if errors is None:
errors = {}
non_block_errors = ErrorList()
if self.meta.min_num is not None and self.meta.min_num > len(value):
non_block_errors.append(
ValidationError(
_('The minimum number of items is %d') %
self.meta.min_num))
elif self.required and len(value) == 0:
non_block_errors.append(
ValidationError(_('This field is required.')))
if self.meta.max_num is not None and self.meta.max_num < len(value):
non_block_errors.append(
ValidationError(
_('The maximum number of items is %d') %
self.meta.max_num))
if self.meta.block_counts:
block_counts = collections.defaultdict(int)
for item in value:
block_counts[item.block_type] += 1
for block_name, min_max in self.meta.block_counts.items():
block = self.child_blocks[block_name]
max_num = min_max.get('max_num', None)
min_num = min_max.get('min_num', None)
block_count = block_counts[block_name]
if min_num is not None and min_num > block_count:
non_block_errors.append(
ValidationError('{}: {}'.format(
block.label,
_('The minimum number of items is %d') % min_num)))
if max_num is not None and max_num < block_count:
non_block_errors.append(
ValidationError('{}: {}'.format(
block.label,
_('The maximum number of items is %d') % max_num)))
if errors or non_block_errors:
# The message here is arbitrary - outputting error messages is delegated to the child blocks,
# which only involves the 'params' list
raise StreamBlockValidationError(block_errors=errors,
non_block_errors=non_block_errors)
def login(request):
next_redirect = request.GET.get('next')
if request.user.is_authenticated():
if not next_redirect:
return HttpResponseRedirect(
reverse('profile', kwargs={'user_id': request.user.id}))
else:
return HttpResponseRedirect(next_redirect)
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = LoginForm(request.POST)
# check whether it's valid:
if form.is_valid():
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
if '@' in username and '.' in username:
uqs = User.objects.filter(email=username)
username = uqs.first().username
user = djauth.authenticate(username=username, password=password)
if user is None:
errors = form._errors.setdefault(NON_FIELD_ERRORS, ErrorList())
errors.append(u"Could not authenticate you.")
else:
djauth.login(request, user)
next_redirect = request.POST.get('next')
if not next_redirect:
return HttpResponseRedirect(
reverse('profile', kwargs={'user_id':
request.user.id}))
else:
return HttpResponseRedirect(next_redirect)
# if a GET (or any other method) we'll create a blank form
else:
form = LoginForm()
return render(request, 'auth/login.html', {
'form': form,
'next': next_redirect
})
def clean(self, value):
clean_data = {}
errors = ErrorList()
if not value or isinstance(value, dict):
if not value or not [
v for v in value.values() if v not in self.empty_values
]:
if self.required:
raise ValidationError(self.error_messages['required'])
else:
return {}
else:
raise ValidationError(self.error_messages['invalid'])
# sort out required => at least one element must be in there
for key, val in value.items():
# ignore empties. Can they even come up here?
if key in self.empty_values and val in self.empty_values:
continue
try:
val = self.contained_field.clean(val)
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
try:
self._validate_key(key)
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
clean_data[key] = val
if self.contained_field.required:
self.contained_field.required = False
if errors:
raise ValidationError(errors)
self.validate(clean_data)
self.run_validators(clean_data)
return clean_data
def clean(self, value):
cleaned = super(ConferenceRegistrationForm, self).clean(value)
question = cleaned.get('govdelivery_question_id')
answer = cleaned.get('govdelivery_answer_id')
# Question and answer values must both exist or neither exist
if (question and not answer) or (answer and not question):
raise ValidationError(
'Validation error in Conference Registration Form: '
'GovDelivery question ID requires answer ID, and vice versa.',
params={
'govdelivery_answer_id':
ErrorList(
['Required if a GovDelivery question ID is entered.'])
})
return cleaned
def edit_profile(request):
if request.method == "POST":
form = EditProfileForm(request.POST)
if form.is_valid():
if not request.user.check_password(form.cleaned_data['password']):
form._errors['password'] = ErrorList(
[u'The password you entered is incorrect.'])
else:
request.user.email = form.cleaned_data['email']
if form.cleaned_data['password1']:
request.user.set_password(form.cleaned_data['password1'])
request.user.save()
return HttpResponseRedirect('/settings/')
else:
form = EditProfileForm()
form.fields['email'].initial = request.user.email
return TemplateResponse(request, "edit_profile_form.html", {'form': form})
def form_valid(self, *args, **kwargs):
form = kwargs['form']
new_name = form.cleaned_data['new_name']
pool = CondorPool.objects.get(id=kwargs['pool_id'])
assert pool.user == self.request.user
existing_pools = CondorPool.objects.filter(user=self.request.user).filter(name=new_name)
if existing_pools.count()>0:
form._errors[NON_FIELD_ERRORS] = ErrorList(['A pool with this name already exists'])
return self.form_invalid(self, *args, **kwargs)
pool.name = new_name
pool.save()
self.success_url = reverse_lazy('pool_details', kwargs={'pool_id': kwargs['pool_id']})
return super(PoolRenameView, self).form_valid(*args, **kwargs)
def form_valid(self, form):
x = PHDBachelorPOS.objects.filter(
((Q(state="AdvisorPending") | Q(state="DGSPending")) &
(Q(owner=self.request.user))))
y = PHDMasterPOS.objects.filter(
((Q(state="AdvisorPending") | Q(state="DGSPending")) &
(Q(owner=self.request.user))))
if (len(x) + len(y) > 0):
form._errors[forms.forms.NON_FIELD_ERRORS] = ErrorList([
u'Students may only resubmit a form if they do not have a current form under review.'
])
return self.form_invalid(form)
user = self.request.user
form.instance.owner = user
form.instance.state = "AdvisorPending"
return super(PHDMSUpdateView, self).form_valid(form)
def clean(self):
super(ProductDataForm, self).clean()
if self.instance:
redirect_to = self.data.get("redirect_to", "")
if redirect_to != "":
lfs.core.utils.set_redirect_for(
self.instance.get_absolute_url(), redirect_to)
else:
lfs.core.utils.remove_redirect_for(
self.instance.get_absolute_url())
if self.data.get("active_base_price", 0):
if self.data.get("base_price_amount", "") == "":
self.errors["base_price_amount"] = ErrorList(
[_(u"This field is required.")])
return self.cleaned_data
def form_valid(self, form):
opts = {
'use_https': self.request.is_secure(),
'token_generator': self.token_generator,
'from_email': self.from_email,
'email_template_name': self.email_template_name,
'subject_template_name': self.subject_template_name,
'request': self.request,
'html_email_template_name': self.html_email_template_name,
'extra_email_context': self.extra_email_context,
}
is_saved = form.save(**opts)
if is_saved == 0:
form._errors[forms.forms.NON_FIELD_ERRORS] = ErrorList(
[u'Email does not exist.'])
return self.form_invalid(form)
return super().form_valid(form)
def clean(self):
# Run subject validation if it exists
org = self.cleaned_data.get('organization')
# If there is no org simply return data.
# Error will be caught downstream
if not org:
return self.cleaned_data
validations = org.subjectvalidation_set.all()
if validations:
for check in validations:
sid = self.cleaned_data.get('organization_subject_id')
valid = re.match(check.regex, sid)
if not valid:
self._errors["subject"] = ErrorList([
"Subject identifier does not meet validation rules for this organization."
])
return self.cleaned_data
def save(self):
"""
Attempts to move the node using the selected target and
position.
If an invalid move is attempted, the related error message will
be added to the form's non-field errors and the error will be
re-raised. Callers should attempt to catch ``InvalidNode`` to
redisplay the form with the error, should it occur.
"""
try:
self.node.move_to(self.cleaned_data['target'],
self.cleaned_data['position'])
return self.node
except InvalidMove as e:
self.errors[NON_FIELD_ERRORS] = ErrorList(e)
raise
def clean(self, value):
result = []
errors = []
for child_val in value:
try:
result.append(self.child_block.clean(child_val))
except ValidationError as e:
errors.append(ErrorList([e]))
else:
errors.append(None)
if any(errors):
# The message here is arbitrary - outputting error messages is delegated to the child blocks,
# which only involves the 'params' list
raise ValidationError('Validation error in ListBlock', params=errors)
return result
def form_valid_bridge(self, form, field, model, related_field,
error_message):
"""
call from form_valid.
@form: it is form of form_valid (type: form)
@field: name of the form field referring to the brigde (type: string)
@model: form's model (type class)
@related_field: name of the related_name of the brigde (type: string)
@error_message: list of message errors (type list)
one item, example:
["The selected entry is not available anymore, please, try again!", ]
"""
# get instance of selected external object
external = form.cleaned_data[field]
object_edit = model.objects.get(pk=form.instance.pk)
if object_edit.external == external:
answer = super(GenUpdateBridge, self).form_valid(form)
else:
related_object = get_external_model(model).objects.filter(
**{
"pk": external.pk,
"{}__isnull".format(related_field): False
}).exclude(**{
"{}".format(related_field): form.instance,
}).first()
if not related_object:
# form valid
try:
with transaction.atomic():
result = super(GenUpdateBridge, self).form_valid(form)
field = object_edit.external
setattr(field, related_field, None)
field.save()
setattr(external, related_field, form.instance)
external.save()
# Return success url
answer = HttpResponseRedirect(self.get_success_url())
except CodenerixException:
answer = super(GenUpdateBridge, self).form_invalid(form)
else:
errors = form._errors.setdefault(field, ErrorList())
errors.append(error_message[0])
answer = super(GenUpdateBridge, self).form_invalid(form)
# Return result
return answer
def clean(self, value):
"""
Validates every value in the given list. A value is validated against
the corresponding Field in self.fields.
Only allows for exactly 1 valid value to be submitted, this is what
gets returned by compress.
example to use directy (instead of using FileOrURLField):
MutuallyExclusiveValueField(
fields=(forms.TypedChoiceField(choices=[(1,1), (2,2)], coerce=int),
forms.IntegerField()))
"""
clean_data = []
errors = ErrorList()
if not value or isinstance(value, (list, tuple)):
if not value or not [
v for v in value if v not in self.empty_values
]:
if self.required:
raise ValidationError(self.error_messages['required'],
code='required')
else:
return self.compress([])
else:
raise ValidationError(self.error_messages['invalid'],
code='invalid')
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
try:
clean_data.append(field.clean(field_value))
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
if errors:
raise ValidationError(errors)
out = self.compress(clean_data)
self.validate(out)
self.run_validators(out)
return out
def login_view(request):
"""
Standard Django login, with additions:
Lowercase the login email (username)
Check user has accepted ToS, if any.
"""
if request.method == "POST":
redirect_to = request.POST.get('next', request.GET.get('next', False))
if not redirect_to:
redirect_to = reverse('seed:home')
form = LoginForm(request.POST)
if form.is_valid():
new_user = authenticate(
username=form.cleaned_data['email'].lower(),
password=form.cleaned_data['password'])
if new_user is not None and new_user.is_active:
# TODO: the ToS haven't worked for awhile, reneable?
# determine if user has accepted ToS, if one exists
# try:
# user_accepted_tos = has_user_agreed_latest_tos(new_user)
# except NoActiveTermsOfService:
# there's no active ToS, skip interstitial
# user_accepted_tos = True
#
# if user_accepted_tos:
login(request, new_user)
return HttpResponseRedirect(redirect_to)
# else:
# store login info for django-tos to handle
# request.session['tos_user'] = new_user.pk
# request.session['tos_backend'] = new_user.backend
# context = RequestContext(request)
# context.update({
# 'next': redirect_to,
# 'tos': TermsOfService.objects.get_current_tos()
# })
# return render(request, 'tos/tos_check.html', context)
else:
errors = ErrorList()
errors = form._errors.setdefault(NON_FIELD_ERRORS, errors)
errors.append('Username and/or password were invalid.')
else:
form = LoginForm()
return render(request, 'landing/login.html', locals())
def form_valid(self, *args, **kwargs):
form = kwargs['form']
new_name = form.cleaned_data['new_name']
key = AWSAccessKey.objects.get(id=kwargs['key_id'])
assert key.user == self.request.user
existing_keys = AWSAccessKey.objects.filter(user=self.request.user).filter(name=new_name)
if existing_keys.count()>0:
form._errors[NON_FIELD_ERRORS] = ErrorList(['A key with this name already exists'])
return self.form_invalid(self, *args, **kwargs)
key.name = new_name
key.save()
self.success_url = reverse_lazy('my_account_keys',)
return super(KeysRenameView, self).form_valid(*args, **kwargs)
def clean(self, value):
result = [
] # build up a list of (name, value) tuples to be passed to the StructValue constructor
errors = {}
for name, val in value.items():
try:
result.append((name, self.child_blocks[name].clean(val)))
except ValidationError as e:
errors[name] = ErrorList([e])
if errors:
# The message here is arbitrary - StructBlock.render_form will suppress it
# and delegate the errors contained in the 'params' dict to the child blocks instead
raise ValidationError('Validation error in StructBlock',
params=errors)
return self._to_struct_value(result)
def get(self, request, *args, **kwargs):
''' Receives the request '''
ctx = {}
# if 'loggedin_user_credentials' in request.session:
# ctx = request.session['loggedin_user_credentials']
if not len(ctx):
Obj = Photographer.objects.get(user_ref=request.user)
ctx.update({
"username": request.user.username,
"firstname": Obj.firstname,
"lastname": Obj.lastname,
"businessname": request.user.businessname,
"instagram_link1": Obj.instagram_link1,
"primary_contact_number": request.user.primary_contact_number,
"countryval": request.user.country.id,
"city": request.user.city,
"email": request.user.email,
"website_link": Obj.website_link
})
# self.request.session['loggedin_user_credentials'] = ctx
CountryQuerySet = Country.objects.all().order_by('name')
editform = self.editform(ctx)
editform.errors['firstname'] = ""
editform.errors['city'] = ""
editform.errors['primary_contact_number'] = ""
editform.errors['businessname'] = ""
editform.errors['email'] = ErrorList()
editform.errors['username'] = ""
editform.errors['countryval'] = ""
ctx.update({'country': CountryQuerySet})
ctx.update({'editform': editform})
try:
PhotographerObj = Photographer.objects.get(user_ref=request.user)
if len(PhotographerObj.image.all()):
ctx.update({"show_profile": "1"})
except:
ctx.update({"show_profile": "0"})
return Response(ctx, template_name='my-profile.html')
def add_video(request, pk, suggest):
form = VideoForm()
search_form = SearchForm()
try:
hall = Hall.objects.get(pk=pk)
except NameError:
return redirect('home')
if (hall.user != request.user) and (suggest == 0):
raise Http404
if request.method == 'POST':
# Create
form = VideoForm(request.POST)
if form.is_valid():
if not suggest:
video = Video()
else:
video = SuggestionVideo()
video.hall = hall
video.url = form.cleaned_data['url']
parsed_url = urllib.parse.urlparse(video.url)
video_id = urllib.parse.parse_qs(parsed_url.query).get('v')
if video_id:
video.youtube_id = video_id[0]
response = requests.get(
f"https://www.googleapis.com/youtube/v3/videos?part=snippet&id={ video_id[0] }&key={YOUTUBE_API_KEY}"
)
json = response.json()
title = json['items'][0]['snippet']['title']
video.title = title
thumb_url = json['items'][0]['snippet']['thumbnails'][
'medium']['url']
video.thumbnail_url = thumb_url
video.save()
return redirect('detail_hall', hall.id)
else:
errors = form._errors.setdefault('url', ErrorList())
errors.append('Needs to be valid Youtube URL')
return render(request, 'halls/add_video.html', {
'form': form,
'search_form': search_form,
'hall': hall,
'suggest': suggest
})
