def cy_view(request, template, pk=None, obj_type=None):
"""List, create, update view in one for a flatter heirarchy. """
# Infer obj_type from URL, saves trouble of having to specify
# kwargs everywhere in the dispatchers.
obj_type = obj_type or request.path.split('/')[2]
Klass, FormKlass = get_klasses(obj_type)
obj = get_object_or_404(Klass, pk=pk) if pk else None
form = None
if request.method == 'POST':
object_table = None
page_obj = None
form = FormKlass(request.POST, instance=obj)
if form.is_valid():
try:
if perm(request, ACTION_CREATE, obj=obj, obj_class=Klass):
obj = form.save()
if Klass.__name__ == 'Ctnr':
request = ctnr_update_session(request, obj)
if (hasattr(obj, 'ctnr_set')
and not obj.ctnr_set.exists()):
obj.ctnr_set.add(request.session['ctnr'])
object_table = tablefy([obj], request=request)
return HttpResponse(json.dumps({'row': object_table}))
except (ValidationError, ValueError) as e:
if form.errors is None:
form.errors = ErrorDict()
form.errors.update(e.message_dict)
return HttpResponse(json.dumps({'errors': form.errors}))
except DatabaseError as e: # DatabaseError(number, description)
if form.errors is None:
form.errors = ErrorDict()
form.errors.setdefault('__all__', []).append(e.args[1])
return HttpResponse(json.dumps({'errors': form.errors}))
else:
return HttpResponse(json.dumps({'errors': form.errors}))
elif request.method == 'GET':
object_list = _filter(request, Klass)
form = FormKlass(instance=obj)
page_obj = make_paginator(request, do_sort(request, object_list), 50)
object_table = tablefy(page_obj, request=request)
if isinstance(form, UsabilityFormMixin):
form.make_usable(request)
return cy_render(
request, template, {
'form': form,
'obj': obj,
'page_obj': page_obj,
'object_table': object_table,
'obj_type': obj_type,
'pretty_obj_type': Klass.pretty_type,
'pk': pk,
})
def delete(self, request):
"""
Deletes the Note in the model with the particular jid of the note passed in. Only the jid matters;
all other fields are ignored.
If a note with such a JID does not exist, return 404.
Called with HTTP DELETE
"""
#ResourceForm = forms.form_for_model(Note, form=self.form_class)
data = self.receiver.get_put_data(request)
#form = ResourceForm(data)
form = NoteForm(data)
request_user = basicauth_get_user_by_emailaddr(request)
if not request_user:
logevent(request, 'Note.delete', 401,
jv3.utils.decode_emailaddr(request))
return self.responder.error(
request, 401,
ErrorDict({"autherror":
"Incorrect user/password combination"}))
matching_notes = Note.objects.filter(jid=form.data['jid'],
owner=request_user)
if len(matching_notes) == 0:
return self.responder.error(
request, 404,
ErrorDict(
{"jid": "Note with jid %d not found" % form.data["jid"]}))
for to_die in matching_notes:
to_die.delete()
return HttpResponse(_("Object successfully deleted."),
self.responder.mimetype)
def is_valid(self):
is_valid = super(DatasetForm, self).is_valid()
is_valid = is_valid and self.tag_formset.is_valid()
is_valid = is_valid and self.source_formset.is_valid()
# Django does not allow to change form.errors, so we use form._errors
if not is_valid:
if self.tag_formset._errors or self.source_formset._errors:
self._errors = dict(self._errors)
for error in self.tag_formset._errors:
self._errors.update(dict(error))
for error in self.source_formset._errors:
self._errors.update(dict(error))
self._errors = ErrorDict(self._errors)
else:
self.cleaned_data['tags'] = [
form.cleaned_data for form in self.tag_formset
]
self.cleaned_data['sources'] = [
form.cleaned_data for form in self.source_formset
]
return is_valid
def update_ns(request, nameserver_pk):
nameserver = get_object_or_404(Nameserver, pk=nameserver_pk)
if request.method == "POST":
form = NameserverForm(request.POST, instance=nameserver)
try:
if form.is_valid():
server = form.cleaned_data['server']
domain = form.cleaned_data['domain']
if 'glue' in form.cleaned_data:
glue_type, glue_pk = form.cleaned_data['glue'].split('_')
try:
if glue_type == 'addr':
glue = AddressRecord.objects.get(pk=glue_pk)
elif glue_type == 'intr':
glue = StaticInterface.objects.get(pk=glue_pk)
except ObjectDoesNotExists, e:
raise ValidationError("Couldn't find glue: " + str(e))
nameserver.glue = glue
nameserver.server = server
nameserver.domain = domain
nameserver.clean()
nameserver.save()
except ValidationError, e:
form = Nameserver(instance=nameserver)
if form._errors is None:
form._errors = ErrorDict()
form._errors['__all__'] = ErrorList(e.messages)
return redirect(nameserver)
def post_handler(self, object_, record_type, orig_qd):
"""Create or update object_. qd is a QueryDict."""
qd = copy.deepcopy(
orig_qd) # If there are ever errors, we have to preserver
# the original qd
comment = qd.pop('comment', [''])[0].strip()
# This little chunk of code could be factored out, but I think it's
# more clear when you see which objects don't need to call this in one
# spot.
qd, errors = self.modify_qd(qd, object_=object_)
if errors:
return None, errors
# Create a save-able form to create/update the object
if object_:
object_form = self.form(qd, instance=object_)
else:
object_form = self.form(qd)
if object_form.is_valid():
try:
object_ = object_form.save()
reversion.set_comment(comment)
except ValidationError, e:
if 'domain' in qd:
prune_tree(Domain.objects.get(pk=qd['domain']))
e_dict = ErrorDict()
e_dict['__all__'] = ErrorList(e.messages)
return None, e_dict
return object_, None
def full_clean(self):
if self.is_blank():
# Blank forms are always valid
self._errors = ErrorDict()
self.cleaned_data = {}
return
super(AutoDeleteForm, self).full_clean()
def security_errors(self):
"""Return just those errors associated with security"""
errors = ErrorDict()
for f in ["honeypot", "timestamp", "security_hash"]:
if f in self.errors:
errors[f] = self.errors[f]
return errors
def _create_ipv4_intr_from_range(label, domain_name, system, mac, range_start,
range_end):
if range_start >= range_end - 1:
errors['ip'] = ErrorList(["The start ip must be less than end ip."])
return None, errors
ip = find_free_ip(range_start, range_end, ip_type='4')
errors = ErrorDict()
if not ip:
errors['ip'] = ErrorList([
"Could not find free ip in range {0} - "
"{1}".format(range_start, range_end)
])
return None, errors
domain = ensure_domain(domain_name, inherit_soa=True)
try:
intr = StaticInterface(label=label,
domain=domain,
ip_str=str(ip),
ip_type='4',
system=system,
mac=mac)
intr.clean()
except ValidationError, e:
errors['interface'] = ErrorList(e.messages)
def create_ipv4_intr_from_range(label, domain_name, system, mac,
range_start_str, range_end_str):
"""This function creates an interface using the first free ip in the
specified range. This function will also ensure that a :class:`Domain` with
the name=``domain_name`` exists in the database. If a new domain is created
it will enheirit it's master's SOA. If the name ``<label>.<domain_name>``
is already a domain, the new interface's label will be set to the empty
string.
:param label: The desired label of the interface.
:type lable: str
:param domain_name: The name of the domain to create the interface in.
:type domain_name: str
:param system: The system object that the interface should be associated to
:type system: :class:`System`
:param mac: The mac address of the interface
:type mac: str
:param range_start_str: The IP where this function should start looking for
a free ip (inclusive).
:type range_start_str: str
:param range_end_str: The last IP where this function should look for
a free ip (inclusive).
:type range_end_str: str
"""
errors = ErrorDict()
try:
start = ipaddr.IPv4Address(range_start_str)
except ipaddr.ValidationError, e:
errors['ip'] = ErrorList(
["Invalid IPv4 ip {0}".format(range_start_str)])
return None, errors
def cydns_view(request, pk=None):
"""List, create, update view in one for a flatter heirarchy. """
# Infer obj_type from URL, saves trouble of having to specify
# kwargs everywhere in the dispatchers.
obj_type = request.path.split('/')[2]
Klass, FormKlass = get_klasses(obj_type)
obj = get_object_or_404(Klass, pk=pk) if pk else None
if request.method == 'POST':
page_obj = None
form = FormKlass(request.POST, instance=obj)
try:
if perm(request, ACTION_CREATE, obj=obj, obj_class=Klass):
obj = form.save()
# If domain, add to current ctnr.
if is_ajax_form(request):
return HttpResponse(json.dumps({'success': True}))
if (hasattr(obj, 'ctnr_set') and not obj.ctnr_set.exists()):
obj.ctnr_set.add(request.session['ctnr'])
return redirect(obj.get_list_url())
except (ValidationError, ValueError), e:
if hasattr(e, 'messages'):
e = e.messages
if not form._errors:
form._errors = ErrorDict()
form._errors['__all__'] = ErrorList(e)
if is_ajax_form(request):
return HttpResponse(json.dumps({'errors': form.errors}))
def error(self, request, status_code, error_dict=None):
"""
Return XML error response that includes a human readable error
message, application-specific errors and a machine readable
status code.
"""
from django.conf import settings
if not error_dict:
error_dict = ErrorDict()
response = HttpResponse(mimetype = self.mimetype)
response.status_code = status_code
xml = SimplerXMLGenerator(response, settings.DEFAULT_CHARSET)
xml.startDocument()
xml.startElement("django-error", {})
xml.addQuickElement(name="error-message", contents='%d %s' % (status_code, STATUS_CODE_TEXT[status_code]))
xml.addQuickElement(name="status-code", contents=str(status_code))
if error_dict:
xml.startElement("model-errors", {})
for (model_field, errors) in error_dict.items():
for error in errors:
xml.addQuickElement(name=model_field, contents=error)
xml.endElement("model-errors")
xml.endElement("django-error")
xml.endDocument()
return response
def handle_result_form(request):
if request.method == 'POST':
form = ResultForm(request.POST, request.FILES, request=request)
form.added = False
if form.is_valid():
new = form.save(commit=False)
r = Result.objects.filter(method=new.method,
task=new.task,
challenge=new.challenge)
if r.count():
new = r[0]
new.aggregation_score = -1
new.output_file = request.FILES['output_file']
score, msg, ok = new.predict()
try:
new.aggregation_score = score[0]
new.complex_result_type = score[1]
new.complex_result = pickle.dumps(score[2])
except Exception:
new.aggregation_score = score
if ok:
new.save()
form.added = True
else:
form.errors['output_file'] = ErrorDict({'': msg}).as_ul()
else:
form = ResultForm(request=request)
form.added = False
return form
def full_clean(self):
"""
Rewrite the error dictionary, so that its keys correspond to the model fields.
"""
super(NgModelFormMixin, self).full_clean()
if self._errors and self.prefix:
self._errors = ErrorDict((self.add_prefix(name), value) for name, value in self._errors.items())
def genericSocialActivate(sn_method,
sn_id,
access_token,
request,
state='homepage'):
try:
activation_result = ttagActivateSocialAccount(sn_method, sn_id,
access_token)
response = None
if activation_result['result'] == 'OK':
response = render_to_response(
'lb_signin.html', {'state': state},
context_instance=RequestContext(request))
else:
form = SignInForm({'user': '******', 'password': '******'})
form._errors = ErrorDict()
errors = ErrorList()
errors = form._errors.setdefault(NON_FIELD_ERRORS, errors)
form._errors['password'] = form.error_class(
[str(activation_result['msg'])])
response = viewHelp(request,
'standalone_homepage.html',
'extension',
'about_extension.html',
'TTAGIT Help - Google Browser Extension',
signinform=form)
return response
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def read(self, request):
"""
Returns a representation of the queryset.
The format depends on which responder (e.g. JSONResponder)
is assigned to this ModelResource instance. Usually called by a
HTTP request to the factory URI with method GET.
"""
request_user = basicauth_get_user_by_emailaddr(request)
if not request_user:
logevent(request, 'Note.read', 401,
{"requesting user:"******"autherror":
"Incorrect user/password combination"}))
qs_user = None
if request.GET.has_key("jid"):
## user has asked for only one note, yo.
qs_user = Note.objects.filter(owner=request_user,
jid=int(request.GET["jid"]))
else:
qs_user = Note.objects.filter(owner=request_user)
logevent(request, 'Note.read', 200)
return self.responder.list(request, qs_user)
def addFileRequiredError(self):
"""Appends a form error message indicating that this field is required.
"""
if not self._errors:
self._errors = ErrorDict()
self._errors["upload_of_work"] = self.error_class([DEF_NO_UPLOAD])
def field_errors(self):
""" Returns a dictionary containing only field-related errors. """
error_dict = copy.copy(self._errors)
if not error_dict:
error_dict = ErrorDict()
if NON_FIELD_ERRORS in error_dict:
del error_dict[NON_FIELD_ERRORS]
return error_dict
def test_clean(self):
fs = FormSetMixin()
form_a = Mock()
form_a.cleaned_data = {"DELETE": True}
form_a._errors = ErrorDict({"name": "That's not a valid name"})
form_b = Mock()
form_b.cleaned_data = {"name": "John"}
form_b._errors = ErrorDict()
form_c = Mock()
form_c.cleaned_data = {}
form_c._errors = ErrorDict({"name": "That's not a valid name"})
fs.forms = [form_a, form_b, form_c]
fs.clean()
self.assertEqual(form_a._errors, ErrorDict())
def full_clean(self):
if not self.find_enabled_value():
self.cleaned_data = {
'enabled': False,
}
self._errors = ErrorDict()
else:
return super(AccountForm, self).full_clean()
def clean(self):
"""
When cleaning, if the form is being deleted, any errors on it should be
ignored
"""
for form in self.forms:
# this form is being deleted, so overwrite the errors
if form.cleaned_data.get("DELETE"):
form._errors = ErrorDict()
def _errors(self):
if self.__errors is None:
error_dict = ErrorDict()
for f in self._forms:
error_dict[self._forms.index(f)] = f.errors
if self._nf_errors:
error_dict[NON_FIELD_ERRORS]=self._nf_errors
self.__errors = error_dict
return self.__errors
def full_clean(self):
"""
Like Django's but we don't delete cleaned_data on error.
"""
self._errors = ErrorDict()
if not self.is_bound: # Stop further processing.
return
self.cleaned_data = {}
# If the form is permitted to be empty, and none of the form data has
# changed from the initial data, short circuit any validation.
if self.empty_permitted and not self.has_changed():
return
self._clean_fields()
self._clean_form()
self._post_clean()
# Errors are for data-prudes
for field in self._errors.keys():
self.cleaned_data[field] = ''
self._errors = ErrorDict()
def _validate_file_size(request, form, klass):
# check whether file is too large
upload_limit = Preferences.objects.get(pk=1).max_data_size
if klass in (Data, Task) and 'file' in request.FILES:
if len(request.FILES['file']) > upload_limit:
form.errors['file'] = ErrorDict({
'':
_('File is too large! Must be smaller than %dMB!' %
(upload_limit / MEGABYTE))
}).as_ul()
def nice_errors(form, non_field_msg='General form errors'):
this_nice_errors = ErrorDict()
if isinstance(form, forms.BaseForm):
for field, errors in form.errors.items():
if field == NON_FIELD_ERRORS:
key = non_field_msg
else:
key = form.fields[field].label
this_nice_errors[key] = errors
return this_nice_errors
def render(self, context):
form = self.form.resolve(context, True)
hidden_fields_errors = ErrorDict()
for field in form.hidden_fields():
if field.errors:
hidden_fields_errors.update({field.name: field.errors})
context[self.as_var] = hidden_fields_errors
return ''
def full_clean(self):
"""Override the django implementation - we don't want to delete the
cleaned_data if the form is not valid.
"""
self._errors = ErrorDict()
if not self.is_bound: # Stop further processing.
return
self.cleaned_data = {}
self._clean_fields()
self._clean_form()
self._post_clean()
def clean(self):
cleaned_data = super(DeleteFormMixin, self).clean()
# If this object is set to be deleted, validation doesn't matter
# because the object will be delete anyway so remove all errors so it
# passes validation.
if self.cleaned_data.get('delete') is True:
self._errors = ErrorDict()
return cleaned_data
def modify_qd(self, qd, object_=None):
fqdn = qd.pop('fqdn', [''])[0]
domain = None
# if record_type not in ('PTR', 'NS', 'DOMAIN', 'SOA'):
try:
label, domain = ensure_label_domain(fqdn)
# If something goes bad latter on you must call prune_tree on
# domain. If you don't do this there will be a domain leak.
except ValidationError, e:
errors = ErrorDict()
errors['fqdn'] = e.messages
return None, errors
def modify_qd(self, qd, **kwargs):
domain_pk = qd.pop('domain', '')[0]
try:
domain = Domain.objects.get(pk=domain_pk)
qd['domain'] = str(domain.pk)
except Domain.DoesNotExist:
error_message = _("Could not find domain with pk "
"'{0}'".format(domain_pk))
errors = ErrorDict()
errors['domain'] = [error_message]
return None, errors
return qd, None
def error(self, request, status_code, error_dict=None):
"""
Renders error template (template name: error status code).
"""
if not error_dict:
error_dict = ErrorDict()
response = direct_to_template(request,
template = '%s/%s.html' % (self.template_dir, str(status_code)),
extra_context = { 'errors' : error_dict },
mimetype = self.mimetype)
response.status_code = status_code
return response
