def clean(self, value):
"""
Only the default language should be required.
"""
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 validators.EMPTY_VALUES]:
if self.required:
raise ValidationError(self.error_messages['required'])
else:
return self.compress([])
else:
raise ValidationError(self.error_messages['invalid'])
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
if i == 0 and self.required and field_value in validators.EMPTY_VALUES:
raise ValidationError(self.error_messages['required'])
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 plus lowercases the login email(username)"""
if request.method == "POST":
redirect_to = request.REQUEST.get('next', False)
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 and new_user.is_active:
login(request, new_user)
if redirect_to:
return HttpResponseRedirect(redirect_to)
else:
return HttpResponseRedirect(reverse("seed:home"))
else:
errors = ErrorList()
errors = form._errors.setdefault(NON_FIELD_ERRORS, errors)
errors.append('Username and/or password were invalid.')
else:
form = LoginForm()
return locals()
def clean(self, value):
# Get the value
# Totally replaced validation.
clean_data = []
errors = ErrorList()
# Only the visible field is required.
radio_value = value[0]
field_visible = [False] * len(self.fields)
field_visible[0] = True
field_visible[self.url_type_registry.index(radio_value) + 1] = True
# The validators only fire for visible fields.
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
if not field_visible[i]:
clean_data.append(None)
continue
if self.required and field_value in validators.EMPTY_VALUES:
raise ValidationError(self.error_messages['required'])
try:
clean_data.append(field.clean(field_value))
except ValidationError, e:
errors.extend(e.messages) # Collect all widget errors
def clean(self, value):
clean_data = []
errors = ErrorList()
if value in validators.EMPTY_VALUES and self.required:
raise ValidationError(self.error_messages['required'])
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
if field_value in validators.EMPTY_VALUES:
if (self.required and not self.optional):
raise ValidationError(self.error_messages['required'])
else:
field_value = field_value
try:
clean_data.append(field.clean(field_value))
except ValidationError, e:
errors.extend(e.messages)
if i == len(self.fields) and len(clean_data) == 0:
raise ValidationError(self.error_messages['optional_required'])
def clean(self, value):
""" Take a tuple of fields_valie(dict) and json_value(str) from JSONWidget """
fields_value, json_value = value
errors = ErrorList()
# Clear json value
if isinstance(json_value, basestring):
try:
json_value = loads(json_value)
except ValueError:
json_value = None
errors.append(_(u"JSON Field: Enter valid JSON"))
if json_value != None and not isinstance(json_value, dict):
errors.append(_(u"JSON Field: Must be a dict"))
# Clear fields
assert isinstance(fields_value, dict)
if json_value:
merge_dict(fields_value, json_value)
def _clean(f, _values):
for k, v in iterhelper(f):
if isinstance(v, (dict, tuple, list)):
_clean(v, _values.get(k, {}))
else:
try:
tmp = _values.get(k, None)
v.clean(tmp)
_values[k] = v.to_python(tmp)
except FormValidationError, e:
errors.extend(
map(lambda x, y: x + y, [u"%s %s: " % (_("Field"), k)] * len(e.messages), e.messages)
)
def lib_artist(request, artist_name):
artist_name_comma = Artist.commafy(artist_name)
artist = get_object_or_none(Artist, name=artist_name_comma)
if (artist is None):
artist = get_object_or_none(Artist, name=artist_name)
errors = ErrorList()
albums = []
similar_artists = []
artist_art = ''
api = PyLastFm()
art_api = EchoNest()
if artist is not None:
albums = Album.objects.filter(artist=artist).order_by("-date_released")
if albums.count() > 0:
lfm_artist = get_last_fm_artist_name(artist)
if lfm_artist:
similar_artists = [similar for similar in api.get_similar_artists(lfm_artist)
if Artist.objects.filter(name__iexact=similar).count() > 0 or
Artist.objects.filter(name__iexact=Artist.commafy(similar)).count() > 0
]
artist_art = art_api.get_artist_art(lfm_artist)
else:
errors.append('The artist could not be found by Last.Fm')
return render_to_response('artist.html', {
'errors': errors,
'albums': albums,
'artist': artist,
'artist_art': artist_art,
'similar_artists': similar_artists,
}, context_instance=RequestContext(request))
def clean(self, value):
'''\
value is assumed to be a dictionary of values with keys corresponding
to the ones in self.subfields. Each value is validated against it's
corresponding field.
'''
clean_data = {}
errors = ErrorList()
if value is None:
return value
if not isinstance(value, dict):
raise ValidationError(self.error_messages['invalid'])
for fieldname, field in self.subfields.items():
if not fieldname in value.keys():
if field.required:
raise ValidationError(field.error_messages['required'])
else:
continue
try:
clean_data[fieldname] = field.clean(value[fieldname])
except ValidationError, e:
errors.extend(e.messages)
def form_valid(self, form):
with transaction.commit_manually():
try:
super(ItemCreate, self).form_valid(form)
except ValidationError as e:
transaction.rollback()
errors = ErrorList()
for error in e.messages:
errors.append(error)
errors = form._errors.setdefault(NON_FIELD_ERRORS, errors)
return super(ItemCreate, self).form_invalid(form)
context = self.get_context_data()
itemimage_form = context['itemimage_formset']
if itemimage_form.is_valid():
itemimage_form.save()
transaction.commit()
return redirect(self.get_success_url())
else:
transaction.rollback()
return self.render_to_response(
self.get_context_data(form=form)
)
def clean_sub_fields(self, value):
"""'value' being the list of the values of the subfields, validate
each subfield."""
clean_data = []
errors = ErrorList()
# Remove the field corresponding to the SKIP_CHECK_NAME boolean field
# if required.
fields = self.fields if not self.skip_check else self.fields[:-1]
for index, field in enumerate(fields):
try:
field_value = value[index]
except IndexError:
field_value = None
# Check the field's 'required' field instead of the global
# 'required' field to allow subfields to be required or not.
if field.required and field_value in validators.EMPTY_VALUES:
errors.append(
'%s: %s' % (field.label, self.error_messages['required']))
continue
try:
clean_data.append(field.clean(field_value))
except ValidationError, 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(
['%s: %s' % (field.label, message)
for message in e.messages])
def clean(self, value):
"""
Validates every value in the given list. A value is validated against
the corresponding Field in self.fields.
For example, if this MultiValueField was instantiated with
fields=(DateField(), TimeField()), clean() would call
DateField.clean(value[0]) and TimeField.clean(value[1]).
"""
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 validators.EMPTY_VALUES]:
if self.required:
raise ValidationError(self.error_messages["required"])
else:
return self.compress([])
else:
raise ValidationError(self.error_messages["invalid"])
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
if self.required and field_value in validators.EMPTY_VALUES:
raise ValidationError(self.error_messages["required"])
try:
clean_data.append(field.clean(field_value))
except ValidationError, 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)
def clean(self, value):
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'])
else:
return []
else:
raise ValidationError(self.error_messages['invalid'])
field = self.field_type(required=self.required)
for field_value in value:
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 field.required:
field.required = False
if errors:
raise ValidationError(errors)
self.validate(clean_data)
self.run_validators(clean_data)
return clean_data
def form_valid(self, form):
try:
return super(ExhibitionCreate, self).form_valid(form)
except ValidationError as e:
errors = ErrorList()
for error in e.messages:
errors.append(error)
errors = form._errors.setdefault(NON_FIELD_ERRORS, errors)
return super(ExhibitionCreate, self).form_invalid(form)
def clean(self, value):
"""
Validates every value in the given list. A value is validated against
the corresponding Field in self.fields.
For example, if this MultiValueField was instantiated with
fields=(DateField(), TimeField()), clean() would call
DateField.clean(value[0]) and TimeField.clean(value[1]).
"""
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
data_field = self.field_type(**self.field_kwargs)
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 = data_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 data_field.required:
data_field.required = False
if errors:
raise ValidationError(errors)
self.validate(clean_data)
self.run_validators(clean_data)
return clean_data
def post(self, request, *args, **kwargs):
if self.async_response is not None:
return self.async_response
if self.subscription_form.is_valid():
try:
subscription = self.subscription_form.create_subscription()
return HttpResponseRedirect(reverse(ManageBillingAccountView.urlname, args=(subscription.account.id,)))
except NewSubscriptionError as e:
errors = ErrorList()
errors.extend([e.message])
self.subscription_form._errors.setdefault(NON_FIELD_ERRORS, errors)
return self.get(request, *args, **kwargs)
def lib_main(request):
albums = []
errors = ErrorList()
pager = Paginator([], 1)
selected_page = 1
form = None # it's our search form
# If a form was just submitted
if request.method == 'POST':
form = SearchForm(request.POST) # A form bound to the POST data
if form.is_valid():
# Use the form fields to search and filter albums from the db
albums = lib_main_filter_albums(form)
pager = Paginator(albums, form.cleaned_data['items_per_page'])
selected_page = int(form.cleaned_data['selected_page'])
page_list = [(str(x), str(x)) for x in pager.page_range][:100]
if len(page_list) is 0:
form.fields['selected_page'][('1', '1')]
else:
form.fields['selected_page'].choices = page_list
form.fields['selected_page'].initial = selected_page
else:
# Add all of the errors in the form.errors dict to our error list
errors.extend(chain.from_iterable(form.errors.values()))
form.save()
else:
form = SearchForm(initial={'artist': request.GET.get('artist'),
'album': request.GET.get('album'),
'label': request.GET.get('label'),
'year': request.GET.get('year'),
'genre': request.GET.get('genre'),
'stack': request.GET.get('stack'),
'selected_page': "1",
'items_per_page': "25",
})
form.fields['selected_page'].choices = [(str(x), str(x)) for x in pager.page_range][:100]
albums_page = []
try:
albums_page = pager.page(selected_page).object_list
except EmptyPage:
albums_page = pager.page(1).object_list
errors.append("That page is empty.")
return render_to_response('library.html', {
'form': form,
'albums': albums_page,
'errors': errors,
}, context_instance=RequestContext(request))
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.REQUEST.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 and new_user.is_active:
# 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_to_response(
'tos/tos_check.html',
context_instance=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_to_response(
'landing/login.html',
locals(),
context_instance=RequestContext(request),
)
def clean(self, value):
"""
Validates every value in the given list. A value is validated against
the corresponding Field in self.fields.
For example, if this MultiValueField was instantiated with
fields=(DateField(), TimeField()), clean() would call
DateField.clean(value[0]) and TimeField.clean(value[1]).
"""
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
if field_value in self.empty_values:
if self.require_all_fields:
# Raise a 'required' error if the MultiValueField is
# required and any field is empty.
if self.required:
raise ValidationError(self.error_messages['required'], code='required')
elif field.required:
# Otherwise, add an 'incomplete' error to the list of
# collected errors and skip field cleaning, if a required
# field is empty.
if field.error_messages['incomplete'] not in errors:
errors.append(field.error_messages['incomplete'])
continue
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. Skip duplicates.
errors.extend(m for m in e.error_list if m not in errors)
if errors:
raise ValidationError(errors)
out = self.compress(clean_data)
self.validate(out)
self.run_validators(out)
return out
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.IntegerField(), forms.IntegerField()),
widget=MutuallyExclusiveRadioWidget(widgets=[
forms.Select(choices=[(1,1), (2,2)]),
forms.TextInput(attrs={'placeholder':
'Enter a number'}),
]))
"""
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 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
data_field = self.field_type(**self.field_kwargs)
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 = data_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 data_field.required:
data_field.required = False
if errors:
raise ValidationError(errors)
self.validate(clean_data)
self.run_validators(clean_data)
return clean_data
def errors_append(form, field_name, message):
u"""
Add an ValidationError to a field (instead of __all__) during Form.clean():
class MyForm(forms.Form):
def clean(self):
value_a=self.cleaned_data['value_a']
value_b=self.cleaned_data['value_b']
if value_a==... and value_b==...:
formutils.errors_append(self, 'value_a', u'Value A must be ... if value B is ...')
return self.cleaned_data
"""
error_list = form.errors.get(field_name)
if error_list is None:
error_list = ErrorList()
form.errors[field_name] = error_list
error_list.append(message)
def __init__(self, label, help_text, html, required, default_value=None, attrs={}):
self.label_text = label
self.help_text = help_text
self.html = html
self.required = required
self.default_value = default_value
self.attrs = attrs
self.errors = ErrorList()
def lib_album(request, artist_name, album_title):
errors = ErrorList()
songs = []
album_art = ''
api = PyLastFm()
album = get_object_or_none(Album, artist__name__iexact=artist_name, name__iexact=album_title)
artist = get_object_or_none(Artist, name__iexact=artist_name)
if album is not None and artist is not None:
# Check if we have the track listing in our database
songs = Song.objects.filter(album=album).order_by('track_num')
try:
lfm_artist = get_last_fm_artist_name(artist)
album_art = api.get_album_art(lfm_artist, album.name)
# If not, get the track listing from Last.fm and save it.
if songs.count() == 0:
songs = save_track_list(album)
except WSError:
errors.append('The album or artist could not be found by Last.Fm')
else:
if artist is None:
errors.append('The artist was not found in the WUVT Library.')
if album is None:
errors.append('The album was not found in the WUVT library.')
return render_to_response('album.html', {
'errors': errors,
'album': album,
'album_art': album_art,
'songs': songs,
}, context_instance=RequestContext(request))
def is_promotable(self):
"""
Returns True if the object's state is the last state of its lifecycle.
"""
self._promotion_errors = ErrorList()
if self.lifecycle.last_state == self.state:
self._promotion_errors.append(_(u"The object is at its last state."))
return False
return True
def clean(self, value):
"""
This is a copy of MultiValueField.clean() with a BUGFIX:
- if self.required and field_value in validators.EMPTY_VALUES:
+ if field.required and field_value in validators.EMPTY_VALUES:
"""
from django.forms.util import ErrorList
from django.core import validators
from django.core.exceptions import ValidationError
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 validators.EMPTY_VALUES]:
if self.required:
raise ValidationError(self.error_messages['required'])
else:
return self.compress(value)
else:
raise ValidationError(self.error_messages['invalid'])
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
if field.required and field_value in validators.EMPTY_VALUES:
raise ValidationError(self.error_messages['required'])
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 clean(self, value):
self.errors = ErrorList()
self.value = value
try:
self.validate(value)
except ValidationError as e:
self.errors.extend(e.messages)
if self.errors:
raise ValidationError(self.errors)
return value
def clean_product_rates(self):
original_data = self.cleaned_data['product_rates']
rates = json.loads(original_data)
rate_instances = []
errors = ErrorList()
for rate_data in rates:
rate_form = ProductRateForm(rate_data)
if not rate_form.is_valid():
errors.extend(list(self._get_errors_from_subform(rate_data['name'], rate_form)))
else:
rate_instances.append(self._retrieve_product_rate(rate_form))
if errors:
self._errors.setdefault('product_rates', errors)
self.new_product_rates = rate_instances
rate_ids = lambda x: set([r.id for r in x])
if (not self.is_update
and (self.plan_version is None
or rate_ids(rate_instances).symmetric_difference(rate_ids(self.plan_version.product_rates.all())))):
self.is_update = True
return original_data
def clean(self, value):
"""
Validates every value in the given list. A value is validated against
the corresponding Field in self.fields.
For example, if this MultiValueField was instantiated with
fields=(DateField(), TimeField()), clean() would call
DateField.clean(value[0]) and TimeField.clean(value[1]).
"""
clean_data = []
errors = ErrorList()
# Currently no file is uploaded so we continue validation.
# If a file is already updated is and you haven't
# if not value or isinstance(value, (list, tuple)):
# if not value or not [v for v in value if v not in validators.EMPTY_VALUES]:
# if self.required:
# raise ValidationError(self.error_messages['required'])
# else:
# return self.compress([])
# else:
# raise ValidationError(self.error_messages['invalid'])
if value[0]:
try:
field_value = value[0]
except IndexError:
field_value = None
if self.required and field_value in validators.EMPTY_VALUES:
raise ValidationError(self.error_messages['required'])
try:
clean_data.append(self.fields[0].clean(field_value))
except ValidationError, 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.extend([None for i in range(6)])
def clean(self, value):
"""
Validates every value in the given list. A value is validated against
the corresponding Field in self.fields.
For example, if this MultiValueField was instantiated with
fields=(DateField(), TimeField()), clean() would call
DateField.clean(value[0]) and TimeField.clean(value[1]).
"""
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'])
else:
return []
else:
raise ValidationError(self.error_messages['invalid'])
field = self.field_type(required=self.required)
for field_value in value:
if self.required and field_value in self.empty_values:
raise ValidationError(self.error_messages['required'])
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 field.required:
field.required = False
if errors:
raise ValidationError(errors)
self.validate(clean_data)
self.run_validators(clean_data)
return clean_data
def _validate_data(self, cleaned_data, row_num, applicable_contract):
"""
Like django's clean method, use this to validate across fields
"""
errors = ErrorList()
validation_methods = [
self._validate_open_closed_date,
self._validate_service_adaptation,
self._validate_media_code,
self._validate_stage_reached,
self._validate_dob_present,
]
validation_methods.extend(self.get_extra_validators_for_applicable_contract(applicable_contract))
validation_methods_depend_on_category = [
self._validate_time_spent,
self._validate_exemption,
self._validate_telephone_or_online_advice,
self._validate_determination_dvca_is_family,
]
for m in validation_methods:
try:
m(cleaned_data)
except serializers.ValidationError as ve:
errors.append(self.format_message(ve.message, row_num))
try:
category = self._validate_category_consistency(cleaned_data)
except serializers.ValidationError as ve:
errors.append(self.format_message(ve.message, row_num))
raise serializers.ValidationError(errors)
for m in validation_methods_depend_on_category:
try:
m(cleaned_data, category)
except serializers.ValidationError as ve:
errors.append(self.format_message(ve.message, row_num))
if len(errors):
raise serializers.ValidationError(errors)
return cleaned_data
def _validate_fields(self):
"""
Validate individual field values, like django's clean_<fieldname> with
less magic ( no setattr('clean_'+field_name) junk) just loop over
the fields and apply the validators specified in the
field spec (self._get_expected_fields_for_row(row))
"""
cleaned_data = {}
errors = ErrorList()
for row_num, row in enumerate(self.rows):
expected_fields = self._get_validators_for_row(row)
if len(row) != len(expected_fields):
raise serializers.ValidationError(
"Row: %s - Incorrect number of columns should be %s "
"actually %s" % (row_num + 1, len(expected_fields), len(row))
)
for idx, field_name in enumerate(expected_fields):
field_value = row[idx]
validators = expected_fields[field_name]
try:
cleaned_data[field_name] = self._validate_field(
field_name, field_value.strip(), idx, row_num, validators
)
except serializers.ValidationError as ve:
errors.append(ve)
except (AssertionError, TypeError) as e:
errors.append(e)
try:
# Global Validation
applicable_contract = self._get_applicable_contract_for_row(row)
self.cleaned_data.append(self._validate_data(cleaned_data, row_num, applicable_contract))
except serializers.ValidationError as ve:
errors.extend(ve.error_list)
if len(errors):
raise serializers.ValidationError(errors)
def post(self, request):
form = self.form_class(request.POST, request.FILES)
backend_forms = []
if form.is_valid():
text = form.cleaned_data['text']
access_level, user_identifier, confirm = request.service.check_access(
request, text)
def prepare_message():
message = Message()
message.set_service(request.service)
message.user_identifier = user_identifier
message.text = text
return message
if access_level == 'moderate':
message = prepare_message()
message.closed = False
message.save()
return render_to_response(
'multitreehole/publish-moderate.html', {
'user_identifier': user_identifier,
'message': message,
},
context_instance=RequestContext(request))
elif access_level == 'accept':
message = prepare_message()
message.closed = True
message.save()
if confirm(message):
client = request.backend.make_client(
request.service.backend.pk,
request.service.backend.params)
backend_message = client.make_message(
form.cleaned_data['text'])
status = backend_message.publish(request.POST,
request.FILES)
else:
status = {
'error':
ErrorList([
_('Access confirmation failed. Are you requesting concurrently?'
)
])
}
if 'forms' in status:
backend_forms = status['forms']
if 'error' in status:
form._errors['text'] = status['error']
if 'data' in status:
message.backend = request.service.backend
message.backend_data = status['data']
message.save()
return render_to_response(
'multitreehole/publish-accept.html', {
'user_identifier': user_identifier,
'message': message,
},
context_instance=RequestContext(request))
message.delete()
else:
access_level, user_identifier, confirm = request.service.check_access(
request)
return self.render_to_response({
'form': form,
'backend_forms': backend_forms,
'access_level': access_level,
'user_identifier': user_identifier,
})
def clean(self):
cleaned_data = self.cleaned_data
if not cleaned_data.get('excel_file') and not cleaned_data.get(
'converted_items'):
self.errors['excel_file'] = ErrorList([u'Required Field'])
return cleaned_data
raise PopupException(
_('There was a problem with some of the LDAP information'),
detail=str(e))
if users and form.cleaned_data['ensure_home_directory']:
for user in users:
try:
ensure_home_directory(request.fs, user.username)
except (IOError, WebHdfsException), e:
request.error(
_("Cannot make home directory for user %s." %
user.username))
if not users:
errors = form._errors.setdefault('username_pattern',
ErrorList())
errors.append(
_('Could not get LDAP details for users in pattern %s.') %
username_pattern)
else:
return redirect(reverse(list_users))
else:
form = AddLdapUsersForm()
return render('add_ldap_users.mako', request, dict(form=form))
def add_ldap_groups(request):
"""
add_ldap_groups(request) -> reply
def edit_document(request, document_slug, revision_id=None):
"""Create a new revision of a wiki document, or edit document metadata."""
doc = get_object_or_404(
Document, locale=request.LANGUAGE_CODE, slug=document_slug)
user = request.user
can_edit_needs_change = doc.allows(user, 'edit_needs_change')
can_archive = doc.allows(user, 'archive')
# If this document has a parent, then the edit is handled by the
# translate view. Pass it on.
if doc.parent:
return translate(request, doc.parent.slug, revision_id)
if revision_id:
rev = get_object_or_404(Revision, pk=revision_id, document=doc)
else:
rev = doc.current_revision or doc.revisions.order_by('-created',
'-id')[0]
disclose_description = bool(request.GET.get('opendescription'))
doc_form = rev_form = None
if doc.allows(user, 'create_revision'):
rev_form = RevisionForm(
instance=rev,
initial={'based_on': rev.id, 'comment': ''})
if doc.allows(user, 'edit'):
doc_form = DocumentForm(
initial=_document_form_initial(doc),
can_archive=can_archive,
can_edit_needs_change=can_edit_needs_change)
if request.method == 'GET':
if not (rev_form or doc_form):
# You can't do anything on this page, so get lost.
raise PermissionDenied
else: # POST
# Comparing against localized names for the Save button bothers me, so
# I embedded a hidden input:
which_form = request.POST.get('form')
_document_lock_clear(doc.id, user.username)
if which_form == 'doc':
if doc.allows(user, 'edit'):
post_data = request.POST.copy()
post_data.update({'locale': request.LANGUAGE_CODE})
topics = []
for t in post_data.getlist('topics'):
topics.append(long(t))
post_data.setlist('topics', topics)
doc_form = DocumentForm(
post_data,
instance=doc,
can_archive=can_archive,
can_edit_needs_change=can_edit_needs_change)
if doc_form.is_valid():
# Get the possibly new slug for the imminent redirection:
try:
doc = doc_form.save(None)
except (TitleCollision, SlugCollision) as e:
# TODO: .add_error() when we upgrade to Django 1.7
errors = doc_form._errors.setdefault('title',
ErrorList())
message = 'The {type} you selected is already in use.'
message = message.format(
type='title' if isinstance(e, TitleCollision) else
'slug')
errors.append(_(message))
else:
# Do we need to rebuild the KB?
_maybe_schedule_rebuild(doc_form)
return HttpResponseRedirect(
urlparams(reverse('wiki.edit_document',
args=[doc.slug]),
opendescription=1))
disclose_description = True
else:
raise PermissionDenied
elif which_form == 'rev':
if doc.allows(user, 'create_revision'):
rev_form = RevisionForm(request.POST)
rev_form.instance.document = doc # for rev_form.clean()
if rev_form.is_valid():
_save_rev_and_notify(rev_form, user, doc, base_rev=rev)
if 'notify-future-changes' in request.POST:
EditDocumentEvent.notify(request.user, doc)
return HttpResponseRedirect(
reverse('wiki.document_revisions',
args=[document_slug]))
else:
raise PermissionDenied
show_revision_warning = _show_revision_warning(doc, rev)
locked, locked_by = _document_lock(doc.id, user.username)
return render(request, 'wiki/edit.html', {
'revision_form': rev_form,
'document_form': doc_form,
'disclose_description': disclose_description,
'document': doc,
'show_revision_warning': show_revision_warning,
'locked': locked,
'locked_by': locked_by})
def add_event(request,
template='schedule/schedule_form.html',
event_form_class=ReferralForm,
recurrence_form_class=ScheduleOccurrenceForm,
redirect_to=None):
# have to contains dtstart variable in URL. URL from schedule have to
# contains date and time informations.
if 'dtstart' not in request.GET:
return http.HttpResponseRedirect('/schedule/')
if request.method == 'POST':
if int(request.POST.get('count')) > 40: # limit occurrence repeat
return render_to_response(
'403.html', {
'object':
_('Sorry. You can not book more than 40 occurrence at the same \
time')
})
recurrence_form = recurrence_form_class(request.POST)
if recurrence_form.is_valid():
if invalid_delta_time(request.POST.get('start_time_delta'),
request.POST.get('end_time_delta')):
messages.error(
request,
_('The start time should be less than the end time'))
return http.HttpResponseRedirect(
request.META.get('HTTP_REFERER') or '/schedule/')
# filter devices based on selection
devices = DeviceDetails.objects.filter(
id__in=request.POST.getlist('device'))
start_occurrence_date = end_occurrence_date = datetime(
year=int(request.POST.get('until_year')),
month=int(request.POST.get('until_month')),
day=int(request.POST.get('until_day')))
# create a start delta time
start_delta = timedelta(
seconds=int(request.POST.get('start_time_delta')))
# checking till one minute before next session
end_delta = timedelta(
seconds=(int(request.POST.get('end_time_delta')) - 1))
# get correct start time of device schedule
start_device_schedule = (start_occurrence_date + start_delta)
end_device_schedule = (end_occurrence_date + end_delta)
# try to check if there's any occurrence with the device in
# specified time
occurrence_start = Occurrence.objects.filter(
start_time__range=(start_device_schedule, end_device_schedule),
scheduleoccurrence__device__in=devices,
)
# check exact end time
end_delta = timedelta(
seconds=int(request.POST.get('end_time_delta')))
end_device_schedule = (end_occurrence_date + end_delta)
occurrence_end = Occurrence.objects.filter(
end_time__range=(start_device_schedule, end_device_schedule),
scheduleoccurrence__device__in=devices,
)
if len(occurrence_start) is not 0 or len(occurrence_end) is not 0:
error = recurrence_form._errors.setdefault(
'device', ErrorList())
error.append('Selected device is busy')
if request.POST.get('tabtitle'): # booking single client
if verify_client(request.POST.get('referral')) is False:
messages.error(request, _('Check the mandatory fields'))
return http.HttpResponseRedirect(
request.META.get('HTTP_REFERER') or '/schedule/')
referral = get_object_or_404(Referral,
pk=request.POST.get('referral'),
service__organization=request.
user.get_profile().org_active)
event = recurrence_form.save(referral)
elif request.POST.get('group'): # booking a group
group = get_object_or_404(ServiceGroup,
pk=request.POST.get('group'),
service__organization=request.user.
get_profile().org_active,
active=True)
# this check is already done in template. just to prevent
# empty groups
if group.charged_members():
first = True
for group_member in group.charged_members():
if first:
event = recurrence_form.save(group_member.referral)
first = False
else:
if not event.errors:
# ignore busy check
event = recurrence_form.save(
group_member.referral, True)
else:
referral = get_object_or_404(
Referral,
pk=request.POST.get('select_referral'),
service__organization=request.user.get_profile(
).org_active)
event = recurrence_form.save(referral, True, True)
if not event.errors:
messages.success(request, _('Schedule saved successfully'))
return http.HttpResponseRedirect(redirect_to or '/schedule/')
else:
return render_to_response(
'schedule/event_detail.html',
dict(event=event),
context_instance=RequestContext(request))
else:
dtstart = parser.parse(request.GET['dtstart'])
room = get_object_or_None(
Room,
pk=request.GET.get('room'),
place__organization=request.user.get_profile().org_active)
client = get_object_or_None(
Client,
pk=request.GET.get('client'),
person__organization=request.user.get_profile().org_active)
referral = get_object_or_None(
Referral,
pk=request.GET.get('referral'),
service__organization=request.user.get_profile().org_active)
event_form = event_form_class()
recurrence_form = recurrence_form_class(initial=dict(
dtstart=dtstart,
day=datetime.strptime(dtstart.strftime("%Y-%m-%d"), "%Y-%m-%d"),
until=datetime.strptime(dtstart.strftime("%Y-%m-%d"), "%Y-%m-%d"),
room=room.id,
))
recurrence_form.fields['device'].widget.choices = ([
(i.id, i) for i in DeviceDetails.objects.active(
request.user.get_profile().org_active).filter(
Q(room=room) | Q(mobility="2", lendable=True)
| Q(place=room.place, mobility="2", lendable=False))
])
return render_to_response(
template,
dict(
dtstart=dtstart,
event_form=event_form,
recurrence_form=recurrence_form,
group=ServiceGroup.objects.filter(
service__organization=request.user.get_profile().org_active,
active=True),
room=room,
object=client,
referral=referral,
referrals=Referral.objects.all(),
room_id=room.id,
),
context_instance=RequestContext(request))
def add_field_error(form, field_name, message):
err_list = ErrorList((message, ))
form._errors[field_name] = err_list
def search(request):
"""
Handler for search form.
"""
if request.method == 'POST': # If the form has been submitted
form = SearchForm(request.POST) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
#process search form into search object, remove any properties
#that do not have values.
data = form.cleaned_data
for key in filter(lambda x: data[x]==None or data[x] == '', data):
del data[key]
search_object = Search()
search_object.data = data
#at least for now limit the size of the result set
count = search_object.querySet().count()
if count > settings.QUERY_LIMIT:
form._errors['Result Size'] = ErrorList(['Your query returned more than 20,000 records, refine your search'])
elif count == 0 and False:
form._errors['Result Size'] = ErrorList(['Your query returned no results'])
else:
#store search in session
search.dataset_version = pdb_select_settings.DATA_VERSION
request.session['search'] = pickle.dumps(search_object)
return redirect('%s/search/results/' % settings.SITE_ROOT) # Redirect after POST
# package aa_choices and ss_choices
aa_choices = []
ss_choices = []
for i in RESIDUE_INDEXES:
aa_chosen = request.POST.getlist('aa_%i' % i)
aa_choices.append([(c[0],c[1],'checked' if c[0] in aa_chosen else '') for c in AA_CHOICES])
ss_chosen = request.POST.getlist('ss_%i' % i)
ss_choices.append([(c[0],c[1],'checked' if c[0] in ss_chosen else '') for c in SS_CHOICES])
else:
aa_choices = [AA_CHOICES for i in range(settings.SEGMENT_SIZE)]
ss_choices = [SS_CHOICES for i in range(settings.SEGMENT_SIZE)]
form = SearchForm() # An unbound form
#delete session variable
try:
del request.session['search']
except:
pass
#construct a list of values for i
iValues = [
# Generates a series of tuples (<value>,<signed string of value>); zero is 'i'
(i,'%+i'%i if i else 'i') for i in RESIDUE_INDEXES
]
#order the residue properties in way that django template can handle it better
residueFields = []
fields = ["ss", "aa", "phi", "psi", "ome", "omep", "chi1", "chi2", "chi3", "chi4", "chi5", "bm", "bs", "bg", "h_bond_energy", "zeta", 'a1','a2','a3','a4','a5','a6','a7','L1','L2','L3','L4','L5']
fields += sidechain_length_relationship_list
fields += sidechain_angle_relationship_list
for i in RESIDUE_INDEXES:
dict = {}
for prefix in fields:
dict[prefix] = form['%s_%i' % (prefix, i)]
dict['%s_i' % prefix] = form['%s_i_%i' % (prefix, i)]
dict['index'] = i
residueFields.append(dict)
return render_to_response('search.html', {
'form': form,
'maxLength' : settings.SEGMENT_SIZE,
'iValues':iValues,
'residueFields':residueFields,
'aa_choices':aa_choices,
'ss_choices':ss_choices,
'sidechain_angle_list':sidechain_angle_relationship_list,
'sidechain_length_list':sidechain_length_relationship_list,
'sidechain_length_lookup':json_sidechain_lengths_lookup,
'sidechain_angle_lookup':json_sidechain_angles_lookup
}, context_instance=RequestContext(request, processors=[settings_processor]))
def document_metadata(
request,
docid,
template='documents/document_metadata.html'):
document = None
try:
document = _resolve_document(
request,
docid,
'base.change_resourcebase_metadata',
_PERMISSION_MSG_METADATA)
except Http404:
return HttpResponse(
loader.render_to_string(
'404.html', RequestContext(
request, {
})), status=404)
except PermissionDenied:
return HttpResponse(
loader.render_to_string(
'401.html', RequestContext(
request, {
'error_message': _("You are not allowed to edit this document.")})), status=403)
if document is None:
return HttpResponse(
'An unknown error has occured.',
content_type="text/plain",
status=401
)
else:
poc = document.poc
metadata_author = document.metadata_author
topic_category = document.category
if request.method == "POST":
document_form = DocumentForm(
request.POST,
instance=document,
prefix="resource")
category_form = CategoryForm(
request.POST,
prefix="category_choice_field",
initial=int(
request.POST["category_choice_field"]) if "category_choice_field" in request.POST else None)
else:
document_form = DocumentForm(instance=document, prefix="resource")
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
if request.method == "POST" and document_form.is_valid(
) and category_form.is_valid():
new_poc = document_form.cleaned_data['poc']
new_author = document_form.cleaned_data['metadata_author']
new_keywords = document_form.cleaned_data['keywords']
new_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
if new_poc is None:
if poc is None:
poc_form = ProfileForm(
request.POST,
prefix="poc",
instance=poc)
else:
poc_form = ProfileForm(request.POST, prefix="poc")
if poc_form.is_valid():
if len(poc_form.cleaned_data['profile']) == 0:
# FIXME use form.add_error in django > 1.7
errors = poc_form._errors.setdefault('profile', ErrorList())
errors.append(_('You must set a point of contact for this resource'))
poc = None
if poc_form.has_changed and poc_form.is_valid():
new_poc = poc_form.save()
if new_author is None:
if metadata_author is None:
author_form = ProfileForm(request.POST, prefix="author",
instance=metadata_author)
else:
author_form = ProfileForm(request.POST, prefix="author")
if author_form.is_valid():
if len(author_form.cleaned_data['profile']) == 0:
# FIXME use form.add_error in django > 1.7
errors = author_form._errors.setdefault('profile', ErrorList())
errors.append(_('You must set an author for this resource'))
metadata_author = None
if author_form.has_changed and author_form.is_valid():
new_author = author_form.save()
if new_poc is not None and new_author is not None:
the_document = document_form.save()
the_document.poc = new_poc
the_document.metadata_author = new_author
the_document.keywords.add(*new_keywords)
Document.objects.filter(id=the_document.id).update(category=new_category)
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_document, send_slack_messages
send_slack_messages(build_slack_message_document("document_edit", the_document))
except:
print "Could not send slack message for modified document."
return HttpResponseRedirect(
reverse(
'document_detail',
args=(
document.id,
)))
if poc is not None:
document_form.fields['poc'].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
if metadata_author is not None:
document_form.fields['metadata_author'].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
return render_to_response(template, RequestContext(request, {
"document": document,
"document_form": document_form,
"poc_form": poc_form,
"author_form": author_form,
"category_form": category_form,
}))
def register(request):
if request.method == 'POST':
if 'cancel' in request.POST:
return redirect_to_index(request)
form = RegistrationForm(request.POST)
if not settings.NAT_ID_VERIFICATION:
form.disable_national_id_verification()
if form.is_valid():
email = form.cleaned_data['email']
first_name = form.cleaned_data['first_name']
last_name = form.cleaned_data['last_name']
national_id = form.cleaned_data['national_id']
result, error_field, applicant = (validate_email_and_national_id(
email, national_id))
if result:
try:
applicant = form.get_applicant()
passwd = applicant.random_password()
applicant.save()
except IntegrityError:
# somehow, it gets error
result, error_field, applicant = (
validate_email_and_national_id(email, national_id))
return registration_error(error_field, applicant, email,
national_id, first_name,
last_name)
registration = Registration(applicant=applicant,
first_name=first_name,
last_name=last_name)
registration.random_and_save()
send_password_by_email(applicant, passwd)
return render_to_response(
'application/registration/success.html', {
'email': form.cleaned_data['email'],
'step_name': "การลงทะเบียนเรียบร้อย"
})
else:
if not applicant.has_logged_in:
return registration_error(error_field, applicant, email,
national_id, first_name,
last_name)
# e-mail or national id has been registered and logged in
from django.forms.util import ErrorList
from commons.utils import admin_email
if error_field == 'email':
dup_obj = u'อีเมล์'
else:
dup_obj = u'รหัสประจำตัวประชาชน'
form._errors['__all__'] = ErrorList([
u"""%(dup_obj)sนี้ถูกลงทะเบียนและถูกใช้แล้ว ถ้าอีเมล์นี้เป็นของคุณจริงและยังไม่เคยลงทะเบียน
กรุณาติดต่อผู้ดูแลระบบทางอีเมล์ <a href="mailto:%(email)s">%(email)s</a> หรือทางเว็บบอร์ด
อาจมีผู้ไม่ประสงค์ดีนำอีเมล์คุณไปใช้""" % {
'dup_obj': dup_obj,
'email': admin_email()
}
])
else:
form = RegistrationForm()
return render_to_response('application/registration/register.html',
{'form': form},
context_instance=RequestContext(request))
def layer_metadata(request, layername, template='layers/layer_metadata.html'):
layer = _resolve_layer(request, layername,
'base.change_resourcebase_metadata',
_PERMISSION_MSG_METADATA)
layer_attribute_set = inlineformset_factory(
Layer,
Attribute,
extra=0,
form=LayerAttributeForm,
)
topic_category = layer.category
poc = layer.poc
metadata_author = layer.metadata_author
if request.method == "POST":
if layer.metadata_uploaded_preserve: # layer metadata cannot be edited
out = {
'success': False,
'errors': METADATA_UPLOADED_PRESERVE_ERROR
}
return HttpResponse(json.dumps(out),
content_type='application/json',
status=400)
layer_form = LayerForm(request.POST, instance=layer, prefix="resource")
attribute_form = layer_attribute_set(
request.POST,
instance=layer,
prefix="layer_attribute_set",
queryset=Attribute.objects.order_by('display_order'))
category_form = CategoryForm(
request.POST,
prefix="category_choice_field",
initial=int(request.POST["category_choice_field"])
if "category_choice_field" in request.POST else None)
else:
layer_form = LayerForm(instance=layer, prefix="resource")
attribute_form = layer_attribute_set(
instance=layer,
prefix="layer_attribute_set",
queryset=Attribute.objects.order_by('display_order'))
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
if request.method == "POST" and layer_form.is_valid(
) and attribute_form.is_valid() and category_form.is_valid():
new_poc = layer_form.cleaned_data['poc']
new_author = layer_form.cleaned_data['metadata_author']
new_keywords = layer_form.cleaned_data['keywords']
if new_poc is None:
if poc is None:
poc_form = ProfileForm(request.POST,
prefix="poc",
instance=poc)
else:
poc_form = ProfileForm(request.POST, prefix="poc")
if poc_form.is_valid():
if len(poc_form.cleaned_data['profile']) == 0:
# FIXME use form.add_error in django > 1.7
errors = poc_form._errors.setdefault(
'profile', ErrorList())
errors.append(
_('You must set a point of contact for this resource'))
poc = None
if poc_form.has_changed and poc_form.is_valid():
new_poc = poc_form.save()
if new_author is None:
if metadata_author is None:
author_form = ProfileForm(request.POST,
prefix="author",
instance=metadata_author)
else:
author_form = ProfileForm(request.POST, prefix="author")
if author_form.is_valid():
if len(author_form.cleaned_data['profile']) == 0:
# FIXME use form.add_error in django > 1.7
errors = author_form._errors.setdefault(
'profile', ErrorList())
errors.append(
_('You must set an author for this resource'))
metadata_author = None
if author_form.has_changed and author_form.is_valid():
new_author = author_form.save()
new_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
for form in attribute_form.cleaned_data:
la = Attribute.objects.get(id=int(form['id'].id))
la.description = form["description"]
la.attribute_label = form["attribute_label"]
la.visible = form["visible"]
la.display_order = form["display_order"]
la.save()
if new_poc is not None and new_author is not None:
new_keywords = layer_form.cleaned_data['keywords']
layer.keywords.clear()
layer.keywords.add(*new_keywords)
the_layer = layer_form.save()
up_sessions = UploadSession.objects.filter(layer=the_layer.id)
if up_sessions.count(
) > 0 and up_sessions[0].user != the_layer.owner:
up_sessions.update(user=the_layer.owner)
the_layer.poc = new_poc
the_layer.metadata_author = new_author
Layer.objects.filter(id=the_layer.id).update(category=new_category)
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_layer, send_slack_messages
send_slack_messages(
build_slack_message_layer("layer_edit", the_layer))
except:
print "Could not send slack message."
return HttpResponseRedirect(
reverse('layer_detail', args=(layer.service_typename, )))
if poc is not None:
layer_form.fields['poc'].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
if metadata_author is not None:
layer_form.fields['metadata_author'].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
return render_to_response(
template,
RequestContext(
request, {
"layer": layer,
"layer_form": layer_form,
"poc_form": poc_form,
"author_form": author_form,
"attribute_form": attribute_form,
"category_form": category_form,
}))
def hidden_field_errors(form):
hidden_field_errors = ErrorList()
for field in form.hidden_fields():
hidden_field_errors.extend(field.errors)
return hidden_field_errors