def user_setup(request): site_pk = _get_site_pk(request) current_site, administered_sites = _get_user_sites(request.user, site_pk) UserFormSet = formset_factory(UserForm, formset=BaseUserFormSet, extra=1) assigned_users = get_site_users(current_site) PageFormSet = formset_factory( _get_page_form_class(current_site), formset=BasePageFormSet, extra=1) page_formsets = {} if request.method == 'POST': user_formset = UserFormSet(request.POST, request.FILES, prefix='user-roles') user_pages = {} if user_formset.is_valid(): submitted_users = {} page_formsets_have_errors = False for user_form in user_formset.forms: user = user_form.cleaned_data.get('user', None) role = user_form.cleaned_data.get('role', None) if user is None and role is None: continue submitted_users[user] = role if not role.is_site_wide and _formset_available(request, user): page_formset = PageFormSet( request.POST, request.FILES, prefix=_get_page_formset_prefix(user)) if page_formset.is_valid(): user_pages[user] = _get_user_pages(page_formset) else: page_formsets[unicode(user.pk)] = page_formset page_formsets_have_errors = True if not page_formsets_have_errors: _update_site_users(request, current_site, assigned_users, submitted_users, user_pages) return _get_redirect(request, site_pk) else: initial_data = [ {'user': user, 'role': role, 'current_site': current_site} for user, role in assigned_users.iteritems()] user_formset = UserFormSet(initial=initial_data, prefix='user-roles') all_roles = Role.objects.all() role_pk_to_site_wide = dict((role.pk, role.is_site_wide) for role in all_roles) # so that the empty form template doesn't have an 'assign pages' link role_pk_to_site_wide[None] = True context = { 'opts': {'app_label': 'cmsroles'}, 'app_label': 'Cmsroles', 'administered_sites': administered_sites, 'current_site': current_site, 'user_formset': user_formset, 'page_formsets': page_formsets, 'user': request.user, 'role_pk_to_site_wide_js': [ (role.pk, 'true' if role.is_site_wide else 'false') for role in all_roles], 'role_pk_to_site_wide': role_pk_to_site_wide} return render_to_response('admin/cmsroles/user_setup.html', context, context_instance=RequestContext(request))
def test_formset_iteration(self): # Regression tests for #16455 -- formset instances are iterable ChoiceFormset = formset_factory(Choice, extra=3) formset = ChoiceFormset() # confirm iterated formset yields formset.forms forms = list(formset) self.assertEqual(forms, formset.forms) self.assertEqual(len(formset), len(forms)) # confirm indexing of formset self.assertEqual(formset[0], forms[0]) try: formset[3] self.fail('Requesting an invalid formset index should raise an exception') except IndexError: pass # Formets can override the default iteration order class BaseReverseFormSet(BaseFormSet): def __iter__(self): return reversed(self.forms) def __getitem__(self, idx): return super(BaseReverseFormSet, self).__getitem__(len(self) - idx - 1) ReverseChoiceFormset = formset_factory(Choice, BaseReverseFormSet, extra=3) reverse_formset = ReverseChoiceFormset() # confirm that __iter__ modifies rendering order # compare forms from "reverse" formset with forms from original formset self.assertEqual(str(reverse_formset[0]), str(forms[-1])) self.assertEqual(str(reverse_formset[1]), str(forms[-2])) self.assertEqual(len(reverse_formset), len(forms))
def send_meeting(request): if request.method == "POST": form = MeetingChangeForm(request.POST) formset = formset_factory(ReportChangeForm)(request.POST) if form.is_valid() and formset.is_valid(): meeting = form.save() for report_form in formset: report = report_form.save(commit=False) report.meeting = meeting report.save() for user in User.objects.all(): user.email_user( 'New HEP group meeting at %s'%meeting.meeting_date, """This message was auto generated because of new HEP group meeting, please don't reply on it. If you wish to report, send the email with your topic to Volodymyr Klavdiienko([email protected]). Then, after Volodymyr will add your report to meeting you will be able to attach file in your profile page(http://exp-hep.univ.kiev.ua/members/profile). """, '[email protected] ' ) return HttpResponseRedirect(reverse('members:meeting_change')) else: form = MeetingChangeForm() formset = formset_factory(ReportChangeForm) return render(request, 'members/meeting_change.html', {'form': form, 'formset': formset, })
def test_more_initial_than_max_num(self): # More initial forms than max_num will result in only the first max_num of # them to be displayed with no extra forms. initial = [ {'name': 'Gin Tonic'}, {'name': 'Bloody Mary'}, {'name': 'Jack and Coke'}, ] LimitedFavoriteDrinkFormSet = formset_factory(FavoriteDrinkForm, extra=1, max_num=2) formset = LimitedFavoriteDrinkFormSet(initial=initial) form_output = [] for form in formset.forms: form_output.append(str(form)) self.assertEqual('\n'.join(form_output), """<tr><th><label for="id_form-0-name">Name:</label></th><td><input type="text" name="form-0-name" value="Gin Tonic" id="id_form-0-name" /></td></tr> <tr><th><label for="id_form-1-name">Name:</label></th><td><input type="text" name="form-1-name" value="Bloody Mary" id="id_form-1-name" /></td></tr>""") # One form from initial and extra=3 with max_num=2 should result in the one # initial form and one extra. initial = [ {'name': 'Gin Tonic'}, ] LimitedFavoriteDrinkFormSet = formset_factory(FavoriteDrinkForm, extra=3, max_num=2) formset = LimitedFavoriteDrinkFormSet(initial=initial) form_output = [] for form in formset.forms: form_output.append(str(form)) self.assertEqual('\n'.join(form_output), """<tr><th><label for="id_form-0-name">Name:</label></th><td><input type="text" name="form-0-name" value="Gin Tonic" id="id_form-0-name" /></td></tr> <tr><th><label for="id_form-1-name">Name:</label></th><td><input type="text" name="form-1-name" id="id_form-1-name" /></td></tr>""")
def books_count(request, profile_id): if request.method == "POST": form = BooksCountForm(request.POST, request.FILES) if form.is_valid(): a = form.save() a.psrn = profile_id numberOfBooks = form.cleaned_data.get("booksPublished") a.save() form = FunkyBooksForm(request.POST, request.FILES) FunkyFormSet = formset_factory(FunkyBooksForm, extra=numberOfBooks, max_num=numberOfBooks) formset = FunkyFormSet() args = {} args.update(csrf(request)) args["formset"] = formset args["form"] = form args["profile_id"] = profile_id return render_to_response("books.html", args) else: FunkyFormSet = formset_factory(FunkyForm, extra=10, max_num=10) formset = FunkyFormSet() form = FunkyForm() args = {} args.update(csrf(request)) args["formset"] = formset args["form"] = form args["profile_id"] = profile_id return render_to_response("books_count.html", args)
def courses(request, profile_id): if request.method == "POST": FunkyFormSet = formset_factory(FunkyCourseForm, extra=3, max_num=3) formset = FunkyFormSet(request.POST) form = FunkyCourseForm(request.POST, request.FILES) for f_form in formset: if f_form.is_valid(): # found_user = Profile.objects.get(psrn=profile_id) a = f_form.save() a.psrn = profile_id a.save() raForm = ResearchAgencyCountForm() args = {} args.update(csrf(request)) args["form"] = raForm args["profile_id"] = profile_id return render_to_response("researchAgency_count.html", args) # return HttpResponseRedirect('/all/') else: FunkyFormSet = formset_factory(FunkyCourseForm, extra=10, max_num=10) formset = FunkyFormSet() form = FunkyCourseForm() args = {} args.update(csrf(request)) args["formset"] = formset args["form"] = form args["profile_id"] = profile_id return render_to_response("courses.html", args)
def profile_settings(request): """ Allows a user to update their own profile. """ user = request.user has_skills = Skill.objects.count() > 0 has_roles = Role.objects.count() > 0 SkillFormSet = formset_factory(SkillForm, formset=BaseSkillFormSet) user_skills = UserSkill.objects.filter(user=user).order_by('skill__name') skill_data = [{'skill': s.skill, 'proficiency': s.proficiency} for s in user_skills] LinkFormSet = formset_factory(LinkForm, formset=BaseLinkFormSet) user_links = UserLink.objects.filter(user=user).order_by('anchor') link_data = [{'anchor': l.anchor, 'url': l.url} for l in user_links] if request.method == 'POST': form = ProfileForm(request.POST, user=user) skill_formset = SkillFormSet(request.POST, prefix='skill') link_formset = LinkFormSet(request.POST, prefix='link') if form.is_valid() and skill_formset.is_valid() and link_formset.is_valid(): # Save user info user.first_name = form.cleaned_data['first_name'] user.last_name = form.cleaned_data['last_name'] user.bio = form.cleaned_data['bio'] user.roles = form.cleaned_data['roles'] user.save() save_skills(request, user, skill_formset) save_links(request, user, link_formset) user_links = UserLink.objects.filter(user=user) match_link_to_brand(user_links) site = get_current_site(request) messages.success(request, _('Your {} profile has been updated.'.format(site.name))) else: form = ProfileForm(user=user) skill_formset = SkillFormSet(initial=skill_data, prefix='skill') link_formset = LinkFormSet(initial=link_data, prefix='link') context = { 'form': form, 'skill_formset': skill_formset, 'link_formset': link_formset, 'has_skills': has_skills, 'has_roles': has_roles, } return render(request, 'accounts/profile_settings.html', context)
def createPapers(request, profile_id): if request.method == "POST": FunkyFormSet = formset_factory(FunkyForm, extra=3, max_num=3) formset = FunkyFormSet(request.POST) form = FunkyForm(request.POST, request.FILES) for f_form in formset: if f_form.is_valid(): # found_user = Profile.objects.get(psrn=profile_id) a = f_form.save() a.psrn = profile_id a.save() bform = BooksCountForm() args = {} args.update(csrf(request)) args["form"] = bform args["profile_id"] = profile_id return render_to_response("books_count.html", args) else: FunkyFormSet = formset_factory(FunkyForm, extra=10, max_num=10) formset = FunkyFormSet() form = FunkyForm() args = {} args.update(csrf(request)) args["formset"] = formset args["form"] = form args["profile_id"] = profile_id return render_to_response("createPapers.html", args)
def get_context_data(self, **kwargs): (host_eg, guest_eg) = self.get_egs() if host_eg: if not host_eg.group.is_admin(self.request.user): raise PermissionDenied kwargs['host_eg'] = host_eg context = super(EventHostInviteView, self).get_context_data(**kwargs) (dates, day_initial, meal_initial) = self.get_meals(host_eg, guest_eg, 'manage' in self.request.GET) day_factory = formset_factory(EventInviteDayForm, extra=0) meal_factory = formset_factory(EventInviteMealForm, extra=0) day_formset = day_factory(prefix='days', initial=day_initial) meal_formset = meal_factory(prefix='meals', initial=meal_initial) dates = self.get_meal_dates(dates, day_formset, meal_formset) context['invite_dates'] = dates context['day_formset'] = day_formset context['meal_formset'] = meal_formset context['host_eg'] = host_eg context['guest_eg'] = guest_eg context['manage'] = 'manage' in self.request.GET return context
def redirectView(request): MemberFormSet = formset_factory(wraps(reloadForm)(partial(reloadForm))) formTree = ProductSelectionForm(request.POST or None) if request.method == 'POST': #as I use formsets this is mandatory formset = MemberFormSet(request.POST) #make sure every form is validMemberFormSet = formset_factory(wraps(PostFormEFactor)(partial(PostFormEFactor))) if formset.is_valid(): #start retrieving formset data, which is all filter data except FancyTree for f in formset: cd = f.cleaned_data print("selection:") selection = cd.get('selection') print(selection) # #start getting some form skeletons now! ArticleFormSet = formset_factory(PostFormEFactor) formset = ArticleFormSet() formset = formset_factory(wraps(PostFormEFactor)(partial(PostFormEFactor)), extra=1) #updata dictionary for filter options: form skeletons selectionForm = formset_factory(wraps(reloadForm)(partial(reloadForm)), extra=1) dict = ({'selectionForm': selectionForm}) #now send some other forms to the filter interface dict.update({'formset':formset}) dict.update({'formTree': formTree}) #send signal for popup popup = 1 dict.update({'popup': popup}) return render(request,"ExioVisuals/distribution.html", dict)
def new_print_annotation(request, print_id): print_pid = '%s:%s' % (PID_PREFIX, print_id) from .forms import AnnotationForm, PersonForm, InscriptionForm PersonFormSet = formset_factory(PersonForm) InscriptionFormSet = formset_factory(InscriptionForm) if request.method == 'POST': form = AnnotationForm(request.POST) person_formset = PersonFormSet(request.POST, prefix='people') inscription_formset = InscriptionFormSet(request.POST, prefix='inscriptions') if form.is_valid() and person_formset.is_valid() and inscription_formset.is_valid(): if request.user.first_name: annotator = u'%s %s' % (request.user.first_name, request.user.last_name) else: annotator = u'%s' % request.user.username annotation = Annotation.from_form_data(print_pid, annotator, form.cleaned_data, person_formset.cleaned_data, inscription_formset.cleaned_data) try: response = annotation.save_to_bdr() logger.info('%s added annotation %s for %s' % (request.user.username, response['pid'], print_id)) return HttpResponseRedirect(reverse('specific_print', kwargs={'print_id': print_id})) except Exception as e: logger.error('%s' % e) return HttpResponseServerError('Internal server error. Check log.') else: inscription_formset = InscriptionFormSet(prefix='inscriptions') person_formset = PersonFormSet(prefix='people') form = AnnotationForm() image_link = zoom_viewer_url(print_pid) return render(request, 'rome_templates/new_annotation.html', {'form': form, 'person_formset': person_formset, 'inscription_formset': inscription_formset, 'image_link': image_link})
def schema_properties_mend(request, graph_slug, element_type): graph = get_object_or_404(Graph, slug=graph_slug) if not 'schema_changed_props' in request.session and \ not 'schema_deleted_props' in request.session: return redirect(reverse("schema_edit", args=[graph.slug])) changed_props = request.session.get('schema_changed_props', []) deleted_props = request.session.get('schema_deleted_props', []) ElementTypeChangedFormSet = formset_factory(ElementTypeChangedForm, extra=0) ElementTypeDeletedFormSet = formset_factory(ElementTypeDeletedForm, extra=0) changed_formset = ElementTypeChangedFormSet(initial=changed_props, prefix='changed') deleted_formset = ElementTypeDeletedFormSet(initial=deleted_props, prefix='deleted') if request.POST: data = request.POST.copy() if changed_props: changed_formset = ElementTypeChangedFormSet(data=data, initial=changed_props, prefix='changed') if deleted_props: deleted_formset = ElementTypeDeletedFormSet(data=data, initial=deleted_props, prefix='deleted') fixed = False if changed_props and deleted_props: if changed_formset.is_valid() and deleted_formset.is_valid(): for cdata in changed_formset.cleaned_data: mend_schema_property(element_type, cdata['option'], cdata['key'], cdata['new_key']) for cdata in deleted_formset.cleaned_data: mend_schema_property(element_type, cdata['option'], cdata['key']) request.session.pop('schema_changed_props') request.session.pop('schema_deleted_props') fixed = True elif changed_props and changed_formset.is_valid(): for cdata in changed_formset.cleaned_data: mend_schema_property(element_type, cdata['option'], cdata['key'], cdata['new_key']) request.session.pop('schema_changed_props') fixed = True elif deleted_props and deleted_formset.is_valid(): for cdata in deleted_formset.cleaned_data: mend_schema_property(element_type, cdata['option'], cdata['key']) request.session.pop('schema_deleted_props') fixed = True if fixed: return redirect(reverse("schema_edit", args=[graph.slug])) return render_to_response('schemas_properties_mend.html', {"graph": graph, "item_type_label": _("Type"), "element_type": element_type, "changed_formset": changed_formset, "deleted_formset": deleted_formset, "changed_props": changed_props, "deleted_props": deleted_props}, context_instance=RequestContext(request))
def __init__(self, *args, **kwargs): super(RPMOverrideFormView, self).__init__(*args, **kwargs) self.checkbox_form_factory = formset_factory(ComposeRPMDisableForm, extra=0) self.override_form_factory = formset_factory(OverrideRPMForm, extra=0) self.variant_form_factory = formset_factory(VariantArchForm, extra=1) self.override_v_form_factory = formset_factory(OverrideRPMForm, extra=0)
def researchAgency(request, profile_id): if request.method == "POST": FunkyFormSet = formset_factory(FunkyResearchAgencyForm, extra=3, max_num=3) formset = FunkyFormSet(request.POST) form = FunkyResearchAgencyForm(request.POST, request.FILES) for f_form in formset: if f_form.is_valid(): # found_user = Profile.objects.get(psrn=profile_id) a = f_form.save() a.psrn = profile_id a.save() # form = FunkyForm(request.POST,request.FILES) # FunkyFormSet = formset_factory(FunkyBooksForm,extra=numberOfBooks, max_num=numberOfBooks) # formset = FunkyFormSet() # args = {} # args.update(csrf(request)) # args['form'] = bform # args['profile_id'] = profile_id # return render_to_response('books_count.html',args) return HttpResponseRedirect("/all/") else: FunkyFormSet = formset_factory(FunkyResearchAgencyForm, extra=10, max_num=10) formset = FunkyFormSet() form = FunkyResearchAgencyForm() args = {} args.update(csrf(request)) args["formset"] = formset args["form"] = form args["profile_id"] = profile_id return render_to_response("researchAgency.html", args)
def researchAgency_count(request, profile_id): if request.method == "POST": form = ResearchAgencyCountForm(request.POST, request.FILES) if form.is_valid(): a = form.save() a.psrn = profile_id numberOfGrants = form.cleaned_data.get("grants") print numberOfGrants a.save() form = FunkyCourseForm(request.POST, request.FILES) FunkyFormSet = formset_factory(FunkyResearchAgencyForm, extra=numberOfGrants, max_num=numberOfGrants) formset = FunkyFormSet() args = {} args.update(csrf(request)) args["formset"] = formset args["form"] = form args["profile_id"] = profile_id return render_to_response("researchAgency.html", args) else: FunkyFormSet = formset_factory(FunkyForm, extra=10, max_num=10) formset = FunkyFormSet() form = FunkyForm() args = {} args.update(csrf(request)) args["formset"] = formset args["form"] = form args["profile_id"] = profile_id return render_to_response("researchAgency_count.html", args)
def __init__(self, request): self.batchpath = request.GET.get('batchpath') or request.POST.get('batchpath') or DEFAULT_BATCH_PATH self.batch = Batch(self.batchpath) self.ArtistFormSet = formset_factory(ArtistForm, formset=DataFormSet, extra=0) self.LabelFormSet = formset_factory(LabelForm, formset=DataFormSet, extra=0) self.ReleaseFormSet = formset_factory(ReleaseForm, formset=DataFormSet, extra=0) self.bad_deliveries = list(self.batch.bad_deliveries())
def change_view(self, request, object_id, form_url='', extra_context=None): if request.method == 'POST': res = formset_factory(RadioElementForm, formset=RadioElementFormSet) rs = res(request.POST) rs.save() return HttpResponseRedirect(reverse('admin:geoforms_radioelementmodel_changelist')) else: initial_data = [] question_data = {'question': []} radioelement = RadioElementModel.objects.get(id = object_id) for i, lang in enumerate(settings.LANGUAGES): html = getattr(radioelement,'html_%s' % lang[0]) if html == None: html = getattr(radioelement,'html_%s' % settings.LANGUAGES[0][0]) soup = BeautifulSoup(html) question_data['question'].append(soup.p.text) if soup.find(attrs={'data-random': 'true'}): question_data['randomize'] = True labels = soup.find_all('label') for j, label in enumerate(labels): if i == 0: initial_data.append({u'label': [label.text.strip()]}) else: initial_data[j]['label'].append(label.text.strip()) return super(RadioElementAdmin, self).change_view(request, object_id, form_url = '', extra_context = { 'current_app': self.admin_site.name, 'form': QuestionForm(initial = question_data), 'formset': formset_factory(RadioElementForm, extra = 0)(initial = initial_data)})
def buildForm(resource={}): fields = {} try: fields = {'name': resource[str(ns['skos']['prefLabel'])][0]['value']} except: pass #TODO: find better way to make empty form fields when there is no data try: fields['firstName'] = resource[str(ns['foaf']['givenName'])][0]['value'] except: pass try: fields['lastName']= resource[str(ns['foaf']['familyName'])][0]['value'] except: pass altLabel = str(ns['skos']['altLabel']) hiddenLabel = str(ns['skos']['hiddenLabel']) initial = [] if (altLabel in resource): for variant in resource[altLabel]: initial.append({'variant':variant['value'], 'isHidden':False}) if (hiddenLabel in resource): for variant in resource[hiddenLabel]: initial.append({'variant':variant['value'], 'isHidden':True}) VariantFormSet = formset_factory(VariantForm, extra=0, formset=BaseVariantFormSet) else: VariantFormSet = formset_factory(VariantForm, extra=1, formset=BaseVariantFormSet) variantForm = VariantFormSet(initial = initial) form = ResourceForm(fields) return {'form':form, 'variants':variantForm}
def test_more_initial_than_max_num(self): # More initial forms than max_num now results in all initial forms # being displayed (but no extra forms). This behavior was changed # from max_num taking precedence in the patch for #20084 initial = [ {'name': 'Gin Tonic'}, {'name': 'Bloody Mary'}, {'name': 'Jack and Coke'}, ] LimitedFavoriteDrinkFormSet = formset_factory(FavoriteDrinkForm, extra=1, max_num=2) formset = LimitedFavoriteDrinkFormSet(initial=initial) form_output = [] for form in formset.forms: form_output.append(str(form)) self.assertHTMLEqual('\n'.join(form_output), """<tr><th><label for="id_form-0-name">Name:</label></th><td><input id="id_form-0-name" name="form-0-name" type="text" value="Gin Tonic" /></td></tr> <tr><th><label for="id_form-1-name">Name:</label></th><td><input id="id_form-1-name" name="form-1-name" type="text" value="Bloody Mary" /></td></tr> <tr><th><label for="id_form-2-name">Name:</label></th><td><input id="id_form-2-name" name="form-2-name" type="text" value="Jack and Coke" /></td></tr>""") # One form from initial and extra=3 with max_num=2 should result in the one # initial form and one extra. initial = [ {'name': 'Gin Tonic'}, ] LimitedFavoriteDrinkFormSet = formset_factory(FavoriteDrinkForm, extra=3, max_num=2) formset = LimitedFavoriteDrinkFormSet(initial=initial) form_output = [] for form in formset.forms: form_output.append(str(form)) self.assertHTMLEqual('\n'.join(form_output), """<tr><th><label for="id_form-0-name">Name:</label></th><td><input type="text" name="form-0-name" value="Gin Tonic" id="id_form-0-name" /></td></tr> <tr><th><label for="id_form-1-name">Name:</label></th><td><input type="text" name="form-1-name" id="id_form-1-name" /></td></tr>""")
def test_max_num_zero(self): # If max_num is 0 then no form is rendered at all, regardless of extra, # unless initial data is present. (This changed in the patch for bug # 20084 -- previously max_num=0 trumped initial data) LimitedFavoriteDrinkFormSet = formset_factory(FavoriteDrinkForm, extra=1, max_num=0) formset = LimitedFavoriteDrinkFormSet() form_output = [] for form in formset.forms: form_output.append(str(form)) self.assertEqual('\n'.join(form_output), "") # test that initial trumps max_num initial = [ {'name': 'Fernet and Coke'}, {'name': 'Bloody Mary'}, ] LimitedFavoriteDrinkFormSet = formset_factory(FavoriteDrinkForm, extra=1, max_num=0) formset = LimitedFavoriteDrinkFormSet(initial=initial) form_output = [] for form in formset.forms: form_output.append(str(form)) self.assertEqual('\n'.join(form_output), """<tr><th><label for="id_form-0-name">Name:</label></th><td><input id="id_form-0-name" name="form-0-name" type="text" value="Fernet and Coke" /></td></tr> <tr><th><label for="id_form-1-name">Name:</label></th><td><input id="id_form-1-name" name="form-1-name" type="text" value="Bloody Mary" /></td></tr>""")
def invitation_inscription(request): #TODO # A REVOIR CRADE user = request.user if user.get_profile().Finished == False : Caracs = Carac.objects.all() Skills = Skill.objects.all() Items = Item.objects.all() initial = [] for carac in Caracs : initial.append({'carac': carac.Nom,'id':carac.id}) CaracFormSet = formset_factory(CaracForm, extra=0) CaracFormSet = CaracFormSet(prefix='carac',initial=initial) initial = [] # algo de skills a revoir pour le classement for skill in Skills : initial.append({'skill': skill.Nom,'id':skill.id}) SkillFormSet = formset_factory(SkillForm, extra=0) SkillFormSet = SkillFormSet(prefix='skill',initial=initial) initial = [] for item in Items : initial.append({'item': item.Nom,'id':item.id}) ItemFormSet = formset_factory(ItemForm, extra=0) ItemFormSet = ItemFormSet(prefix='item',initial=initial) print CaracFormSet.management_form formJack = JackRegisterForm() return render_to_response('invitinscription.html',{"CaracFormSet":CaracFormSet,'SkillFormSet':SkillFormSet,'ItemFormSet':ItemFormSet,'formJack':formJack},RequestContext(request)) else : return HttpResponseRedirect('../')
def post(self, request, pk, **kwargs): self.object = self.get_object() ruleset_id = self.object.id class RuleFormWithRuleset(RuleForm): def clean(self): # HACK! How to add ruleset info to extra fields in a meaningful way? cleaned_data = super(RuleForm, self).clean() if "ruleset" not in cleaned_data and len(self._errors.get("ruleset", [])) == 1 and self._errors["ruleset"][0] == u"This field is required.": cleaned_data["ruleset"] = RuleSet.objects.get(pk=ruleset_id) del self._errors["ruleset"] for field in ("insert", "remove", "where"): self.cleaned_data[field] = _normalize_quotes(self.cleaned_data[field]) return cleaned_data ruleset_form = modelform_factory(RuleSet)(request.POST, instance=self.object) if ruleset_form.is_valid(): ruleset_form.save() formset = formset_factory(RuleFormWithRuleset, formset=BaseModelFormSet, can_delete=True) formset.model = Rule formset = formset(request.POST, request.FILES, queryset=self.object.rules.all()) if formset.is_valid(): formset.save() formset = formset_factory(RuleForm, formset=BaseModelFormSet, can_delete=True) formset.model = Rule formset = formset(queryset=self.object.rules.all()) return self.render_to_response(self.get_context_data(formset=formset, ruleset_form=ruleset_form))
def submit_recipe(request): ''' Handle a submitted recipe form ''' print request.POST HoeveelheidFormset = formset_factory(HoeveelheidForm) ImageFormset = formset_factory(ImageForm) if request.method=='POST' and 'submit_recipe' in request.POST: recept_form = ReceptForm(request.POST, request.FILES) hoeveelheid_formset = HoeveelheidFormset(request.POST) image_formset = ImageFormset(request.POST, request.FILES, prefix="image_form") # Check if the forms are valid, and add the recipe. Redirect to home page # afterwards if recept_form.is_valid(): if hoeveelheid_formset.is_valid(): data = recept_form.cleaned_data hoeveelheid_data = hoeveelheid_formset.cleaned_data if request.POST['pk']=="-1": recept = Recept() else: recept = Recept.objects.get(pk=request.POST['pk']) # Remove present doel and hoeveelheden, to avoid duplicates, wrong information Hoeveelheid.objects.filter(recept=recept).delete() for doel in recept.doel.all(): recept.doel.remove(doel) recept.naam = data['naam'] recept.user = request.user recept.bereidingstijd = data['bereidingstijd'] recept.aantal_personen = data['aantal_personen'] recept.bereiding = data['bereiding'] recept.seizoen = data['seizoen'] recept.vegetarisch = data['vegetarisch'] # Saving the recipe, before adding relations recept.save() if image_formset.is_valid(): for (i, f) in enumerate(request.FILES.keys()): foto = Foto.objects.create(image=request.FILES[f], naam=data['naam']+'image_' + str(i)) recept.fotos.add(foto) if 'doel' in request.POST: recept.doel.add(request.POST['doel']) for h_data in hoeveelheid_data: try: h = Hoeveelheid.objects.create(hoeveelheid=h_data['hoeveelheid'], recept=recept, ingredient=h_data['ingredient']) except: continue return redirect('/') else: # TODO: Return some useful error message. pass else: recept_form = ReceptForm() hoeveelheid_formset = HoeveelheidFormset() image_formset = ImageFormset(prefix="image_form") return toevoegen(request, recept_form=recept_form, hoeveelheid_formset=hoeveelheid_formset, image_formset=image_formset)
def recipe_edit(request, recipe_id): recipe = get_object_or_404(Recipe, pk=recipe_id) for ingredient in recipe.ingredient_set.all(): get_object_or_404(Ingredient, pk=ingredient.id) for instruction in recipe.instruction_set.all(): get_object_or_404(Instruction, pk=instruction.id) # if this is a POST request we need to process the form data ingredientformset = formset_factory(AddIngredientForm, can_delete = True, extra = 0) instructionformset = formset_factory(AddInstructionForm, can_delete = True, extra = 0) extraingredientformset = formset_factory(AddIngredientForm, can_delete = True) extrainstructionformset = formset_factory(AddInstructionForm, can_delete = True) if request.method == "POST": recipeform = AddRecipeForm(request.POST, instance=recipe) ingrformset = ingredientformset(request.POST, request.FILES, prefix = 'ingredients', initial=recipe.ingredient_set.all().values()) instrucformset = instructionformset(request.POST, request.FILES, prefix = 'instructions', initial=recipe.instruction_set.all().values()) extraingrformset = extraingredientformset(request.POST, request.FILES, prefix = 'extra_ingredients') extrainstrucformset = extrainstructionformset(request.POST, request.FILES, prefix = 'extra_instructions') if recipeform.is_valid() and ingrformset.is_valid() and instrucformset.is_valid() and extraingrformset.is_valid() and extrainstrucformset.is_valid(): # Prepare the ingredient and instruction models, but don't commit it to the database just yet. # Add the recipe ForeignKey by saving the secondary form we setup savedrecipe = recipeform.save() for ingrform in ingrformset: ingredient = ingrform.save(commit=False) ingredient.recipe = savedrecipe ingredient.save() for ingrform in extraingrformset: ingredient = ingrform.save(commit=False) ingredient.recipe = savedrecipe ingredient.save() for instrucform in instrucformset: instruction = instrucform.save(commit = False) instruction.recipe = savedrecipe instruction.save() for instrucform in extrainstrucformset: instruction = instrucform.save(commit = False) instruction.recipe = savedrecipe instruction.save() # redirect to a new URL: return HttpResponseRedirect(reverse('addrecipe:thank', args=(savedrecipe.id,))) else: recipeform = AddRecipeForm(instance=recipe) ingrformset = ingredientformset(prefix = 'ingredients', initial=recipe.ingredient_set.all().values()) instrucformset = instructionformset(prefix = 'instructions', initial=recipe.instruction_set.all().values()) extraingrformset = extraingredientformset(prefix = 'extra_ingredients') extrainstrucformset = extrainstructionformset(prefix = 'extra_instructions') return render(request, 'addrecipe/post_edit.html', {'recipeform': recipeform, 'ingrformset' : ingrformset, 'instrucformset' : instrucformset , 'extra_ingredients' : extraingrformset, 'extra_instructions' : extrainstrucformset, 'recipe' : recipe})
def subscribe(request): if request.method != 'POST': response = HttpResponseNotAllowed('Method not allowed') response['Accept'] = 'POST' return response if not request.user.is_authenticated(): return redirect(reverse('login') + '?from=bookmarklet') if 'source' in request.POST and 'html' in request.POST: SubscriptionFormSet = formset_factory(SubscriptionForm, extra=0) xml = lxml.html.fromstring(request.POST['html']) xml.make_links_absolute(request.POST['source']) # lxml FTW links = xml.xpath(('//link[@type="application/atom+xml" or ' '@type="application/rss+xml"]')) parsed_links = [] for link in links: parsed_links.append({ 'url': link.get('href'), 'name': link.get('title'), 'subscribe': True, }) formset = SubscriptionFormSet(initial=parsed_links) cats = [(str(c.pk), c.name) for c in request.user.categories.all()] for form in formset: form.fields['category'].choices = cats return render(request, 'feeds/bookmarklet_subscribe.html', {'formset': formset, 'source': request.POST['source']}) else: response = manual_csrf_check(request) if response is not None: return response SubscriptionFormSet = formset_factory(SubscriptionForm, extra=0) formset = SubscriptionFormSet(data=request.POST) cats = [(str(c.pk), c.name) for c in request.user.categories.all()] for form in formset: form.fields['category'].choices = cats if formset.is_valid(): created = 0 for form in formset: if form.cleaned_data['subscribe']: category = request.user.categories.get( pk=form.cleaned_data['category'], ) category.feeds.create(name=form.cleaned_data['name'], url=form.cleaned_data['url']) created += 1 if created == 1: message = _('1 feed has been added') else: message = _('%s feeds have been added') % created messages.success(request, message) return redirect(reverse('feeds:home')) else: return render(request, 'feeds/bookmarklet_subscribe.html', {'formset': formset})
def post(self,request,contact_id): class RequiredFormSet(BaseFormSet): def __init__(self, *args, **kwargs): super(RequiredFormSet, self).__init__(*args, **kwargs) for form in self.forms: form.empty_permitted = False tipo_alarma = int(self.request.POST['tipo_alarma']) if tipo_alarma==1 : contact = get_object_or_404(AlarmaHumo, pk=contact_id) alarm_form_set = formset_factory(AlarmaHumoForm, extra=0, max_num=10, formset=RequiredFormSet) elif tipo_alarma==2: contact = get_object_or_404(AlarmaEstado, pk=contact_id) alarm_form_set = formset_factory(AlarmaEstado2Form, extra=0, max_num=10, formset=RequiredFormSet) elif tipo_alarma==3: contact = get_object_or_404(AlarmaAcceso, pk=contact_id) alarm_form_set = formset_factory(AlarmaAccesoForm, extra=0, max_num=10, formset=RequiredFormSet) elif tipo_alarma==4: contact = get_object_or_404(AlarmaEstado, pk=contact_id) alarm_form_set = formset_factory(AlarmaEstadoForm, extra=0, max_num=10, formset=RequiredFormSet) alarma_formset = alarm_form_set(request.POST, request.FILES, instance=contact) sensor_id = self.request.POST.get('sensor_select',False) nivel_id = self.request.POST.get('nivel_select',False) if alarma_formset.is_valid(): if sensor_id != '0': set_form_data() for form in alarma_formset.forms: alarma = form.save(commit=False) sensor = Sensor.objects.all().filter(id = sensor_id) alarma.sensor = sensor[0] alarma.nivel_alarma = nivel_id self.set_data_alarma(tipo_alarma,alarma) alarma.save() else: error_sensor= '* This field is required.' i = alarmas.Alarma() sensores = i.consul_elementos_sensor( tipo_sensor = tipo_alarma) return render_to_response(self.template_name, locals(), RequestContext(request)) else: i = alarmas.Alarma() sensores = i.consul_elementos_sensor( tipo_sensor = tipo_alarma) return render_to_response(self.template_name, locals(), RequestContext(request)) return HttpResponseRedirect('../')
def list(request): # This class is for list type of dynamic problems in QBank class RequiredFormSet(BaseFormSet): def __init__(self, *args, **kwargs): super(RequiredFormSet, self).__init__(*args, **kwargs) for form in self.forms: form.empty_permitted = True VariableFormSet = formset_factory(VariableForm, max_num = 10, formset = RequiredFormSet) HintFormSet = formset_factory(HintForm, max_num = 10, formset = RequiredFormSet) #ChoiceFormSet = formset_factory(ChoiceForm, max_num = 10, formset = RequiredFormSet) if request.method == 'POST': # If the form has been submitted... problem_form = ListProblemForm(request.POST) problem_template_form = ProblemTemplateForm(request.POST, prefix='template') answer_form = AnswerForm(request.POST, prefix='answer') variable_formset = VariableFormSet(request.POST,request.FILES, prefix='variables') hint_formset = HintFormSet(request.POST, request.FILES, prefix='hints') #choice_formset = ChoiceFormSet(request.POST, request.FILES, prefix='choices') if problem_form.is_valid() and problem_template_form.is_valid() and variable_formset.is_valid() and hint_formset.is_valid() and answer_form.is_valid(): problem = problem_form.save() problem_template = problem_template_form.save(commit = False) problem_template.problem = problem problem_template.save() answer = answer_form.save(commit = False) answer.problem = problem answer.save() for form in variable_formset.forms: variable = form.save(commit = False) variable.problem = problem variable.save() # Redirect to a 'success' page for form in hint_formset.forms: hint = form.save(commit = False) hint.problem = problem hint.save() return HttpResponseRedirect('/qbank/problems/') else: problem_form = ListProblemForm() problem_template_form = ProblemTemplateForm(prefix='template') answer_form = AnswerForm(prefix='answer') variable_formset = VariableFormSet(prefix='variables') #choice_formset = ChoiceFormSet(prefix='choices') hint_formset = HintFormSet(prefix='hints') c = {'problem_form' : problem_form, 'problem_template_form' : problem_template_form, 'answer_form': answer_form, 'variable_formset' : variable_formset, #'choice_formset': choice_formset, 'hint_formset' : hint_formset, } c.update(csrf(request)) return render_to_response('list.html', c)
def get_post_formsets(self, request): formsets = super(EventHostRegisterView, self).get_post_formsets(request) GroupHostFormset = formset_factory(EventGroupHostForm, extra=0) FeaturesFormset = formset_factory(EventGroupHostFeaturesForm, extra=0) formsets['grouphost_formset'] = GroupHostFormset(request.POST, prefix='grouphost') formsets['features_formset'] = FeaturesFormset(request.POST, prefix='features') return formsets
def test_limiting_max_forms(self): # Limiting the maximum number of forms ######################################## # Base case for max_num. # When not passed, max_num will take its default value of None, i.e. unlimited # number of forms, only controlled by the value of the extra parameter. LimitedFavoriteDrinkFormSet = formset_factory(FavoriteDrinkForm, extra=3) formset = LimitedFavoriteDrinkFormSet() form_output = [] for form in formset.forms: form_output.append(str(form)) self.assertEqual( "\n".join(form_output), """<tr><th><label for="id_form-0-name">Name:</label></th><td><input type="text" name="form-0-name" id="id_form-0-name" /></td></tr> <tr><th><label for="id_form-1-name">Name:</label></th><td><input type="text" name="form-1-name" id="id_form-1-name" /></td></tr> <tr><th><label for="id_form-2-name">Name:</label></th><td><input type="text" name="form-2-name" id="id_form-2-name" /></td></tr>""", ) # If max_num is 0 then no form is rendered at all. LimitedFavoriteDrinkFormSet = formset_factory(FavoriteDrinkForm, extra=3, max_num=0) formset = LimitedFavoriteDrinkFormSet() form_output = [] for form in formset.forms: form_output.append(str(form)) self.assertEqual("\n".join(form_output), "") LimitedFavoriteDrinkFormSet = formset_factory(FavoriteDrinkForm, extra=5, max_num=2) formset = LimitedFavoriteDrinkFormSet() form_output = [] for form in formset.forms: form_output.append(str(form)) self.assertEqual( "\n".join(form_output), """<tr><th><label for="id_form-0-name">Name:</label></th><td><input type="text" name="form-0-name" id="id_form-0-name" /></td></tr> <tr><th><label for="id_form-1-name">Name:</label></th><td><input type="text" name="form-1-name" id="id_form-1-name" /></td></tr>""", ) # Ensure that max_num has no effect when extra is less than max_num. LimitedFavoriteDrinkFormSet = formset_factory(FavoriteDrinkForm, extra=1, max_num=2) formset = LimitedFavoriteDrinkFormSet() form_output = [] for form in formset.forms: form_output.append(str(form)) self.assertEqual( "\n".join(form_output), """<tr><th><label for="id_form-0-name">Name:</label></th><td><input type="text" name="form-0-name" id="id_form-0-name" /></td></tr>""", )
def editQuestion(request, question_index): NewOptionsFormset = formset_factory(NewOptionForm, max_num=15, extra=0) if request.method == 'POST': # receiving question info print(request.POST) question_form = NewQuestionForm(request.POST) options_formset = NewOptionsFormset(request.POST, request.FILES) if question_form.is_valid() and options_formset.is_valid(): if question_index == -1: # Saving new question q = question_form.save() print("saving question...") else: # Updating existing question q = Question.objects.get(pk=question_index) form = NewQuestionForm(request.POST, instance=q) form.save() Option.objects.filter(question=question_index).delete() for form in options_formset.forms: option = form.save(commit=False) #commit = false option.question = q option.save() #redirect to options page unless fill in the blank #return HttpResponseRedirect(previous_page(request.path)) return HttpResponseRedirect('/questions/questionHome') else: # render page if question_index == -1: NewOptionsFormset = formset_factory(NewOptionForm, max_num=15, extra=1) question_form = NewQuestionForm() options_formset = NewOptionsFormset() else: ##** The else statement needs to load the forms with data from database question = get_object_or_404(Question, id=question_index) options = Option.objects.all().filter(question=question).values() #branch select couldn't find option['branch_id'] so insert option['branch'] for option in options: option['branch'] = option['branch_id'] if not options: NewOptionsFormset = formset_factory(NewOptionForm, max_num=15, extra=1) else: NewOptionsFormset = formset_factory(NewOptionForm, max_num=15, extra=0) question_form = NewQuestionForm(instance=question) print("options ===> ", options) options_formset = NewOptionsFormset(initial=options) print(options_formset) context = { 'question_form': question_form, 'options_formset': options_formset} context['previous_page'] = previous_page(request.path) return render(request, 'questions/addQuestion.html', context)
def modify_sensor(request, sensor_id): errors = False user = request.user VariableFormSet = formset_factory(ModifyVariableForm, extra=0) if request.method == 'POST': if user.auth_level < 2: context = {'title':'Not authorized!', 'error_msg':'You are not allowed to modify sensor values. Please contact admin to request rights to modify/add sensors.'} return render(request, 'management/error.html', context) else: modified_sensor = Sensor.objects.get(pk=sensor_id) modified_sensor_form = ModifySensorForm(request.POST, instance=modified_sensor, prefix='modify_sensor') communication_technology = request.POST['communication_technology'] protocol = request.POST['protocol'] if communication_technology == 'Wlan': instance = Wlan.objects.get(pk=request.POST['communication_instance']) modified_wlan_form = ModifyWlanForm(request.POST, instance=instance, prefix='wlan') communication_instances = Wlan.objects.all() modify_communication_form = modified_wlan_form if modified_wlan_form.is_valid(): modified_wlan_form.save() modified_sensor.communication_object = instance else: errors = True elif communication_technology == 'Nb_iot': instance = Nb_iot.objects.get(pk=request.POST['communication_instance']) modified_nb_iot_form = ModifyNbIotForm(request.POST, instance=instance, prefix='nb_iot') communication_instances = Nb_iot.objects.all() modify_communication_form = modified_nb_iot_form if modified_nb_iot_form.is_valid(): modified_nb_iot_form.save() modified_sensor.communication_object = instance else: errors = True if protocol == 'HTTP': instance = HTTP.objects.get(pk=request.POST['protocol_instance']) modified_http_form = ModifyHTTPForm(request.POST, instance=instance, prefix='http') protocol_instances = HTTP.objects.all() modify_protocol_form = modified_http_form if modified_http_form.is_valid(): modified_http_form.save() modified_sensor.protocol_object = instance else: errors = True elif protocol == 'HTTPS': instance = HTTPS.objects.get(pk=request.POST['protocol_instance']) modified_https_form = ModifyHTTPSForm(request.POST, instance=instance, prefix='https') protocol_instances = HTTPS.objects.all() modify_protocol_form = modified_https_form if modified_https_form.is_valid(): modified_https_form.save() modified_sensor.protocol_object = instance else: errors = True elif protocol == 'MQTT': instance = MQTT.objects.get(pk=request.POST['protocol_instance']) modified_MQTT_form = ModifyMQTTForm(request.POST, instance=instance, prefix='mqtt') protocol_instances = MQTT.objects.all() modify_protocol_form = modified_MQTT_form if modified_MQTT_form.is_valid(): modified_MQTT_form.save() modified_sensor.protocol_object = instance else: errors = True old_key = modified_sensor.sensor_key modify_sensor_form = modified_sensor_form variable_formset = VariableFormSet(request.POST) if variable_formset.is_valid(): old_variables = Variable.objects.filter(sensor=modified_sensor) for o in old_variables: o.delete() for variable_form in variable_formset: name = variable_form.cleaned_data.get('name') unit = variable_form.cleaned_data.get('unit') if name and unit: v = Variable(sensor=modified_sensor, name=name, unit=unit) v.save() else: errors = True if modified_sensor_form.is_valid(): if not errors: modified_sensor.sample_rate = Sample_rate.objects.get(id=request.POST['modify_sensor-sample_rate']) modified_sensor.sensitivity = Sensitivity.objects.get(id=request.POST['modify_sensor-sensitivity']) if old_key != request.POST['modify_sensor-sensor_key']: modified_sensor.sensor_key_old = old_key modified_sensor_form.save() if modified_sensor.status != Sensor.WAITING_FOR_UPDATE: modified_sensor.status = Sensor.MEASURING_WAITING_FOR_UPDATE modified_sensor.latest_modifier = user modified_sensor.date_modified = datetime.datetime.now() modified_sensor.save() update_sensor(modified_sensor) return redirect('browse_sensors') else: errors = True #If not post fill the form sensor = Sensor.objects.get(pk=sensor_id) communication_object = sensor.communication_object communication_type = communication_object.__class__.__name__ protocol_object = sensor.protocol_object protocol = protocol_object.__class__.__name__ if user.auth_level >= 2: if not errors: modify_sensor_form = ModifySensorForm(instance=sensor, prefix='modify_sensor') if communication_type == 'Wlan': modify_communication_form = ModifyWlanForm(instance=communication_object, prefix='wlan') communication_instances = Wlan.objects.all() elif communication_type == 'Nb_iot': modify_communication_form = ModifyNbIotForm(instance=communication_object, prefix='nb_iot') communication_instances = Nb_iot.objects.all() else: raise Http404("Page doesn't exist") if protocol == 'HTTP': modify_protocol_form = ModifyHTTPForm(instance=protocol_object, prefix='http') protocol_instances = HTTP.objects.all() elif protocol == 'HTTPS': modify_protocol_form = ModifyHTTPSForm(instance=protocol_object, prefix='https') protocol_instances = HTTPS.objects.all() elif protocol == 'MQTT': modify_protocol_form = ModifyMQTTForm(instance=protocol_object, prefix='mqtt') protocol_instances = MQTT.objects.all() else: raise Http404("Page doesn't exist") else: return render(request, 'management/error.html', {'title' : 'You are not allowed to modify sensor', 'error_msg' : 'Ask rights to modify sensor from admin.'}) variables = Variable.objects.filter(sensor=Sensor.objects.get(pk=sensor_id)) initial_data = [{'name': v.name, 'unit': v.unit} for v in variables] modify_variable_forms = VariableFormSet(initial=initial_data) available_sample_rates = Sample_rate.objects.filter(model=sensor.model.pk) available_sensitivities = sensor.sample_rate.supported_sensitivities.all() current_model = sensor.model.sensor_model context = {'modify_sensor_form' : modify_sensor_form, 'available_sample_rates': available_sample_rates, 'current_sample_rate': sensor.sample_rate.id, 'available_sensitivities': available_sensitivities, 'current_sensitivity': sensor.sensitivity.id, 'current_communication_technology': sensor.communication_object.__class__.__name__, 'current_communication_id': sensor.communication_object.id, 'communication_instances': communication_instances, 'modify_communication_form': modify_communication_form, 'available_communication_technologies':AVAILABLE_COMMUNICATION_TECHNOLOGIES, 'current_protocol': sensor.protocol_object.__class__.__name__, 'current_protocol_id': sensor.protocol_object.id, 'protocol_instances': protocol_instances, 'modify_protocol_form': modify_protocol_form, 'available_protocols': AVAILABLE_PROTOCOLS, 'modify_variable_forms': modify_variable_forms, 'sensor_id': sensor_id, 'current_model': current_model, } return render(request, 'management/modify_sensor.html', context)
def post(self, *args, **kwargs): tally_id = kwargs.get('tally_id') post_data = self.request.POST pk = session_matches_post_result_form(post_data, self.request) result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id) form_in_data_entry_state(result_form) formset, forms_and_candidates = get_formset_and_candidates(result_form, post_data) recon_form = ReconForm(post_data) data_entry_number = get_data_entry_number(result_form.form_state) candidates = result_form.candidates CandidateFormSet = formset_factory(CandidateForm, extra=len(candidates), formset=BaseCandidateFormSet) formset = CandidateFormSet(post_data) if (not result_form.has_recon or recon_form.is_valid()) and formset.is_valid(): check_form = check_state_and_group( result_form, self.request.user, recon_form) if check_form: return self.form_invalid(check_form) entry_version = None new_state = None if result_form.form_state == FormState.DATA_ENTRY_1: entry_version = EntryVersion.DATA_ENTRY_1 new_state = FormState.DATA_ENTRY_2 else: entry_version = EntryVersion.DATA_ENTRY_2 new_state = FormState.CORRECTION for i, form in enumerate(formset.forms): votes = form.cleaned_data['votes'] Result.objects.create( candidate=candidates[i], result_form=result_form, entry_version=entry_version, votes=votes, user=self.request.user.userprofile ) if result_form.has_recon: re_form = recon_form.save(commit=False) re_form.entry_version = entry_version re_form.result_form = result_form re_form.user = self.request.user.userprofile re_form.save() result_form.form_state = new_state result_form.duplicate_reviewed = False result_form.save() return redirect(self.success_url, tally_id=tally_id) else: return self.render_to_response(self.get_context_data( formset=formset, forms_and_candidates=forms_and_candidates, reconciliation_form=recon_form, result_form=result_form, data_entry_number=data_entry_number, tally_id=tally_id))
spoc=forms.CharField(label='SPOC',widget=forms.TextInput(attrs={'readonly':'readonly'}),) consultants = forms.ModelMultipleChoiceField(label='Choose Consultants',queryset=None, widget=forms.CheckboxSelectMultiple, required=True) bankname=forms.ModelChoiceField(label='Bankname',queryset=Bank.objects.all(),empty_label='Select Bank') From=forms.DateField(label='From Date',widget=forms.DateInput(attrs={'type':'date'}),required=True) To=forms.DateField(label='To Date',widget=forms.DateInput(attrs={'type':'date'}),required=True) requests_recieved = forms.CharField(widget=TinyMCE(attrs={'cols': 30, 'rows': 7})) summary_of_response = forms.CharField(widget=TinyMCE(attrs={'cols': 15, 'rows': 15})) summary_of_workdone = forms.CharField(widget=TinyMCE(attrs={'cols': 15, 'rows': 6})) learnings = forms.CharField(widget=TinyMCE(attrs={'cols': 15, 'rows': 6})) class AttachmentsForm(forms.Form): file=forms.FileField(required=False,label='Upload File') AttachmentsFormset= formset_factory(AttachmentsForm) class QAForm(forms.Form): file=forms.FileField(required=False,label='Upload File') QA_Formset= formset_factory(QAForm) class CreateReportForm(forms.Form): def __init__(self, *args, **kwargs): user = kwargs.pop('user') super(CreateReportForm, self).__init__(*args, **kwargs) self.fields['consultants'].queryset = User.objects.filter(is_consultant=True).exclude(name=user) self.fields['spoc'].initial = User.objects.get(name=user) spoc=forms.CharField(label='SPOC',widget=forms.TextInput(attrs={'readonly':'readonly'}),) consultants = forms.ModelMultipleChoiceField(queryset=None, widget=forms.CheckboxSelectMultiple, required=True) bankname=forms.ModelChoiceField(queryset=Bank.objects.all(),required=True,empty_label='Select Bank') date=forms.DateField(label='Date',widget=forms.DateInput(attrs={'type':'date'}))
def engine_call(self, request, engine_method, format=None, is_detail=True, form_class=RequestForm, serialize=True, download=True, limit=False): mutable_get = request.GET.copy() mutable_get.update(request.POST.copy()) mutable_get['output'] = 'json' if format is not None: format = 'prettyjson' if format == 'pjson' else format format = 'json_array' if format == 'ajson' else format format = 'json' if format == 'jsonp' else format mutable_get['output'] = format if limit: max_rows = int(self.get_max_rows(request)) param_rows = mutable_get.get('limit', None) if max_rows > 0 and (not param_rows or int(param_rows) <= 0 or int(param_rows) > max_rows): mutable_get['limit'] = max_rows resource = {} if is_detail: resource = self.get_object() mutable_get['revision_id'] = resource[self.dao_pk] mutable_get.update(self.get_default_parameters(request)) items = dict(mutable_get.items()) formset=formset_factory(form_class, formset=RequestFormSet) form = formset(items) if not form.is_valid(): logger.info("form errors: %s" % form.errors) # TODO: correct handling raise Exception("Wrong arguments") command = AbstractCommandFactory(self.app).create(engine_method, self.data_types[0], form.cleaned_data) result = command.run() if not result: # TODO: correct handling raise Exception('Wrong engine answer') resource['result'] = result[0] if result[0] else {} resource['format'] = result[1] if serialize: serializer = self.get_serializer(resource) return Response(serializer.data) serializer = EngineSerializer(resource, context={'dao_filename': self.dao_filename}) if download and 'redirect' in serializer.data and serializer.data['redirect']: response = HttpResponse(content_type='application/force-download') filename = serializer.data['filename'] # UGLY HOTFIX # ENGINE SEND SOMETHING LIKE ### Nivel_Rendimiento_anio_2008.xlsx?AWSAccessKeyId=AKIAI65****H2VI25OA&Expires=1452008148&Signature=u84IIwXrpIoE%3D filename2 = filename.split('?AWSAccessKeyId')[0] #TODO get the real name (title) or someting nice response['Content-Disposition'] = 'attachment; filename="{0}"'.format(filename2) redir = urllib2.urlopen(serializer.data['result']['fUri']) status = redir.getcode() resp = redir.read() url = redir.geturl() if settings.DEBUG: logger.info('REDIR %d %s -- %s -- %s -- %s' % (status, url, redir.info(), filename, filename2)) response.write(resp) return response response = Response(serializer.data['result'], content_type=resource['format']) #TODO hacer una lista de los formatos que esperan forzar una descarga y los que se mostraran en pantalla output = mutable_get['output'] if download and output not in ['json', 'html']: # reemplazar la extension si la tuviera filename = serializer.data['filename'] name = filename if len(filename.split('.')) == 1 else '.'.join(filename.split('.')[:-1]) final_filename = '{}.{}'.format(name, output) response['Content-Disposition'] = 'attachment; filename="{}"'.format(final_filename) # Si es un recurso, trato de guardar el timestamp si corresponde if is_detail and format == 'json': self.update_timestamp(response, resource) return response
def volumemanager(request): if request.method == "POST": form = forms.VolumeManagerForm(request.POST) VdevFormSet = formset_factory(forms.VolumeVdevForm, formset=forms.VdevFormSet) formset = VdevFormSet(request.POST, prefix='layout') formset.form = form if form.is_valid() and formset.is_valid() and form.done(formset): return JsonResp(request, message=_("Volume successfully added.")) else: return JsonResp(request, form=form, formsets={'layout': formset}) disks = [] # Grab disk list # Root device already ruled out for disk, info in notifier().get_disks().items(): disks.append( forms.Disk(info['devname'], info['capacity'], serial=info.get('ident'))) disks = sorted(disks, key=lambda x: (x.size, x.dev), cmp=_diskcmp) # Exclude what's already added used_disks = [] for v in models.Volume.objects.all(): used_disks.extend(v.get_disks()) qs = iSCSITargetExtent.objects.filter(iscsi_target_extent_type='Disk') used_disks.extend([i.get_device()[5:] for i in qs]) bysize = dict() for d in list(disks): if d.dev in used_disks: continue hsize = forms.humanize_number_si(d.size) if hsize not in bysize: bysize[hsize] = [] bysize[hsize].append({ 'dev': d.dev, 'name': str(d), 'size': d.size, 'serial': d.serial, }) bysize = OrderedDict(sorted(bysize.iteritems(), reverse=True)) qs = models.Volume.objects.filter(vol_fstype='ZFS') swap = Advanced.objects.latest('id').adv_swapondrive return render( request, "storage/volumemanager.html", { 'disks': json.dumps(bysize), 'dedup_warning': forms.DEDUP_WARNING, 'swap_size': swap * 1024 * 1024 * 1024, 'extend': json.dumps([{ 'value': '', 'label': '-----' }] + [{ 'label': x.vol_name, 'value': x.vol_name, 'enc': x.vol_encrypt > 0 } for x in qs]), })
def modelformset_factory( model, form=ModelForm, formfield_callback=None, formset=BaseModelFormSet, extra=1, can_delete=False, can_order=False, max_num=None, fields=None, exclude=None, widgets=None, validate_max=False, localized_fields=None, labels=None, help_texts=None, error_messages=None, min_num=None, validate_min=False, field_classes=None, session=None, ): """Return a FormSet class for the given sqlalchemy model class.""" _meta = getattr(form, "Meta", None) fields = getattr(_meta, "fields", fields) exclude = getattr(_meta, "exclude", exclude) if fields is None and exclude is None: raise ImproperlyConfigured( "Calling modelformset_factory without defining 'fields' or " "'exclude' explicitly is prohibited.") form = modelform_factory( model, form=form, fields=fields, exclude=exclude, formfield_callback=formfield_callback, widgets=widgets, localized_fields=localized_fields, labels=labels, help_texts=help_texts, error_messages=error_messages, field_classes=field_classes, session=session, ) FormSet = formset_factory( form, formset, extra=extra, min_num=min_num, max_num=max_num, can_order=can_order, can_delete=can_delete, validate_min=validate_min, validate_max=validate_max, ) class_name = model.__name__ + "FormSet" return type(form)(str(class_name), (FormSet, ), { "model": model, "session": session })
def student_take_quiz(request, Quiz_Order): assignment = Assignment.objects.get(assignNum=Quiz_Order) submitassign = SubmitAssign.objects.get(assignNum=assignment, studentID=request.user) ''' #check if submittime is before 5hours if timezone.now() - submitassign.submitTime < timedelta(hours=5): #submitAssigns = SubmitAssign.objects.filter(studentID__username = request.user.username).filter(assignNum__subjectNum = assignment.subjectNum.subjectNum) #return render(request, 'student/student_quiz.html', {'submitassigns':submitAssigns}) return student_quiz(request, assignment.subjectNum.subjectNum) ''' if assignment.amountQuizShort is None: takequizshorts = quiz_short.objects.filter(AssignNum=Quiz_Order) else: quiz_id_list = quiz_shortManager.objects.filter( submitAssign=submitassign).values_list('quiz', flat=True) if len(quiz_id_list) == 0: id_list = quiz_short.objects.filter( AssignNum=Quiz_Order).values_list('id', flat=True) random_id_list = random.sample( list(id_list), min(len(list(id_list)), assignment.amountQuizShort)) #takequizshorts = quiz_short.objects.filter(id__in=random_id_list) for quiz_id in random_id_list: quiz_shortManager.objects.create(submitAssign=submitassign, quiz_id=quiz_id) quiz_id_list = quiz_shortManager.objects.filter( submitAssign=submitassign).values_list('quiz', flat=True) takequizshorts = quiz_short.objects.filter(id__in=quiz_id_list) else: takequizshorts = quiz_short.objects.filter(id__in=quiz_id_list) if assignment.amountQuizOne is None: takequizones = quiz_one.objects.filter(AssignNum=Quiz_Order) else: quiz_id_list = quiz_oneManager.objects.filter( submitAssign=submitassign).values_list('quiz', flat=True) if len(quiz_id_list) == 0: id_list = quiz_one.objects.filter( AssignNum=Quiz_Order).values_list('id', flat=True) random_id_list = random.sample( list(id_list), min(len(list(id_list)), assignment.amountQuizOne)) #takequizones = quiz_one.objects.filter(id__in=random_id_list) for quiz_id in random_id_list: quiz_oneManager.objects.create(submitAssign=submitassign, quiz_id=quiz_id) quiz_id_list = quiz_oneManager.objects.filter( submitAssign=submitassign).values_list('quiz', flat=True) takequizones = quiz_one.objects.filter(id__in=quiz_id_list) else: takequizones = quiz_one.objects.filter(id__in=quiz_id_list) if assignment.amountQuizMulti is None: takequizmultis = quiz_multi.objects.filter(AssignNum=Quiz_Order) else: quiz_id_list = quiz_multiManager.objects.filter( submitAssign=submitassign).values_list('quiz', flat=True) if len(quiz_id_list) == 0: id_list = quiz_multi.objects.filter( AssignNum=Quiz_Order).values_list('id', flat=True) random_id_list = random.sample( list(id_list), min(len(list(id_list)), assignment.amountQuizMulti)) #takequizmultis = quiz_multi.objects.filter(id__in=random_id_list) for quiz_id in random_id_list: quiz_multiManager.objects.create(submitAssign=submitassign, quiz_id=quiz_id) quiz_id_list = quiz_multiManager.objects.filter( submitAssign=submitassign).values_list('quiz', flat=True) takequizmultis = quiz_multi.objects.filter(id__in=quiz_id_list) else: takequizmultis = quiz_multi.objects.filter(id__in=quiz_id_list) #takequizones = quiz_one.objects.filter(AssignNum = Quiz_Order) #takequizmultis = quiz_multi.objects.filter(AssignNum = Quiz_Order) my_iterator_short = takequizshorts.iterator() FormSet_Short_Answer_Forms = formset_factory(ShortAnswerForm, extra=len(takequizshorts)) try: FormSet_Short_Answer_Forms.form = staticmethod( curry(ShortAnswerForm, item_iterator_short=my_iterator_short)) except: pass my_iterator = takequizones.iterator() FormSet_One_Answer_Forms = formset_factory(OneChoiceForm, extra=len(takequizones)) try: FormSet_One_Answer_Forms.form = staticmethod( curry(OneChoiceForm, item_iterator=my_iterator)) except: pass my_iterator_multi = takequizmultis.iterator() FormSet_Multi_Answer_Forms = formset_factory(MultiChoiceForm, extra=len(takequizmultis)) try: FormSet_Multi_Answer_Forms.form = staticmethod( curry(MultiChoiceForm, item_iterator_multi=my_iterator_multi)) except: pass if request.method == 'POST': formset_short_answer_forms = FormSet_Short_Answer_Forms( request.POST, prefix="short_answer_forms") formset_one_answer_forms = FormSet_One_Answer_Forms( request.POST, prefix="one_answer_forms") formset_multi_answer_forms = FormSet_Multi_Answer_Forms( request.POST, prefix="multi_answer_forms") print(request.POST) grade = 0 if formset_short_answer_forms.is_valid( ) and formset_one_answer_forms.is_valid( ) and formset_multi_answer_forms.is_valid(): for f in formset_short_answer_forms: cd = f.cleaned_data answer = cd.get('answer') ''' short_answer_result[sar]=f.quiz_short.Answer print(short_answer_result[sar]) ''' f.correct_short = f.quiz_short.Answer == answer if f.correct_short: grade = grade + 1 for f in formset_one_answer_forms: cd = f.cleaned_data answer_key = cd.get('one_answer') ''' print(dict(f.fields['one_answer'].choices).get(answer_key)) #if f.quiz_one.Answer == one_answer : if f.quiz_one.Answer == dict(f.fields['one_answer'].choices).get(answer_key): grade = grade + 1 ''' f.correct_one_check = f.quiz_one.Check == answer_key if f.correct_one_check: grade = grade + 1 ''' correct_list_multi = [] if f.quiz_one.Check_1 == True: correct_list_multi.append('1') if f.quiz_one.Check_2 == True: correct_list_multi.append('2') if f.quiz_one.Check_3 == True: correct_list_multi.append('3') if f.quiz_one.Check_4 == True: correct_list_multi.append('4') if correct_list_multi == answer_list_multi : grade = grade + 1 ''' for f in formset_multi_answer_forms: cd = f.cleaned_data answer_list = cd.get('multi_answer') correct_list = [] if f.quiz_multi.Check_1 == True: correct_list.append('a_multi') if f.quiz_multi.Check_2 == True: correct_list.append('b_multi') if f.quiz_multi.Check_3 == True: correct_list.append('c_multi') if f.quiz_multi.Check_4 == True: correct_list.append('d_multi') f.correct_multi_check = correct_list == answer_list if f.correct_multi_check: grade = grade + 1 assignment = Assignment.objects.get(assignNum=Quiz_Order) submitassign = SubmitAssign.objects.filter(assignNum=assignment, studentID=request.user) submitassign.update(grade=grade, submitTime=timezone.now()) quiz_oneManager.objects.filter(submitAssign=submitassign).delete() quiz_multiManager.objects.filter( submitAssign=submitassign).delete() quiz_shortManager.objects.filter( submitAssign=submitassign).delete() # context = {'takequizshorts':takequizshorts, 'takequizones':takequizones, 'takequizmultis':takequizmultis, 'formsetshortanswerforms':formset_short_answer_forms, 'formsetoneanswerforms':formset_one_answer_forms, 'formsetmultianswerforms':formset_multi_answer_forms} # return HttpResponseRedirect('student_quiz_result.html', context) questionquantity = len(takequizshorts) + len(takequizones) + len( takequizmultis) context = { 'takequizshorts': takequizshorts, 'takequizones': takequizones, 'takequizmultis': takequizmultis, 'formsetshortanswerforms': formset_short_answer_forms, 'formsetoneanswerforms': formset_one_answer_forms, 'formsetmultianswerforms': formset_multi_answer_forms, 'grade': grade, 'questionquantity': questionquantity } return render(request, 'student/student_quiz_result.html', context) else: formset_short_answer_forms = FormSet_Short_Answer_Forms( prefix="short_answer_forms") formset_one_answer_forms = FormSet_One_Answer_Forms( prefix="one_answer_forms") formset_multi_answer_forms = FormSet_Multi_Answer_Forms( prefix="multi_answer_forms") context = { 'takequizshorts': takequizshorts, 'takequizones': takequizones, 'takequizmultis': takequizmultis, 'formsetshortanswerforms': formset_short_answer_forms, 'formsetoneanswerforms': formset_one_answer_forms, 'formsetmultianswerforms': formset_multi_answer_forms } return render(request, 'student/student_take_quiz.html', context)
self.forms.append( self._construct_form(i, model_fields=self.model_fields)) @cached_property def forms(self): # override the original property to include `model_fields` argument forms = [ self._construct_form(i, model_fields=self.model_fields) for i in range(self.total_form_count()) ] forms.append(self.empty_form) # add initial empty form return forms AFQFormSet = formset_factory(AdvancedFilterQueryForm, formset=AdvancedFilterFormSet, extra=1, can_delete=True) AFQFormSetNoExtra = formset_factory(AdvancedFilterQueryForm, formset=AdvancedFilterFormSet, extra=0, can_delete=True) class AdvancedFilterForm(CleanWhiteSpacesMixin, forms.ModelForm): """ Form to save/edit advanced filter forms """ class Meta: model = AdvancedFilter fields = ('title', ) class Media:
def clean(self): """No two email addresses are the same.""" if any(self.errors): # Don't bother validating the formset unless each form is valid return emails = [] for form in self.forms: email = form.cleaned_data['email'] if email in emails: raise ValidationError( "Forms in a set must have distinct email addresses.") emails.append(email) TestFormSet = formset_factory(TestForm, BaseTestFormSet) def formset_view(request): "A view that tests a simple formset" if request.method == 'POST': formset = TestFormSet(request.POST) if formset.is_valid(): t = Template('Valid POST data.', name='Valid POST Template') c = Context() else: t = Template('Invalid POST data. {{ my_formset.errors }}', name='Invalid POST Template') c = Context({'my_formset': formset}) else: formset = TestForm(request.GET)
def index(request): if request.method == "POST": all_forms = { "form1": forms.Form1, "form2": forms.Form2, "form3": forms.Form3, "form4": forms.Form4, "form5": forms.Form5, "form6": formset_factory(forms.Form6, extra=4), } for i in range(1, len(all_forms) + 1): all_forms[f"form{i}"] = all_forms[f"form{i}"](prefix=f"form{i}", data=request.POST) if all(all_forms[i].is_valid() for i in all_forms): document.main(all_forms) else: return HttpResponse( f"<h1>INVALID FORM : CLICK BACK BUTTON TOP LEFT<br>" "{'\n'.join(map(lambda x:x.errors if not x.is_valid() else " ", all_forms.values()))}</h1>") return HttpResponse("<h1>Sent</h1>") all_forms = { "form1": forms.Form1, "form2": forms.Form2, "form3": forms.Form3, "form4": forms.Form4, "form5": forms.Form5, "form6": formset_factory(forms.Form6, extra=4), } sections = [ f"mainapp/section{i}.html" for i in range(1, len(all_forms) + 1) ] for i in range(1, len(all_forms) + 1): all_forms[f"form{i}"] = all_forms[f"form{i}"](prefix=f"form{i}") return render( request, "mainapp/index.html", context={ **all_forms, "sections": sections, "section8": [ "Grant agency Title of the project and reference number", "Duration(from mm/yy to mm/yy)", "Percentage of time devoted /being devoted/to be devoted, in many months", "Amount in lakh Rs." ], "section9": [], "section10": [], "section11": [], "section12": [], })
BaseLeaveFormSet, EmployeeCommonForm, LeaveSegmentForm, StudentApplicationForm, AcademicReplacementFormOffline, AdminReplacementFormOffline, BaseLeaveFormSetOffline, EmployeeCommonFormOffline, LeaveSegmentFormOffline) from .helpers import (create_migrations, deduct_leave_balance, get_pending_leave_requests, restore_leave_balance, get_designation) from .models import (Leave, LeaveRequest, LeaveSegment, LeaveType, ReplacementSegment, LeaveOffline, LeaveSegmentOffline, ReplacementSegmentOffline) from applications.globals.models import HoldsDesignation from notification.views import leave_module_notif LeaveFormSet = formset_factory(LeaveSegmentForm, extra=0, max_num=3, min_num=1, formset=BaseLeaveFormSet) AcadFormSet = formset_factory(AcademicReplacementForm, extra=0, max_num=3, min_num=1) AdminFormSet = formset_factory(AdminReplacementForm, extra=0, max_num=3, min_num=1) common_form = EmployeeCommonForm() LeaveFormSetOffline = formset_factory(LeaveSegmentFormOffline, formset=BaseLeaveFormSetOffline, extra=0,
def deadline_management(self, request, tl, one, two, module, extra, prog): # Define a formset for editing multiple perms simultaneously. EditPermissionFormset = formset_factory(EditPermissionForm) # Define a status message message = '' # Handle 'open' / 'close' actions if extra == 'open' and 'id' in request.GET: perm = Permission.objects.get(id=request.GET['id']) # Clear any duplicate user permissions Permission.objects.filter( permission_type=perm.permission_type, program=perm.program, user__isnull=True, role=perm.role).exclude(id=perm.id).delete() perm.end_date = None perm.save() message = 'Deadline opened: %s.' % perm.nice_name() elif extra == 'close' and 'id' in request.GET: perm = Permission.objects.get(id=request.GET['id']) # Clear any duplicate user permissions Permission.objects.filter( permission_type=perm.permission_type, program=perm.program, user__isnull=True, role=perm.role).exclude(id=perm.id).delete() perm.end_date = datetime.now() perm.save() message = 'Deadline closed: %s.' % perm.nice_name() # Check incoming form data if request.method == 'POST': edit_formset = EditPermissionFormset(request.POST.copy(), prefix='edit') create_form = NewPermissionForm(request.POST.copy()) if edit_formset.is_valid(): num_forms = 0 for form in edit_formset.forms: # Check if the permission with the specified ID exists. # It may have been deleted by previous iterations of this loop # deleting duplicate permissions. if 'id' in form.cleaned_data and Permission.objects.filter( id=form.cleaned_data['id']).exists(): num_forms += 1 perm = Permission.objects.get( id=form.cleaned_data['id']) # Clear any duplicate perms Permission.objects.filter( permission_type=perm.permission_type, program=perm.program, user__isnull=True, role=perm.role).exclude(id=perm.id).delete() perm.start_date = form.cleaned_data['start_date'] perm.end_date = form.cleaned_data['end_date'] perm.save() if num_forms > 0: message = 'Changes saved.' if create_form.is_valid(): perm, created = Permission.objects.get_or_create( user=None, permission_type=create_form. cleaned_data['permission_type'], role=Group.objects.get( name=create_form.cleaned_data['role']), program=prog) if not created: message = 'Deadline already exists: %s. Please modify the existing deadline.' % perm.nice_name( ) else: perm.start_date = create_form.cleaned_data['start_date'] perm.end_date = create_form.cleaned_data['end_date'] perm.save() message = 'Deadline created: %s.' % perm.nice_name() else: message = 'No activities selected. Please select a deadline type from the list before creating a deadline.' # find all the existing permissions with this program # Only consider global permissions -- those that apply to all users # of a particular role. Permissions added for individual users # should be managed in the admin interface. perms = Permission.deadlines().filter(program=self.program, user__isnull=True) perm_map = {p.permission_type: p for p in perms} # Populate template context to render page with forms context = {} # Set a flag on each perm for whether it has ended # TODO(benkraft): refactor users to just call is_valid themselves. for perm in perms: perm.open_now = perm.is_valid() # For each permission, determine which other ones it implies for perm in perms: includes = Permission.implications.get(perm.permission_type, []) perm.includes = [] perm.name = perm.nice_name() for p in includes: if p == perm.permission_type: continue perm.includes.append({ 'type': p, 'nice_name': Permission.nice_name_lookup(p) }) if p in perm_map: perm.includes[-1].update({ 'overridden': True, 'overridden_by': perm_map[p], 'bit_open': perm_map[p].open_now }) # Supply initial data for forms formset = EditPermissionFormset( initial=[perm.__dict__ for perm in perms], prefix='edit') for i in range(len(perms)): perms[i].form = formset.forms[i] context['message'] = message context['manage_form'] = formset.management_form context['perms'] = perms context['create_form'] = NewPermissionForm() return render_to_response(self.baseDir() + 'deadlines.html', request, context)
return encoding class RenameForm(forms.Form): op = "rename" src_path = CharField(label=_("File to rename"), help_text=_("The file to rename.")) dest_path = CharField(label=_("New name"), help_text=_("Rename the file to:")) class BaseRenameFormSet(FormSet): op = "rename" RenameFormSet = formset_factory(RenameForm, formset=BaseRenameFormSet, extra=0) class CopyForm(forms.Form): op = "copy" src_path = CharField(label=_("File to copy"), help_text=_("The file to copy.")) dest_path = CharField(label=_("Destination location"), help_text=_("Copy the file to:")) class BaseCopyFormSet(FormSet): op = "copy" CopyFormSet = formset_factory(CopyForm, formset=BaseCopyFormSet, extra=0)
def get_sensor_variables(request, sensor_id): variables = Variable.objects.filter(sensor=Sensor.objects.get(pk=sensor_id)) initial_data = [{'name': v.name, 'unit': v.unit} for v in variables] VariableFormSet = formset_factory(ModifyVariableForm, extra=0) return render(request, 'management/variable_table.html', context = {'modify_variable_forms': VariableFormSet(initial=initial_data)})
pass class ContactBaseFormSet(BaseFormSet): def add_fields(self, form, index): super(ContactBaseFormSet, self).add_fields(form, index) def clean(self): super(ContactBaseFormSet, self).clean() raise forms.ValidationError( "This error was added to show the non form errors styling") ContactFormSet = formset_factory(TestForm, formset=ContactBaseFormSet, extra=2, max_num=4, validate_max=True) class FilesForm(forms.Form): text1 = forms.CharField() file1 = forms.FileField() file2 = forms.FileField(required=False) file3 = forms.FileField(widget=forms.ClearableFileInput) file4 = forms.FileField(required=False, widget=forms.ClearableFileInput) class ArticleForm(forms.Form): title = forms.CharField() pub_date = forms.DateField()
def _get_lookup(self, operator, over): lookup = Field().get_db_prep_lookup(operator, over, connection=self._db_connection, prepared=True) if isinstance(lookup, (tuple, list)): return lookup[0] return lookup def _get_selects_with_extra_ids(self): qn = self._db_operations.quote_name selects = [] for select in self._selects: appmodel, field = select.split(".") appmodel = self._unquote_name(appmodel) field = self._unquote_name(field) selects.append(select) if appmodel in self._models: pk_name = self._models[appmodel]._meta.pk.name else: pk_name = u"id" selects.append("%s.%s" % (qn(appmodel), qn(pk_name))) return selects QueryByExampleFormSet = formset_factory(QueryByExampleForm, formset=BaseQueryByExampleFormSet, extra=1, can_delete=True)
def clean(self): if any(self.errors): return if (not self.forms or not any( f.cleaned_data.get('enabled') for f in self.forms if f.app == amo.FIREFOX)): # L10n: {0} is Firefox. raise forms.ValidationError( _(u'{0} is a required target application.').format( amo.FIREFOX.pretty)) return self.cleaned_data PackagerCompatFormSet = formset_factory(PackagerCompatForm, formset=PackagerCompatBaseFormSet, extra=0) class PackagerFeaturesForm(forms.Form): about_dialog = forms.BooleanField( required=False, label=_lazy(u'About dialog'), help_text=_lazy(u'Creates a standard About dialog for your ' 'extension')) preferences_dialog = forms.BooleanField( required=False, label=_lazy(u'Preferences dialog'), help_text=_lazy(u'Creates an example Preferences window')) toolbar = forms.BooleanField( required=False,
class Page1(forms.Form): name = forms.CharField(max_length=100) user = forms.ModelChoiceField(queryset=User.objects.all()) thirsty = forms.NullBooleanField() class Page2(forms.Form): address1 = forms.CharField(max_length=100) address2 = forms.CharField(max_length=100) class Page3(forms.Form): random_crap = forms.CharField(max_length=100) Page4 = formset_factory(Page3, extra=2) class ContactWizard(NamedUrlWizardView): def done(self, form_list, **kwargs): c = Context({ 'form_list': [x.cleaned_data for x in form_list], 'all_cleaned_data': self.get_all_cleaned_data() }) for form in self.form_list.keys(): c[form] = self.get_cleaned_data_for_step(form) c['this_will_fail'] = self.get_cleaned_data_for_step('this_will_fail') return HttpResponse(Template('').render(c))
class BaseDetalleOrdenServiciosFormSet(formsets.BaseFormSet): def clean(self): for form in self.forms: if form.cleaned_data: pass else: raise forms.ValidationError('Registro de datos incompletos.', code='datos_incompletos') class BaseDetalleConformidadServicioFormSet(formsets.BaseFormSet): def clean(self): for form in self.forms: if form.cleaned_data: pass else: raise forms.ValidationError('Registro de datos incompletos.', code='datos_incompletos') DetalleCotizacionFormSet = formsets.formset_factory( FormularioDetalleCotizacion, BaseDetalleCotizacionFormSet, 0) DetalleOrdenCompraFormSet = formsets.formset_factory( FormularioDetalleOrdenCompra, BaseDetalleOrdenCompraFormSet, 0) DetalleOrdenServiciosFormSet = formsets.formset_factory( FormularioDetalleOrdenServicios, BaseDetalleOrdenServiciosFormSet, 0) DetalleConformidadServicioFormSet = formsets.formset_factory( FormularioDetalleConformidadServicio, BaseDetalleConformidadServicioFormSet, 0)
def edit_appointment(request, appointment): appointment = get_object_or_404(Appointment, pk=appointment) EditAppointmentFormset = formset_factory(OrderAppointmentForm, formset=EditAppointmentBaseFormset, can_delete=True, extra=0) date_start = EventRelation.objects.get_events_for_object(appointment).values()[0]['start'].astimezone(timezone(settings.TIME_ZONE)) date_end = EventRelation.objects.get_events_for_object(appointment).values()[0]['end'].astimezone(timezone(settings.TIME_ZONE)) initial_data_form = {'customer': appointment.customer, 'comment':appointment.comment, 'duration': date_end.hour - date_start.hour} for service in ProductCategory.objects.filter(service=True): found = False for order in appointment.orders.all(): if service == order.category: initial_data_form['show_{}'.format(service.id)] = True initial_data_form['service_{}'.format(service.id)] = order.product initial_data_form['cost_{}'.format(service.id)] = order.cost found = True if not found: initial_data_form['show_{}'.format(service.id)] = False initial_data_formset = [] for order in appointment.orders.filter(category__service=False): initial_data_formset.append({'category': order.category,'product': order.product, 'quantity': order.quantity, 'cost': order.cost}) if request.method == 'POST': formset = EditAppointmentFormset(request.POST, initial=initial_data_formset) form_app = CreateAppointmentForm(request.POST, date=date_start, initial=initial_data_form, appointment=appointment) if form_app.is_valid() and formset.is_valid(): if form_app.has_changed(): date = form_app.cleaned_data['date'] event = EventRelation.objects.get_events_for_object(appointment).get() event.start = date event.end = event.start + timedelta(hours=int(form_app.cleaned_data['duration'])) event.save() appointment.customer = form_app.cleaned_data['customer'] appointment.comment = form_app.cleaned_data['comment'] appointment.barber = form_app.cleaned_data['barber'] for service in ProductCategory.objects.filter(service=True): order = appointment.orders.filter(category=service) if order: order = order.get() if form_app.cleaned_data['show_{}'.format(service.id)]: order.cost = form_app.cleaned_data['cost_{}'.format(service.id)] order.save() else: order.delete() else: if form_app.cleaned_data['show_{}'.format(service.id)]: order = OrderDetail.objects.create(category=service, product=form_app.cleaned_data['service_{}'.format(service.id)], quantity=1, cost=form_app.cleaned_data['cost_{}'.format(service.id)], date=date_start, barber=appointment.barber, customer=form_app.cleaned_data['customer'], appointment_fk=appointment) appointment.orders.add(order) if formset.has_changed(): bulk_edit = [] bulk_create = [] for index, form in enumerate(formset): if form.has_changed(): product = initial_data_formset[index]['product'] if index < len(initial_data_formset) else None order = appointment.orders.filter(product=product) if form in formset.deleted_forms and order: order = order.get() order.delete() else: if order: bulk_edit.append((order.get().id, {'product': form.cleaned_data['product'], 'cost': form.cleaned_data['cost'], 'quantity': form.cleaned_data['quantity']})) else: if form not in formset.deleted_forms: bulk_create.append({'category': form.cleaned_data['category'], 'product': form.cleaned_data['product'], 'quantity': form.cleaned_data['quantity'], 'cost': form.cleaned_data['cost']}) for bulk in bulk_edit: order = OrderDetail.objects.get(pk=bulk[0]) order.product = bulk[1]['product'] order.cost = bulk[1]['cost'] order.quantity = bulk[1]['quantity'] order.save() for bulk in bulk_create: order = OrderDetail.objects.create(category=bulk['category'], product=bulk['product'], quantity=bulk['quantity'], cost=bulk['cost'], date=date_start, barber=appointment.barber, customer=appointment.customer, appointment_fk=appointment) appointment.orders.add(order) appointment.save() else: formset = EditAppointmentFormset(initial=initial_data_formset) form_app = CreateAppointmentForm(date=date_start, initial=initial_data_form, barber=appointment.barber) return render(request, 'admin/edit_appointment.html', {'appointment': appointment, 'formset': formset, 'barber': appointment.barber, 'form': form_app, 'time':'{}-00'.format(date_start.hour)})
self.extra = len(self.mxcells) self.max_num = len(self.mxcells) self.absolute_max = len(self.mxcells) self.validate_max = len(self.mxcells) super(BaseICMatrixFormset, self).__init__(*args, **kwargs) def _construct_form(self, i, **kwargs): kwargs['mxcell'] = self.mxcells[i] # print(kwargs) form = super(BaseICMatrixFormset, self)._construct_form(i, **kwargs) # print(form) return form BaseFormset = formset_factory(form=ICMatrix, formset=BaseICMatrixFormset) print(BaseFormSet) class ObjectivesForm(forms.ModelForm): class Meta: model = Objectives exclude = ('assessed_cr', ) def __init__(self, *args, **kwargs): super(ObjectivesForm, self).__init__(*args, **kwargs) # Call to ModelForm constructor self.fields['transaction_objective'].widget.attrs[ 'style'] = "width:850px" # self.fields['transaction_objective'].required = False # for i in range(2):
form.app = app cats = sorted(app_cats[key], key=lambda x: x.name) form.fields['categories'].choices = [(c.id, c.name) for c in cats] # If this add-on is featured for this application, category # changes are forbidden. if not acl.action_allowed(self.request, 'Addons', 'Edit'): form.disabled = (app and self.addon.is_featured(app)) def save(self): for f in self.forms: f.save(self.addon) CategoryFormSet = formset_factory(form=CategoryForm, formset=BaseCategoryFormSet, extra=0) def icons(): """ Generates a list of tuples for the default icons for add-ons, in the format (psuedo-mime-type, description). """ icons = [('image/jpeg', 'jpeg'), ('image/png', 'png'), ('', 'default')] dirs, files = storage.listdir(settings.ADDON_ICONS_DEFAULT_PATH) for fname in files: if '32' in fname and not 'default' in fname: icon_name = fname.split('-')[0] icons.append(('icon/%s' % icon_name, icon_name)) return icons
def get_formset(self): """ Returns the formset class from the formset factory """ return formset_factory(self.get_form_class(), **self.get_factory_kwargs())
def post(self, request): """ The form has been submitted, process it. """ logger = logging.getLogger( "peering.manager.views.ImportFromObjectView") if "_add" in request.POST and not request.POST.getlist("pk"): messages.error(request, "No objects selected.") return redirect(self.get_return_url(request)) # Prepare the form if not self.custom_formset: ObjectFormSet = formset_factory(self.form_model, extra=0) else: ObjectFormSet = formset_factory(self.form_model, formset=self.custom_formset, extra=0) # Get dependencies base_objects = self.get_base_objects(request.POST.getlist("pk")) if not base_objects: # We don't have base objects to handle, proceed as if we were in the next # step of the form (object creation) formset = ObjectFormSet(data=request.POST) else: # Proceed base object and fill in the form processed_base_objects = [ self.process_base_object(request, o) for o in base_objects ] formset = ObjectFormSet( initial=self.sort_objects(processed_base_objects)) created_objects = [] if formset.is_valid(): logger.debug("formset validation was successful") with transaction.atomic(): for form in formset: if form.is_valid(): instance = form.save() created_objects.append(instance) if created_objects: count = len(created_objects) msg = f"Imported {count} {created_objects[0]._meta.verbose_name if count == 1 else created_objects[0]._meta.verbose_name_plural}" logger.info(msg) messages.success(request, msg) return redirect(self.get_return_url(request)) else: logger.debug("formset validation failed") return render( request, self.template_name, { "formset": formset, "object_type": self.form_model._meta.model._meta.verbose_name, "return_url": self.get_return_url(request), }, )
'twitter_feed', 'tags', ] class RelatedLinkForm(forms.Form): link = forms.URLField( required=False, # because we'll only save those that are there anyway error_messages={'invalid': 'Please enter a full URL, including the ‘http://’!'}, widget=forms.TextInput, ) def clean_link(self): link = self.cleaned_data.get('link') if not link: return None if not link.startswith('http://') or link.startswith('https://'): return 'http://' + link else: return link RelatedLinkFormset = formset_factory(RelatedLinkForm, extra=1, formset=OrderedFormset) RelatedLinkFormset.title = 'Web links' RelatedLinkFormset.help_text = 'Paste in the URL of the website in full, including the ‘http://’' class AreaForm(forms.Form): area = forms.ModelChoiceField(queryset=Area.objects.all()) AreaFormSet = formset_factory(AreaForm, extra=1, formset=OrderedFormset) AreaFormSet.title = 'Areas' AreaFormSet.help_text = help_text=help_text('rca.RcaNowPageArea', 'area')
def questions_update_view(self, request, election, poll): from zeus.utils import poll_reverse from zeus.forms import ScoresForm, RequiredFormset, DEFAULT_ANSWERS_COUNT extra = 1 if poll.questions_data: extra = 0 questions_formset = formset_factory(ScoresForm, formset=RequiredFormset, extra=extra, can_delete=True, can_order=True) if request.method == 'POST': formset = questions_formset(request.POST) if formset.is_valid(): questions_data = [] for question in formset.cleaned_data: if not question: continue # force sort of answers by extracting index from answer key. # cast answer index to integer, otherwise answer_10 would # be placed before answer_2 answer_index = lambda a: int(a[0].replace('answer_', '')) isanswer = lambda a: a[0].startswith('answer_') answer_values = list( filter(isanswer, iter(question.items()))) sorted_answers = sorted(answer_values, key=answer_index) question['answers'] = [x[1] for x in sorted_answers] question['scores'] = [ p for p in question['scores'] if p is not None ] question['question_subtitle'] = ",".join( question['scores']) for k in list(question.keys()): if k in ['DELETE', 'ORDER']: del question[k] questions_data.append(question) poll.questions_data = questions_data poll.update_answers() poll.logger.info("Poll ballot updated") poll.save() url = poll_reverse(poll, 'questions') return HttpResponseRedirect(url) else: formset = questions_formset(initial=poll.questions_data) context = { 'default_answers_count': DEFAULT_ANSWERS_COUNT, 'formset': formset, 'max_questions_limit': 1, 'election': election, 'poll': poll, 'module': self } set_menu('questions', context) tpl = 'election_modules/simple/election_poll_questions_manage' return render_template(request, tpl, context)
def add_sensor(request): user = request.user VariableFormSet = formset_factory(ModifyVariableForm, extra=0) errors_sensor_form = False errors = False if request.method == 'POST': if user.auth_level < 2: context = {'title':'Not authorized!', 'error_msg':'You are not allowed to add sensors. Please contact admin to request rights to modify/add sensors.'} return render(request, 'management/error.html', context) else: add_sensor_form = AddSensorForm(request.POST, prefix='add_sensor') communication_technology = request.POST['communication_technology'] protocol = request.POST['protocol'] if add_sensor_form.is_valid(): new_sensor = add_sensor_form.save() new_sensor.sample_rate = Sample_rate.objects.get(id=request.POST['add_sensor-sample_rate']) new_sensor.sensitivity = Sensitivity.objects.get(id=request.POST['add_sensor-sensitivity']) if communication_technology == 'Wlan': instance = Wlan.objects.get(pk=request.POST['communication_instance']) modified_wlan_form = ModifyWlanForm(request.POST, instance=instance, prefix='wlan') communication_instances = Wlan.objects.all() modify_communication_form = modified_wlan_form if modified_wlan_form.is_valid(): modified_wlan_form.save() new_sensor.communication_object = instance else: errors = True elif communication_technology == 'Nb_iot': instance = Nb_iot.objects.get(pk=request.POST['communication_instance']) modified_nb_iot_form = ModifyNbIotForm(request.POST, instance=instance, prefix='nb_iot') communication_instances = Nb_iot.objects.all() modify_communication_form = modified_nb_iot_form if modified_nb_iot_form.is_valid(): modified_nb_iot_form.save() new_sensor.communication_object = instance else: errors = True if protocol == 'HTTP': instance = HTTP.objects.get(pk=request.POST['protocol_instance']) modified_http_form = ModifyHTTPForm(request.POST, instance=instance, prefix='http') protocol_instances = HTTP.objects.all() modify_protocol_form = modified_http_form if modified_http_form.is_valid(): modified_http_form.save() new_sensor.protocol_object = instance else: errors = True elif protocol == 'HTTPS': instance = HTTPS.objects.get(pk=request.POST['protocol_instance']) modified_https_form = ModifyHTTPSForm(request.POST, instance=instance, prefix='https') protocol_instances = HTTPS.objects.all() modify_protocol_form = modified_https_form if modified_https_form.is_valid(): modified_https_form.save() new_sensor.protocol_object = instance else: errors = True elif protocol == 'MQTT': instance = MQTT.objects.get(pk=request.POST['protocol_instance']) modified_MQTT_form = ModifyMQTTForm(request.POST, instance=instance, prefix='mqtt') mqtt_instances = MQTT.objects.all() modify_protocol_form = modified_MQTT_form if modified_MQTT_form.is_valid(): modified_MQTT_form.save() new_sensor.protocol_object = instance else: errors = True variable_formset = VariableFormSet(request.POST) if variable_formset.is_valid(): for variable_form in variable_formset: name = variable_form.cleaned_data.get('name') unit = variable_form.cleaned_data.get('unit') if name and unit: v = Variable(sensor=new_sensor, name=name, unit=unit) v.save() else: errors = True if not errors: new_sensor.status = Sensor.WAITING_FOR_UPDATE new_sensor.adder = user new_sensor.latest_modifier = user new_sensor.save() create_new_sensor(new_sensor) return redirect('browse_sensors') else: new_sensor.delete() else: errors_sensor_form = True #If not post fill the form #Give initial values found = False for communication_type_class in AVAILABLE_COMMUNICATION_TECHNOLOGIES_CLASSES: if communication_type_class.objects.all().exists(): found = True communication_object = communication_type_class.objects.all()[0] communication_type = communication_object.__class__.__name__ break if not found: context = {'title':'You need to create communication object!', 'error_msg':'You need to create communication object before adding new sensors.'} return render(request, 'configurator/error.html', context) found = False for protocol_type_class in AVAILABLE_PROTOCOLS_CLASSES: if protocol_type_class.objects.all().exists(): found = True protocol_object = protocol_type_class.objects.all()[0] protocol = protocol_object.__class__.__name__ break if not found: context = {'title':'You need to add application layer protocol objects!', 'error_msg':'You need to create application layer protocol object before adding sensor.'} return render(request, 'configurator/error.html', context) if not Type_of_sensor.objects.all().exists(): context = {'title':'Not authorized!', 'error_msg':'You are not allowed to add sensor. Please contact admin to request rights to modify/add sensors.'} return render(request, 'configurator/error.html', context) initial_sensor_type = Type_of_sensor.objects.all()[0] available_sample_rates = Sample_rate.objects.filter(model=initial_sensor_type.pk) initial_sample_rate = available_sample_rates[0] available_sensitivities = initial_sample_rate.supported_sensitivities.all() initial_sensitivity = available_sensitivities[0] default_variables = Default_variable.objects.filter(type_of_sensor=initial_sensor_type) initial_data = [{'name': dv.name, 'unit': dv.unit} for dv in default_variables] modify_variable_forms = VariableFormSet(initial=initial_data) if user.auth_level >= 2: if not errors_sensor_form: add_sensor_form = AddSensorForm(prefix='add_sensor') if not errors: modify_communication_form = ModifyWlanForm(instance=communication_object, prefix='wlan') communication_instances = Wlan.objects.all() modify_protocol_form = ModifyHTTPForm(instance=protocol_object, prefix='http') protocol_instances = HTTP.objects.all() else: context = {'title':'Not authorized!', 'error_msg':'You are not allowed to add sensor. Please contact admin to request rights to modify/add sensors.'} return render(request, 'management/error.html', context) context = {'add_sensor_form' : add_sensor_form, 'available_sample_rates': available_sample_rates, 'current_sample_rate': initial_sample_rate.id, 'available_sensitivities': available_sensitivities, 'current_sensitivity': initial_sensitivity.id, 'current_communication_technology': communication_object.__class__.__name__, 'current_communication_id': communication_object.id, 'communication_instances': communication_instances, 'modify_communication_form': modify_communication_form, 'available_communication_technologies': AVAILABLE_COMMUNICATION_TECHNOLOGIES, 'current_protocol': protocol_object.__class__.__name__, 'current_protocol_id': protocol_object.id, 'protocol_instances': protocol_instances, 'modify_protocol_form': modify_protocol_form, 'available_protocols': AVAILABLE_PROTOCOLS, 'modify_variable_forms': modify_variable_forms, } return render(request, 'management/add_sensor.html', context)
def get_children_formset(self): if self.module.child_form: return formset_factory(self.module.child_form, can_delete=True, extra=1)(**self.get_children_formset_kwargs())
def _initialize_offer_preference_formset(internships_offers): offer_preference_formset = formset_factory(OfferPreferenceForm, formset=OfferPreferenceFormSet, extra=internships_offers.count(), min_num=internships_offers.count(), max_num=internships_offers.count(), validate_min=True, validate_max=True) return offer_preference_formset
def campaign_edit_target(request, listid, targetid): target = get_object_or_404(Target, id=targetid) targetlist = get_object_or_404(TargetList, id=listid) if targetlist.author not in request.user.swordphishuser.visible_users(): return HttpResponseForbidden() if not targetlist.targets.filter(id=targetid): return HttpResponseForbidden() targetform = NewTargetForm(instance=target) formset = formset_factory(AttributeForm, extra=0) attformset = formset(initial=target.attributes.all().values()) if request.method == "GET": return render( request, 'Main/Campaigns/Targets/edittarget.html', { 'targetlist': targetlist, 'targetid': targetid, 'targetform': targetform, 'attformset': attformset }) if request.method == "POST": targetform = NewTargetForm(request.POST) attformset = formset(request.POST) if not (targetform.is_valid() and attformset.is_valid()): return render( request, 'Main/Campaigns/Targets/edittarget.html', { 'targetlist': targetlist, 'targetid': targetid, 'targetform': targetform, 'attformset': attformset }) tl = targetlist.targets.filter( mail_address=targetform.cleaned_data["mail_address"]) for tar in tl: if tar.id != target.id: return render( request, 'Main/Campaigns/Targets/edittarget.html', { 'targetlist': targetlist, 'targetid': targetid, 'targetform': targetform, 'attformset': attformset, 'target_already_exists': True }) target.mail_address = targetform.cleaned_data["mail_address"] target.save() target.attributes.all().delete() for attform in attformset: target.addAttribute(attform.cleaned_data["key"], attform.cleaned_data["value"]) return HttpResponse("Ok") return HttpResponseForbidden()