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
