def setprimary(request, **kwargs):
team_link = kwargs.get("team_link")
picture_id = kwargs["picture_id"]
account = get_object_or_404(Account, user=request.user)
team = team_link and team_control.get_or_404(team_link) or None
picture = get_object_or_404(Picture, id=picture_id)
prefix = team_link and "/%s" % team_link or ""
url = "%s/gallery/list/%s" % (prefix, picture.gallery.id)
if team:
assert_member(account, team)
if request.method == "POST":
form = Form(request.POST)
if form.is_valid():
control.setprimary(account, picture)
return HttpResponseRedirect(url)
else:
form = Form()
# TODO make template that shows the image being set!
args = {
"form" : form, "form_title" : _("SET_AS_PRIMARY_PICTURE"),
"cancel_url" : url
}
if team:
return rtr(team, None, request, "site/form.html", args)
else:
return render_response(request, "site/form.html", args)
def authorization_endpoint(request):
auth_code_generator = AuthorizationCodeGenerator(missing_redirect_uri)
try:
auth_code_generator.validate(request)
except AuthorizationError as authorization_error:
return auth_code_generator.make_error_redirect(authorization_error)
if request.method == 'GET':
return render(
request, authorization_template_name, {
'form':
Form(),
'client':
auth_code_generator.client,
'scopes':
auth_code_generator.valid_scope_objects,
'form_action':
update_parameters(
authorization_endpoint_uri,
auth_code_generator.get_request_uri_parameters(
as_dict=True)),
})
if request.method == 'POST':
form = Form(request)
if form.is_valid() and request.POST.get('user_action') == 'Accept':
return auth_code_generator.make_success_redirect()
else:
return auth_code_generator.make_error_redirect()
def bill_edit(request, id, template_name='membership/entity_edit.html'):
bill = get_object_or_404(Bill, id=id)
class Form(ModelForm):
class Meta:
model = Bill
exclude = ('billingcycle', 'reminder_count')
before = bill.__dict__.copy(
) # Otherwise save() (or valid?) will change the dict, needs to be here
if request.method == 'POST':
form = Form(request.POST, instance=bill)
if form.is_valid():
form.save()
after = bill.__dict__
log_change(bill, request.user, before, after)
messages.success(request,
unicode(_("Changes to bill %s saved.") % bill))
return redirect(
'bill_edit',
id) # form stays as POST otherwise if someone refreshes
else:
messages.error(request,
unicode(_("Changes to bill %s not saved.") % bill))
else:
form = Form(instance=bill)
logentries = bake_log_entries(bill.logs.all())
return render_to_response(template_name, {
'form': form,
'bill': bill,
'logentries': logentries
},
context_instance=RequestContext(request))
def remove(request):
conn = psycopg2.connect(database='formationdjango',
host='localhost',
user='******',
password='******')
if request.method == 'POST':
form = Form(request.POST)
if form.is_valid() and request.POST['select'][0]:
remove_row(conn, 'ex06_movies',
{'episode_nb': request.POST['select'][0]})
curr = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
form = Form()
try:
curr.execute("""SELECT * from ex06_movies""")
except Exception as e:
return HttpResponse("No data available")
response = curr.fetchall()
if response:
return render(request, 'ex06/remove.html', {
'data': response,
'form': form
})
else:
return HttpResponse("No data available")
def upload_file(request):
if request.method == 'POST':
if request.user.is_authenticated():
print "-------------------------upload file"
form = Form(request.POST, request.FILES)
if form.is_valid():
print "file valid"
print request.FILES
directory = request.POST['directory']
instance = UserFiles(user=request.user,
directory=directory,
file=request.FILES['file'])
if directory == '':
json_helper.update_file(
settings.MEDIA_ROOT + 'users/' +
str(request.user.username) + '/', instance.file.name,
settings.MEDIA_ROOT + 'users/' +
str(request.user.username) + '/' + instance.file.name)
else:
json_helper.update_file(
settings.MEDIA_ROOT + 'users/' +
str(request.user.username) + '/',
directory + '/' + instance.file.name,
settings.MEDIA_ROOT + 'users/' +
str(request.user.username) + '/' + directory + '/' +
instance.file.name)
instance.save()
json_helper.logger(settings.MEDIA_ROOT + 'log.txt',
request.user.username, 'updated file: ',
instance.file.name)
response = HttpResponse()
response.content = json.dumps(
json_helper.read_json(settings.MEDIA_ROOT + 'users/' +
str(request.user.username) +
'/file_list.txt'))
response['Content-Type'] = 'application/json'
response.status_code = 200
return response
else:
response = HttpResponse()
response.content = "User not authenticated"
response.status_code = 497
return response
else:
form = Form()
if request.user.is_authenticated:
documents = UserFiles.objects.filter(
user__username=request.user.username)
else:
documents = {}
return render_to_response('file_demo/upload_file.html', {
'documents': documents,
'form': form
},
context_instance=RequestContext(request))
def billingcycle_edit(request,
id,
template_name='membership/entity_edit.html'):
cycle = get_object_or_404(BillingCycle, id=id)
class Form(ModelForm):
is_paid_forced = False
class Meta:
model = BillingCycle
exclude = ('membership', 'start', 'end', 'sum', 'reference_number')
def disable_fields(self):
self.fields['is_paid'].required = False
if cycle.amount_paid() >= cycle.sum and cycle.is_paid:
self.fields['is_paid'].widget.attrs['disabled'] = 'disabled'
self.is_paid_forced = True
def clean_is_paid(self):
if self.is_paid_forced:
return cycle.is_paid
else:
return self.cleaned_data['is_paid']
before = cycle.__dict__.copy(
) # Otherwise save() (or valid?) will change the dict, needs to be here
if request.method == 'POST':
form = Form(request.POST, instance=cycle)
form.disable_fields()
if form.is_valid():
form.save()
after = cycle.__dict__
log_change(cycle, request.user, before, after)
messages.success(
request,
unicode(_("Changes to billing cycle %s saved.") % cycle))
return redirect(
'billingcycle_edit',
id) # form stays as POST otherwise if someone refreshes
else:
messages.error(request,
unicode(_("Changes to bill %s not saved.") % cycle))
else:
form = Form(instance=cycle)
form.disable_fields()
logentries = bake_log_entries(cycle.logs.all())
return render_to_response(template_name, {
'form': form,
'cycle': cycle,
'logentries': logentries
},
context_instance=RequestContext(request))
def remove(request):
form = Form()
if request.method == 'POST':
form = Form(request.POST)
if form.is_valid() and request.POST['select'][0]:
Movies.objects.filter(pk=request.POST['select'][0]).delete()
response = Movies.objects.all().order_by('episode_nb')
if response:
return render(request, 'ex05/remove.html', {
'data': response,
'form': form
})
else:
return HttpResponse("No data available")
def get_form(self, Form=None):
self.set_mongoadmin()
context = self.set_permissions_in_context({})
if not context['has_edit_permission']:
return HttpResponseForbidden(
"You do not have permissions to edit this content.")
self.document_type = getattr(self.models, self.document_name)
self.ident = self.kwargs.get('id')
try:
self.document = self.document_type.objects.get(pk=self.ident)
except self.document_type.DoesNotExist:
raise Http404
if Form is None:
Form = self.get_form_class()
self.form = Form()
if self.request.method == 'POST':
self.form = self.process_post_form('Your changes have been saved.')
else:
self.form = MongoModelForm(model=self.document_type,
instance=self.document).get_form()
return self.form
def report_detail(request, slug):
"""Render report detail or list of reports in case of wrong report slug is specified"""
data = {}
all_reports = {}
template = 'reporting/reports.html'
report = None
form = Form()
reports_date_init = True
try:
# Retrieving report name by slug specified in an URL
report = reporting.get_report(slug)(request)
except reporting.NoReportException:
pass
if report is not None:
form = report.form_class(request.POST or None)
if request.method == "POST" and form.is_valid():
if request.POST.get('generate', None):
data = report.generate(**form.cleaned_data)
reports_date_init = False
template = report.template_name
else:
# Wrong report slug is specified. rendering all the reports list
all_reports = [(slug, unicode(r.verbose_name))
for slug, r in reporting.all_reports()]
return direct_to_template(
request, template, {
'form': form,
'data': data,
'report': report,
'reports_date_init': reports_date_init,
'object_list': all_reports,
})
def get_payment_process_response(self, order, urls):
address = order.billing_address
payment = Payment(
order_number=order.identifier,
reference_number=order.reference_number[:20],
amount=str(int(order.taxful_total_price * 100)),
delivery_date=(order.order_date.date() +
datetime.timedelta(1)).strftime("%Y%m%d"),
return_url=urls["return"],
delayed_url=urls["return"],
cancel_url=urls["cancel"],
message=force_text(order),
contact=Contact(first_name=flatten_unicode(address.first_name),
last_name=flatten_unicode(address.last_name),
email=flatten_unicode(address.email),
phone=flatten_unicode(address.phone),
address=flatten_unicode(address.street),
postcode=address.postal_code,
postoffice=flatten_unicode(address.city),
country=address.country.alpha3))
form = Form()
for key, value in self._get_checkout_object().get_offsite_button_data(
payment).items():
form.fields[key] = CharField(initial=value, widget=HiddenInput)
html = TEMPLATE % {"form": form}
return HttpResponse(html)
def test_get_field_options_value(self):
unbound_field = ChoiceField()
field = BoundField(Form(initial={"field": "Value"}), unbound_field,
"field")
context = Context({"field": field})
self.TEMPLATE.render(context)
def simple_search(request):
"""Controlla form e crea ricerca semplice
Controlla che il contenuto del form sia valido e in caso affermativo redirige
alla pagina dei risultati, se no invoca una BadRequest
:param request: richiesta HTTP
:return: redirezione o HttpResponseBadRequest
"""
if request.method != 'POST':
return HttpResponseBadRequest(
'Impossibile fare richiesta GET su simple_search view')
elif request.POST['testo_ricerca'] == '':
return HttpResponseRedirect(reverse('attivita:index'))
form = Form(request.POST)
if form.is_valid():
if request.POST['testo_ricerca'] != '':
ricerca = RicercaSemplice(testo=request.POST['testo_ricerca'])
ricerca.save()
return HttpResponseRedirect(
reverse('search:simple_results', args=(ricerca.id, )))
print('Qualcosa è andato storto')
messages.error(request, "Errore nella compilazione form")
return HttpResponseRedirect(reverse('attivita:index'))
def test_modelform_saving(self):
Form = modelform_factory(TestModel, fields=('phone',))
f = Form({'phone_0': '415.123.4567', 'phone_1': '88'})
self.assertTrue(f.is_valid())
obj = f.save()
self.assertIsInstance(obj.phone, PhoneNumber)
self.assertEqual(str(obj.phone), '(415) 123-4567, press 88')
def post(self, request):
table = None
search_form = forms.CreatePersonSearchForm(request.POST)
# Dummy form for the submit button. Could be stripped out?
create_form = Form(request.POST, prefix='create')
if search_form.is_valid():
# Components of our search query
queryset = self.get_queryset(search_form)
table = datatables.CreateMatchTable(data=queryset, request=request)
# Store details for use by creation method
self.request.session['new_student'] = search_form.cleaned_data
if self.request.POST.get(
'action'
) == 'create' and 'new_student' in self.request.session:
student = self.create_student(
**self.request.session['new_student'])
del self.request.session['new_student']
messages.success(
request,
message='Record created. Please complete their information.')
return redirect(student.get_absolute_url(), {'new': True})
return render(request, 'student/new.html', {
'search_form': search_form,
'create_form': create_form,
'table': table
})
def get_search_form(self):
"""
Return list of form based on model
"""
magic_dico_form = self.get_dict_for_forms()
forms = []
initial = list(self.request.GET.lists())
for key, value in magic_dico_form.items():
form = Form()
model = value["model"]
if not value["fields"]:
continue
for field in value["fields"]:
formfield = get_formfield(model, field)
formfield.widget.attrs.update({'class': self.css_class})
form.fields.update({field: formfield})
initial_tmp = {}
for k, vals in initial:
tmp_list = k.split(model.__name__ + "-")
if len(tmp_list) == 2:
list_val_tmp = vals[0] if len(vals) == 1 else [
val for val in vals if val != ''
]
initial_tmp[tmp_list[-1]] = list_val_tmp
form.initial = initial_tmp
form.prefix = model.__name__
forms.append(form)
return sorted(forms, key=lambda form: form.prefix)
def search(request):
"""The search page."""
form = Form(request.GET, load_all=True)
# entries = form.search()
tags = []
blogs = []
# for entry in entries:
# if entry.model_name == 'tag':
# tags.append(entry)
# elif entry.model_name == 'entry' and entry.object.active:
# blogs.append(entry)
#
query = form.data['q']
#
static = get_assets("blog.header")
deployment = get_deployment()
attributes = {
'deployment': deployment,
'assets': static,
'blogs': blogs,
'tags': tags,
'query': query
}
return render(request, 'search.html', attributes)
def create(self, request):
positionFile = request.FILES.get('positionFile')
form = Form(request.POST)
portfolioName = form.data['portfolio']
positions = pd.read_excel(positionFile)
for i in positions.index:
#Skip empty quantity
if math.isnan(positions['Qty (Current)'][i]):
continue
stock, created = Stock.objects.update_or_create(
tick=positions["SecCode"][i],
defaults={
'name': positions['Security Desc'][i],
'lastprice': positions['Last Px'][i]
},
)
portfolio, created = Portfolio.objects.update_or_create(
name=portfolioName)
position, created = Position.objects.update_or_create(
portfolio=portfolio,
stock=stock,
defaults={
'openprice': positions['Open Px'][i],
'quantity': positions['Qty (Current)'][i]
})
content_type = positionFile.content_type
response = f'{content_type} is uploaded'
return Response(response)
def __init__(self, project, form=None):
self.project = project
self.form = form if form is not None else Form({})
self.objects = []
self.jobs = []
self.max_group_depth = 1
self.ns = None
def post(self, request):
form = CreateAuctionForm(request.POST)
currency = get_currency(request)
if form.is_valid():
# save the new auction
cleaned_data = form.cleaned_data
auction_title = cleaned_data['title']
auction_description = cleaned_data['description']
auction_min_price = float(cleaned_data['minimum_price'])
auction_deadline = cleaned_data['deadline']
auction_deadline_in_seconds = calendar.timegm(
auction_deadline.timetuple())
form = Form()
# open the confirmation form
return render(
request, 'confirmation.html', {
'form': form,
'auction_title': auction_title,
'auction_description': auction_description,
'auction_min_price': auction_min_price,
'auction_deadline': auction_deadline_in_seconds
})
else:
# form was invalid, need to send it back for the user to fix
return render(request, self.template_name, {
'form': form,
'currency': currency
})
def get(self, request, **kwargs):
if request.method == 'GET':
form = Form(request.GET)
if form.is_valid():
# Names
name1 = request.GET.get('inputName1')
name2 = request.GET.get('inputName2')
if not name1:
name1 = 'Noname1'
if not name2:
name2 = 'Noname2'
# Calculations
bdate1 = request.GET.get('inputDate1').split('-')
bdate1 = bdate1[2] + '.' + bdate1[1] + '.' + bdate1[0]
bdate2 = request.GET.get('inputDate2').split('-')
bdate2 = bdate2[2] + '.' + bdate2[1] + '.' + bdate2[0]
#
data = match_all(bdate1, bdate2)
data1 = data['p1p2']
data2 = data['p2p1']
items = list(data1.keys())
#
context = {
'name1': name1,
'name2': name2,
'items': ",".join(items),
'y1': ",".join([str(data1[i]) for i in items]),
'y2': ",".join([str(data2[i]) for i in items])
}
else:
context = None
return render(request, "match_engine1.html", context=context)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
# fill in the table of "changed fields"
context['changed_fields'] = []
changed_field_names = self.object.changed_fields.split()
for field in changed_field_names:
if (field == 'artist'):
#current = ' '.join(self.object.song.artist.all())
current = "\n".join(
list(a.name for a in self.object.song.artist.all()))
#new = ' '.join(self.object.artist.all())
new = "\n".join(list(a.name for a in self.object.artist.all()))
else:
current = getattr(self.object.song, field)
new = getattr(self.object, field)
context['changed_fields'].append({
'name': field,
'current': current,
'new': new,
})
# add a form for approve / reject
context['form'] = Form()
return context
def membership_edit(request,
id,
template_name='membership/membership_edit.html'):
membership = get_object_or_404(Membership, id=id)
class Form(ModelForm):
class Meta:
model = Membership
exclude = ('person', 'billing_contact', 'tech_contact',
'organization')
def clean_status(self):
return membership.status
def clean_approved(self):
return membership.approved
def disable_fields(self):
self.fields['status'].required = False
self.fields['status'].widget.attrs['disabled'] = 'disabled'
self.fields['approved'].required = False
self.fields['approved'].widget.attrs['disabled'] = 'disabled'
if request.method == 'POST':
if not request.user.has_perm('membership.manage_members'):
return HttpResponseForbidden(_("Permission manage required"))
form = Form(request.POST, instance=membership)
before = membership.__dict__.copy()
form.disable_fields()
if form.is_valid():
form.save()
after = membership.__dict__
log_change(membership, request.user, before, after)
return redirect(
'membership_edit',
id) # form stays as POST otherwise if someone refreshes
else:
form = Form(instance=membership)
form.disable_fields()
# Pretty print log entries for template
logentries = bake_log_entries(membership.logs.all())
return render_to_response(template_name, {
'form': form,
'membership': membership,
'logentries': logentries
},
context_instance=RequestContext(request))
def post(self, request, **kwargs):
form = Form(request.POST)
if 'autocomplete1' in request.POST: # Add user
if form.is_valid:
name = request.POST['nameAdd']
username = request.POST['usernameAdd']
gender = request.POST['genderAdd']
password = request.POST['passwordAdd']
place = request.POST['autocomplete1']
time = request.POST['timeAdd']
date = request.POST['dateAdd']
try:
user = User.objects.get(username=username)
messages.add_message(request, messages.ERROR,
'User with such name already exists')
except:
user = User()
user.first_name = name
user.username = username
user.set_password(password)
user.save()
person = Person()
person.name = name
person.bdate = date
person.btime = time
person.bplace = place
person.gender = gender
person.user = username
person.password = password
person.save()
elif 'autocomplete2' in request.POST: # Edit user
if form.is_valid:
name = request.POST['nameEdit']
username = request.POST['usernameEdit']
gender = request.POST['genderEdit']
password = request.POST['passwordEdit']
place = request.POST['autocomplete2']
time = request.POST['timeEdit']
date = request.POST['dateEdit']
user = User.objects.get(username=username)
user.first_name = name
user.username = username
user.set_password(password)
user.save()
person = Person.objects.get(user=username)
person.name = name
person.bdate = date
person.btime = time
person.bplace = place
person.gender = gender
person.user = username
person.password = password
person.save()
return redirect('/admin_panel')
def test_modelform_rendering(self):
Form = modelform_factory(TestModelOptional, fields=('phone',))
obj = TestModelOptional(phone='415 123 4567 x 88')
f = Form(instance=obj)
expected = '<tr><th><label for="id_phone_0">Phone:</label></th><td><input type="text" name="phone_0" ' \
'value="(415) 123-4567" size="13" id="id_phone_0" />\n\n ext. ' \
'<input type="text" name="phone_1" value="88" size="4" id="id_phone_1" /></td></tr>'
self.assertEqual(str(f), expected)
def add_item(request):
if request.method == 'POST':
form = Form(request.POST)
print(form.data.get("title"))
connector.add_list_elem(configurator.getKAppList(), form.data.get("title"), form.data.get("subtitle"))
return HttpResponseRedirect('./add_item')
else:
return render(request, 'smarttrash/add_item.html')
def create_list(request):
if request.method == 'POST':
form = Form(request.POST)
response_list = connector.create_list([{"color": form.data.get("color"), "title": form.data.get("title")}])
configurator.setKAppList(response_list[0].get("_id"))
return HttpResponseRedirect('./setup_list')
else:
return HttpResponseRedirect('./setup_list')
def __init__(self, user, submission, categorization):
assert not submission.revised
RootSubmissionIdBody.__init__(self, user, submission.assignment,
categorization)
super(RevisionSubmissionIdBody,
self).__init__(Form(), UrlNames.SUBMISSION_ID.name)
self.submission_id = submission.pk
def delete_entity(request):
if Form(request.POST).is_valid():
user = request.user
eid = request.POST.get('entity_id')
entity = Entity.objects.get(id__iexact=eid)
if entity and entity.user_id == user.id:
entity.delete()
return redirect('my_entities')
def new_form_options(title='', subtitle='', form=Form()):
options = dict()
options['page_title'] = title
options['page_subtitle'] = subtitle
options['page_submit'] = 'Continue'
options['page_cancel'] = 'Back'
options['page_form'] = form
return options
def quiz(request, *args, **kwargs):
if not request.user.is_authenticated:
return redirect('%s?next=%s' % (settings.LOGIN_URL, request.path))
quiz_object = Quiz.objects.get(**kwargs)
quiz_id = kwargs["id"]
if request.method == 'POST':
f = Form(request.POST)
ids = set()
for k, v in f.data.items():
if k == "csrfmiddlewaretoken":
continue
else:
ids.add(v)
kwargs = {"id__in": ids}
choices = Choice.objects.filter(**kwargs)
correct_choices = 0
for choice in choices:
if choice.correct:
correct_choices += 1
mark_kwargs = {"user": request.user.id, "quiz": quiz_id}
try:
exam_result = int(correct_choices / len(ids) * 100)
except ZeroDivisionError:
exam_result = 0
try:
mark = Mark.objects.get(**mark_kwargs)
mark.result = exam_result
except ObjectDoesNotExist:
mark = Mark(user=request.user,
quiz=quiz_object,
result=exam_result)
mark.save()
result = {
"correct_choices": correct_choices,
"total_questions": len(ids),
"mark": exam_result
}
return render(request, 'quizzes/result.html', result)
return render(
request, 'quizzes/take.html', {
'quiz':
quiz_object,
"questions": [{
"name": question.name,
"body": question.body,
"answers": question.answers.all()
} for question in quiz_object.questions.all()]
})
