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) messages.success(request, "The import was successfull.") return HttpResponseRedirect( urlresolvers.reverse('admin:tasks_task_changelist')) except Exception, e: from django.forms.util import ErrorList msg = "An Error occured. The import file was propably malformed.: %s" % str( e) form._errors["file"] = ErrorList([msg])
def move_node(self, node, target): try: # Reload object because tree attributes may be out of date node = node.__class__.objects.get(pk=node.pk) descendant_count = node.get_descendants().count() if node.parent != target: node.parent = target node.attach_user(self.user, change=True) node.save() self.success_count += 1 + descendant_count return node except InvalidMove as e: self.errors[NON_FIELD_ERRORS] = ErrorList(e) raise
def clean(self): cleaned_data = SetPasswordForm.clean(self) if 'new_password1' in cleaned_data: if (len(cleaned_data['new_password1']) < MIN_PASSWORD_LENGTH or len(cleaned_data['new_password1']) > MAX_PASSWORD_LENGTH): self._errors['new_password1'] = ErrorList([ 'New password must be between %d and %d characters long.' % (MIN_PASSWORD_LENGTH, MAX_PASSWORD_LENGTH) ]) del cleaned_data['new_password1'] if 'new_password2' in cleaned_data: del cleaned_data['new_password2'] return cleaned_data
def login(request): log_form = LoginForm(request.POST or None) if request.method == "POST" and log_form.is_valid(): username = log_form.cleaned_data["username"] password = log_form.cleaned_data["password"] user = auth.authenticate(username=username, password=password) if user is not None: auth.login(request, user) return HttpResponseRedirect("/") else: errors = log_form._errors.setdefault( django.forms.forms.NON_FIELD_ERRORS, ErrorList()) errors.append("Bad Username or password") return render_to_response("login.html", {"form": log_form}, RequestContext(request))
def handle_excel_file(file, model, form): """ This is the utility function that handles the actual uploading of each individual model instance. See the doc for kit.excel.upload.views.bulk_upload for the specific processing rules, or the in-line documentation here for a more detailed explanation. """ excel = file.read() try: workbook = open_workbook(file_contents=excel) worksheet = workbook.sheet_by_index(0) except: form.errors.setdefault('excel_file', ErrorList()) form.errors['excel_file'].append("Please upload a valid excel file.") return False try: attribute_typedef = parse_header_row(worksheet, model) except ValidationError, v: form.errors.setdefault('excel_file', ErrorList()) form.errors['excel_file'].append(v.messages[0]) return False
def clean(self): # We want an explicit error message for old accounts with a too # short password, see bug 1067673 for details. if ('password' in self.errors and 'password' in self.data and 1 < len(self.data['password']) < PasswordMixin.min_length): msg = _( 'As part of our new password policy, your password must ' 'be %s characters or more. Please update your password by ' '<a href="%s">issuing a password reset</a>.') % ( PasswordMixin.min_length, reverse('password_reset_form')) self._errors['password'] = ErrorList([mark_safe(msg)]) # Only clean the form (username and password) if recaptcha is ok. if 'recaptcha' in self.errors: return {} return super(AuthenticationForm, self).clean()
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 clean(self): """clean_address""" if self._errors: return self.cleaned_data cleaned_data = self.cleaned_data address = cleaned_data['address'] user = cleaned_data['user'] if user.is_superuser: error_msg = _('Super users do not use addresses') self._errors["address"] = ErrorList([error_msg]) del cleaned_data['address'] account = UserProfile.objects.get(user=user) if account.account_type == 2: if not DOM_RE.match(address): error_msg = _('provide a valid domain address') self._errors["address"] = ErrorList([error_msg]) del cleaned_data['address'] else: if not email_re.match(address): error_msg = _('provide a valid email address') self._errors["address"] = ErrorList([error_msg]) del cleaned_data['address'] return cleaned_data
def clean(self): password = self.cleaned_data.get("old_password", "").strip() new_password = self.cleaned_data.get("new_password", "").strip() new_password2 = self.cleaned_data.get("new_password2", "").strip() # check password from database user = authenticate(username=self.user.user.username, password=password) if user is None: self._errors["old_password"] = ErrorList( [u'Please input the corrected password!']) if self.cleaned_data.get("old_password", None) is not None: del self.cleaned_data["old_password"] # check newpassword twice if new_password != new_password2: self._errors["new_password2"] = ErrorList( [u'The twiced password\ cannot match!']) if self.cleaned_data.get("new_password2", None) is not None: del self.cleaned_data["new_password2"] return self.cleaned_data
def clean(self): cleaned_data = super(AddLdapGroupsForm, self).clean() groupname_pattern = cleaned_data.get("groupname_pattern") dn = cleaned_data.get("dn") if not dn: if groupname_pattern is not None and len(groupname_pattern) > 30: msg = _('Too long: 30 characters or fewer and not %s' ) % groupname_pattern errors = self._errors.setdefault('groupname_pattern', ErrorList()) errors.append(msg) raise forms.ValidationError(msg) return cleaned_data
def clean(self): data = self.cleaned_data #if not (data.get('link') or data.get('description')): # self._errors["link"] = ErrorList(["You must provide either a link or description"]) site = get_site() local_today = utc.localize(datetime.utcnow()).astimezone( site.tz).date() if data.has_key('start_date'): if (data['start_date'] < local_today) and ( (data['end_date'] == None) or (data['end_date'] < local_today)): self._errors["start_date"] = ErrorList( ["This event occurs in the past"]) return super(EventBasicsForm, self).clean()
def clean(self): """ Catches further validation errors before the save. """ cleaned_data = super(StopCallMeBackForm, self).clean() if self._errors: # if already in error => skip return cleaned_data event = event_registry.get_event(self.get_event_key())() try: event.get_log_code(case=self.case, **self.get_kwargs()) except ValueError as e: self._errors[NON_FIELD_ERRORS] = ErrorList([str(e)]) return cleaned_data
def check_block_type(self, content=None, section=None): block_type = self.cleaned_data['block_type'] module, classname = block_type.rsplit('.', 1) block_class = getattr(import_module(module), classname) self.block_class = block_class if issubclass(self.block_class, SectionBlock): if not section: self._errors['block_type'] = ErrorList([ _(u'You can not insert a section block from a view without section' ) ]) else: self.tie_render = section
def manage_promises(request, grad_slug): grad = get_object_or_404(GradStudent, slug=grad_slug) promises = Promise.objects.filter( student=grad).order_by('start_semester__name') if request.method == 'POST': form = PromiseForm(request.POST) if form.is_valid(): try: promise = promises.get( end_semester=form.cleaned_data['end_semester'], removed=False) except Promise.DoesNotExist: promise = None if promise != None: form._errors['end_semester'] = ErrorList( [u"A Promise for this semester already exists."]) else: promise = form.save(commit=False) promise.student = grad promise.save() messages.success(request, "Promise for %s sucessfully saved." % (grad)) l = LogEntry(userid=request.user.username, description="added promise of $%f for %s" % (promise.amount, grad.slug), related_object=promise) l.save() return HttpResponseRedirect( reverse('grad.views.manage_promises', kwargs={'grad_slug': grad.slug})) else: form = PromiseForm( initial={ 'student': grad, 'start_semester': Semester.get_semester(), 'end_semester': Semester.get_semester(), 'amount': '0.00' }) context = { 'grad': grad, 'form': form, 'promises': promises, } return render(request, 'grad/manage_promises.html', context)
def upload_create_resource_form(request, project, prefix='create_form'): """Form for creating a new resource.""" resource = None display_form = False if request.method == 'POST' and request.POST.get('create_resource', None): cr_form = CreateResourceForm(request.POST, request.FILES, prefix=prefix) if cr_form.is_valid(): name = cr_form.cleaned_data['name'] slug = slugify(name) # Check if we already have a resource with this slug in the db. try: Resource.objects.get(slug=slug, project=project) except Resource.DoesNotExist: pass else: # if the resource exists, modify slug in order to force the # creation of a new resource. slug = slugify(name) identifier = Resource.objects.filter( project=project, slug__icontains="%s_" % slug).count() + 1 slug = "%s_%s" % (slug, identifier) method = cr_form.cleaned_data['i18n_method'] content = content_from_uploaded_file(request.FILES) filename = filename_of_uploaded_file(request.FILES) rb = ResourceBackend() try: with transaction.commit_on_success(): rb.create(project, slug, name, method, project.source_language, content, user=request.user, extra_data={'filename': filename}) except ResourceBackendError, e: cr_form._errors['source_file'] = ErrorList([ e.message, ]) display_form = True else: display_form = False resource = Resource.objects.get(slug=slug, project=project) else: display_form = True
def login(request): logger = logging.getLogger('rid_agent.views.login') client_ip = handlers.GetRemoteIp(request) #If this is a GET request, render the login page and preserve any redirect info if request.method == 'GET': #Either redirect the user to the page they were trying to access, #or the default URL. if (request.GET is not None and 'next' in request.GET): next = request.GET['next'] else: next = settings.LOGIN_REDIRECT_URL form = forms.LoginForm(initial={'next': next}) logger.info('Login page accessed from %s with next=%s', client_ip, next) return render_to_response('auth/login.html', {'form': form}, context_instance=RequestContext(request)) #This is a POST request, meaning a login attempt. if request.method == 'POST': form = forms.LoginForm(request.POST) if not form.is_valid( ): #If the form isn't valid, render the login form again logger.debug('Login form invalid from %s', client_ip) return render_to_response('auth/login.html', {'form': form}, context_instance=RequestContext(request)) username = request.POST['username'] password = request.POST['password'] redirect_url = request.POST['next'] user = auth.authenticate(username=username, password=password) #attempt to auth the user logger.info('Login attempt for %s from %s.', username, client_ip) if user is not None and user.is_active: # Correct password, and the user is marked "active" auth.login(request, user) # Log in the user logger.info('Login successful for %s from %s. Redirecting to %s', username, client_ip, redirect_url) return HttpResponseRedirect( redirect_url) #Success, redirect to the 'next' page logger.info('Login failed for %s from %s', username, client_ip) form._errors['username'] = ErrorList(['Login Failed']) return render_to_response('auth/login.html', {'form': form}, context_instance=RequestContext(request)) #Shouldn't get here, but just in case render the default login page logger.warning( 'Rendering a page that logically shouldn\'t be rendered. Request came from %s.', client_ip) return render_to_response('auth/login.html', {'form': forms.LoginForm}, context_instance=RequestContext(request))
def login_user(request): form = LoginForm() if request.method == 'POST': form = LoginForm(request.POST) if form.is_valid(): password = form.cleaned_data['password'].encode('utf-8') username = form.cleaned_data['username'].strip() user = authenticate(username=username, password=password) if user and user.is_active: login(request, user) log_admin_action(request, 'logged in') config = read_config_file() if not config['api_password']: initial_setup(username, password) config = read_config_file() api = get_api(config) set_api_version(api) if api.backup(): log_admin_action(request, 'restoring from backup') subprocess.call([ '/opt/openmanage/bin/run_restore_omva.sh', ]) elif not config['groups']: create_initial_group() config_mgr_ = config_mgr.ConfigManager( config_mgr.default_config()) api = get_api(config_mgr_.config) subprocess.call([ '/opt/openmanage/bin/first_setup.sh', api.info()['brand_identifier'] ]) request.session['username'] = username return redirect(urllib.unquote(request.GET.get('next', '/'))) else: errors = form._errors.setdefault(NON_FIELD_ERRORS, ErrorList()) errors.append('Invalid username or password') return render_to_response('login.html', dict( form=form, request_login=True, ), 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 locals()
def clean(self): 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") == str(CHOICES_YES): if self.data.get("base_price_amount", "") == "": self.errors["base_price_amount"] = ErrorList( [_(u"This field is required.")]) return self.cleaned_data
def clean(self): cleaned_data = self.cleaned_data sector_id = cleaned_data.get('sector_id') ref_no = cleaned_data.get('ref_no') if sector_id: existing = Sector.objects.filter(ref_no=ref_no).exclude( id=sector_id).count() else: existing = Sector.objects.filter(ref_no=ref_no).count() if existing: self._errors['ref_no'] = ErrorList(['เลขสำนักนี้ซ้ำกับสำนักอื่น']) del cleaned_data['ref_no'] return cleaned_data
def clean(self): super(UserRegisterForm, self).clean() data = self.cleaned_data # Passwords p1 = data.get('password') p2 = data.get('password2') if p1 != p2: msg = _('The passwords did not match.') self._errors['password2'] = ErrorList([msg]) if p2: del data['password2'] return data
def form_valid(self, form): self.object = form.save(commit=False) election = get_object_or_404(Election, slug=self.kwargs['election_slug'], owner=self.request.user) self.object.election = election try: self.object.full_clean() except ValidationError: from django.forms.util import ErrorList form._errors["slug"] = ErrorList( [u"Ya tienes una categoria con ese slug."]) return super(CategoryCreateView, self).form_invalid(form) return super(CategoryCreateView, self).form_valid(form)
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 AssertionError as e: errors = self._errors.setdefault('groupname_pattern', ErrorList()) errors.append(str(e)) raise forms.ValidationError(str(e)) return cleaned_data
def clean(self): """ Validations for all fields or field validations which are dependent on each other can be defined here. """ name = self.cleaned_data.get('name') # Check that name must be alphanumeric & can only contains .(dot), -(hyphen), _(underscore). try: if not re.match(r'^[A-Za-z0-9\._-]+$', name): self._errors['name'] = ErrorList([ u"Name must be alphanumeric & can only contains .(dot), -(hyphen) and _(underscore)." ]) except Exception as e: logger.info(e.message) return self.cleaned_data
def clean(self): """ Validates the dates in the admin form. """ # Data that has passed validation. cleaned_data = self.cleaned_data pub_date = cleaned_data.get("pub_date") end_date = cleaned_data.get("end_date") if pub_date >= end_date: self._errors["end_date"] = ErrorList( [u"The end date must be after the pub date."]) del cleaned_data["end_date"] return cleaned_data
def index(request): if request.method == 'POST': form = LoginForm(request.POST) if form.is_valid(): cd = form.cleaned_data user = authenticate(username=cd['username'], password=cd['password']) if user is not None: login(request, user) return redirect('frontpage') else: form._errors['valid'] = ErrorList( [u"nie ma takiego użytkownika"]) else: form = LoginForm() return render(request, "index.html", {'form': form, 'user': request.user})
def clean(self): data = self.cleaned_data amouser = self.request.user # Passwords p1 = data.get("password") p2 = data.get("password2") if p1 or p2: if not amouser.check_password(data["oldpassword"]): msg = _("Wrong password entered!") self._errors["oldpassword"] = ErrorList([msg]) del data["oldpassword"] super(UserEditForm, self).clean() return data
def pay_form_add(request, id_=0, content=""): if request.method == 'POST': if request.session["is_admin"]: form = TransactionAdminForm(request.POST) else: form = TransactionForm(request.POST) if form.is_valid(): d = form.save(commit=False) user = request.user if not request.session["is_admin"]: # Если пользователь не АДМИН то agent = user.agent # агент берется с юзера d.agent = agent # Иначе агент берется с формы ret = d.add() if ret == -1: form._errors["summa"] = ErrorList( [u"Остаток диллера не позволяет оплатить эту сумму"]) return render(request, 'pay_form.html', {'form': form}) if id_ != 0: return HttpResponseRedirect('/proc/pay/%s/%s' % (id_, content)) else: return HttpResponseRedirect('/proc/pay/') else: return render(request, 'pay_form.html', {'form': form}) else: if content == "agent": form = TransactionAdminForm() form.fields["agent"].queryset = Agent.objects.filter(id=id_) elif content == "dealer": form = TransactionAdminForm() form.fields["agent"].queryset = Agent.objects.filter(dealer=id_) elif request.session["is_admin"]: form = TransactionAdminForm() elif request.session["user_type"] == "dealer": form = TransactionAdminForm() else: form = TransactionForm() #query="select o.* from proc_opservice o, proc_agent_opservices ao where o.id=ao.opservice_id and ao.agent_id = %s" % id_ #op = OpService.objects.raw(query)[0:] return render(request, 'pay_form.html', {'form': form})
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 _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