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