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()] })