def VariableFormsFactory(symbols, post=None): """A factory function to create variable input form for a specific variable. :symbols: A list of symbols representing variables :post: Is the form to be created with filled data from a POST req? :returns: A list of forms :rtype: List[AnalyticalProblemInputVariablesForm] """ forms = [] for symbol in symbols: if post is not None: form = AnalyticalProblemInputVariablesForm( symbol, { symbol + "_lower_bound": post[symbol + "_lower_bound"], symbol + "_upper_bound": post[symbol + "_upper_bound"], symbol + "_initial_value": post[symbol + "_initial_value"], }) else: form = AnalyticalProblemInputVariablesForm(symbol) forms.append(form) return forms
def _non_deleted_forms(self): forms = [] for form in self.fields_formset.forms: if form in self.fields_formset.deleted_forms: continue # skip deleted forms when generating query forms.append(form) return forms
def get_form_repr(self): """ :return: form representation of CSV file for use in add products view """ forms = [] lang_id = self.shop.api.default_lang categories = dict(self.shop.api.get_categories()) for order, line in enumerate(self.lines): name, category, price, quantity, desc = line.split(',') #Select proper category if str(category) not in categories.keys(): for k, v in categories.items(): if str(category).lower() == v.lower(): category = k break form = AttrDict(cleaned_data={}) form.cleaned_data = dict(langs = [dict(id=lang_id, name=name, link_rewrite=slugify2(name), product_desc=desc, product_desc_short=desc)], quantity = quantity, price= price, categories = [category], order=order) forms.append(form) return forms
def mk_role_forms(shift=None): forms = [] initial = mk_initial(shift) for rname, attrs in settings.CONTRACTOR_ROLES: # fdict = { '<group_name>', [(<fname>, <ftype>), ... ], ... } fdict = {} dynfields = {} dynfieldsets = [] for attr in attrs: grp_name, ftype = attr_info(attr) if grp_name in fdict: fdict[grp_name].append((attr, ftype)) else: fdict[grp_name] = [(attr, ftype)] for grp_name, _ in settings.ATTRIBUTES: if grp_name in fdict: fields = fdict[grp_name] newfields = dict(join(mk_fields(field, rname) for field in fields)) dynfields.update(newfields) dynfieldsets.append( (grp_name, {'fields': newfields.keys()}) ) forms.append( {'name': rname.replace('/', '-'), 'form': dyn_form(dynfields, initial, dynfieldsets)} ) return forms
def manage_access_forms(request, obj, permission_class, field): forms = [] can_create = Permission.objects.get( codename='can_create', content_type__app_label='{0}s'.format(field)) can_invite = Permission.objects.get( codename='can_invite', content_type__app_label='{0}s'.format(field)) can_manage = Permission.objects.get( codename='can_manage', content_type__app_label='{0}s'.format(field)) users = request.user.get_users() permissions = permission_class.objects.filter(**{ field: obj, "user__in": users }).select_related('permission', 'user') for user in users: forms.append( ManageAccessForm( request.POST or None, obj=obj, user=user, can_create=can_create, can_invite=can_invite, can_manage=can_manage, permissions=permissions, )) return forms
def make_forms_from_questionario(questionario, data=None): forms = [] questoes = questionario.get_questoes() random.shuffle(questoes) for questao in questoes: forms.append(questao.get_respostaForm(data=data, prefix='q%s' % questao.id)) return forms
def get_context_data(self, *args, **kwargs): context = super(AvioReservation, self).get_context_data(**kwargs) request = self.request id = self.kwargs.get('flight_id') fligth = Flight.objects.get(pk=id) seat_type = request.session['seat_type'] querry = Seat.objects.filter(flight=id) seats = querry.filter( seat_type=seat_type[0]).order_by('seat_number').values_list( 'seat_status', 'seat_number') context['flight'] = fligth context['num_seats'] = request.session['num_seats'] context['seat_type'] = seat_type context['seats'] = json.dumps(list(seats)) context['s'] = querry.filter(seat_type=seat_type[0], seat_status="F").order_by('seat_number') forms = [] for x in range(int(request.session['num_seats'])): f = DateReservationForm(request.user, context['s'], prefix=x) if x == 0: f.fields['person'].disabled = True f.fields['passport'].required = True f.fields['first_name'].initial = request.user.first_name f.fields['last_name'].initial = request.user.last_name forms.append(f) context['form'] = forms return context
def get_forms(cls, request, kwargs={}): form = cls(request.POST, **kwargs) id_name = form.add_prefix('id') form_ids = [ key[len(id_name) - 1:] for key in request.POST.keys() if key.startswith(id_name[:-1]) ] forms = FormCollection() for form_id in form_ids: new_kwargs = dict(kwargs.items() + [('postfix', form_id), ('id', request.POST[id_name[:-1] + form_id])]) form = cls(request.POST, **new_kwargs) if not form.id: # Ignore empty forms where no core field is specified core_available = False for core in form.core: if request.POST.get(form.add_prefix(core), ''): core_available = True break if form.id or core_available: forms.append(form) return forms
def currentdistro(request): if request.method == "POST": instance = AutoTorrent.objects.get(id=request.POST['id']) form = AutoTorrentForm(request.POST or None, instance=instance) if form.is_valid(): model_instance = form.save(commit=False) model_instance.save() form.save_m2m() link = AutoTorrent.objects.get(id=model_instance.id).url exclude_list = AutoTorrent.objects.get(id=model_instance.id).excludes.all().values_list('phrase', flat=True) r = requests.get(link, verify=False) data = [x[1] for x in re.findall('(src|href|HREF|SRC)="(\S+)"',r.content)] links = filter(lambda x:x.endswith(".torrent"), data) torrent_links = [urljoin(link,l) if 'http' not in l else l for l in links] torrent_links = [l for l in torrent_links if not any(ex.lower() in l.lower() for ex in exclude_list)] for torrent in torrent_links: filedl = requests.get(torrent, stream=True, verify=False) with open('/data/downloads/torrents/' + torrent.split('/')[-1], 'wb') as f: for chunk in filedl.iter_content(chunk_size=1024): if chunk: # filter out keep-alive new chunks f.write(chunk) return HttpResponseRedirect(reverse('currentdistro')) forms = [] current_autotorrents = AutoTorrent.objects.all() for torrent in current_autotorrents: forms.append(AutoTorrentForm(None, instance=torrent)) return render_to_response('currentdistro.html', { 'username' : request.user, 'forms': forms }, context_instance=RequestContext(request))
def get(self): user = check_privileged(self) if not user: return go = self.request.get('go') if go: # render applet page template_values = {'DOC_ROOT':settings.DOC_ROOT} configs = self._get_forms() params = [] for key in self.FORMS: if configs[key].value: params.append(configs[key]) template_values['params'] = params self.response.out.write(template.render('static/admin_publish_applet.html', template_values)) else: # render settings entities = self._get_forms() forms = [] # this way, we get them in order for key in self.FORMS: forms.append(SettingForm(instance=entities[key], prefix=key)) template_values = { 'action':self.request.uri, 'forms':forms } self.response.out.write(template.render('static/admin_publish.html', template_values))
def get_forms(cls, request, kwargs={}): form = cls(request.POST, **kwargs) id_name = form.add_prefix('id') form_ids = [key[len(id_name) - 1:] for key in request.POST.keys() if key.startswith(id_name[:-1])] forms = FormCollection() for form_id in form_ids: new_kwargs = dict(kwargs.items() + [('postfix', form_id), ('id', request.POST[id_name[:-1] + form_id])]) form = cls(request.POST, **new_kwargs) if not form.id: # Ignore empty forms where no core field is specified core_available = False for core in form.core: if request.POST.get(form.add_prefix(core), ''): core_available = True break if form.id or core_available: forms.append(form) return forms
def forms(request): """ List of all the forms on the site """ xforms = XForm.on_site.all().exclude(keyword__in=[ 'store', 'send', 'cash', 'sc', 'cherry', 'lookup', 'rec', 'return', 'sum', 'test' ]).order_by('keyword') forms = [] for form in xforms: fields = form.fields.all() constraints = [] for field in fields: for constraint in field.constraints.all(): constraints.append(constraint) forms.append({ 'form': form, 'fields': form.fields.all(), 'constraints': constraints }) reports = None return render_to_response( "responses/forms.html", { 'xforms': xforms, 'forms': forms, 'reports': reports, 'helps': HelpMessage.objects.all().order_by('-priority') }, context_instance=RequestContext(request))
def menu(request): user_id = request.session.get('LOGIN_USER_ID') user_name = request.session.get('LOGIN_USER_NAME') if request.method == 'GET': msites = None msites = MSite.objects.filter(user_id=user_id).order_by('site_name') forms = [] if msites is not None: for msite in msites: msite_data = { 'id': msite.id, 'site_name': msite.site_name, 'login_user_id': msite.login_user_id, 'login_user_pw': msite.login_user_pw, 'site_url': msite.site_url, } forms.append(msite_data) context = { 'user_id': user_id, 'user_name': user_name, 'forms': forms, 'msites': msites, } return render(request, 'amaterasu/menu.html', context)
def get_embedded_forms(self): """ Return a list of embedded forms. """ if not hasattr(self, '_embedded_forms'): # collect pk-field names i = 1 pk_fields = [] while True: # we should have at least a seq field for each row prefix = self.get_prefix(i) seq_field = '%s-seq' % prefix if seq_field not in self._form.data and i > self.initial_rows: break pk_fields.append('%s-pk' % prefix) i += 1 # collect all pks pks = [] for pk_field in pk_fields: if pk_field in self._form.data: pks.append(self._form.data[pk_field]) # load all model references (one query), if this is a model if issubclass(self.model, models.Model): instances = self.model.objects.in_bulk(pks) else: instances = {} # construct list of forms and validate forms = [] is_valid = True for i, pk_field in enumerate(pk_fields, start=1): if pk_field in self._form.data: pk = self._form.data[pk_field] try: pk = int(pk) except ValueError: pass instance = instances.get(pk) else: instance = self.model() # create form # validate on post form = self.get_embedded_form(i, instance) if self._request.method == 'POST': if not form.is_valid(): is_valid = False forms.append(form) # only cache if valid self._embedded_forms = forms self._is_valid = is_valid return self._embedded_forms, self._is_valid
def forms(self): forms = super(BaseInlineFormSetWithEmpty, self).forms for form in forms: form.empty = False empty = self.empty_form # for use by javascript empty.empty = True forms.append(empty) return forms
def render_variation_form(variation): prefix = "existing_{}".format(variation.id) if request.POST: form = VariationConfigForm(request.POST, prefix=prefix) else: form = VariationConfigForm(prefix=prefix, initial={'exist': True}, instance=variation) forms.append(form) return render_form(form)
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
def render_empty_form(product, size): prefix = "new_{}_{}".format(product.id, size.id) if request.POST: form = VariationConfigForm(request.POST, prefix=prefix) else: form = VariationConfigForm(prefix=prefix, initial={'product': product, 'size': size, 'exist': False}) forms.append(form) return render_form(form)
def labeled_forms(self): forms = [] label_format = self.label + " %d" for i in range(len(self.forms)): forms.append({ "label": label_format % (i + 1), "form": self.forms[i] }) return forms
def forms(self): """ Instatiates one form for each answer. """ forms = [] for i, answer in enumerate(self.exercise.answer_set.all()): initial = {'answer': answer} forms.append(self._construct_form(i, initial=initial)) return forms
def forms_for_survey(survey, request='testing', submission=None): testing = bool(request == 'testing') session_key = "" if testing or not request.user.is_authenticated() else request.session.session_key.lower() post = None if testing else request.POST or None files = None if testing else request.FILES or None main_form = SubmissionForm(survey, data=post, files=files) forms = [main_form] for q in survey.questions.all().order_by("order"): forms.append(_form_for_question(q, session_key, submission, post, files)) return forms
def bind(self, data=None, files=None, initial=None): forms = [] for i, Form in enumerate(self.formclasses): prefix = self.prefix_for_form(i) form = Form(prefix=prefix, data=data, files=files, initial=initial) forms.append(form) self.forms = forms self.data = data self.files = files self.initial = initial or self.initial return self
def forms(self): """ Instantiate forms at first property access. Change: Allow passing of additional kwargs to form instance upon init """ # DoS protection is included in total_form_count() forms = [self._construct_form(i, **{'model_fields': self.model_fields}) for i in xrange(self.total_form_count())] forms.append(self.empty_form) # add initial empty form return forms
def initialize_form(self, instance, model, data=None, extra=None): """ Takes a "finalized" query and generate it's form data """ model_fields = self.get_fields_from_model(model, self._filter_fields) forms = [] if instance: for field_data in instance.list_fields(): forms.append(AdvancedFilterQueryForm._parse_query_dict(field_data, model)) formset = AFQFormSetNoExtra if extra is None else AFQFormSet self.fields_formset = formset(data=data, initial=forms or None, model_fields=model_fields)
def get_row_forms(self): if not hasattr(self, '_forms'): forms = [] rows = read_csv_file( self.cleaned_data['import_file'], self.csv_headers, skip_lines=self.skip_lines) for row in rows: forms.append(self.line_form_class(row)) self._forms = forms return self._forms
def forms_as_choices(self): forms = [] for wp in FormsWorkspace.objects.all(): new_form = [] sub_forms = [] for form in wp.formsform_set.all(): sub_forms.append([form.pk, form.name]) new_form = [wp.name, sub_forms] forms.append(new_form) return forms
def forms(self): """ Instantiate forms at first property access. Change: Allow passing of additional kwargs to form instance upon init """ # DoS protection is included in total_form_count() forms = [ self._construct_form(i, **{'model_fields': self.model_fields}) for i in xrange(self.total_form_count()) ] forms.append(self.empty_form) # add initial empty form return forms
def get_select_binfield_forms(bs, num, initials): forms = [] choices = [] bf_ids = [] for bf in BinField.objects.filter(bs=bs): choices.append((bf.id, bf.label)) for i in range(num): sel_bf = SelectBinFieldForm(choices, 'Field') if len(initials) is num: sel_bf.fields['bf'].initial = initials[i] bf_ids.append(sel_bf.fields['bf'].initial) forms.append(sel_bf) return forms, bf_ids
def serialize_report(report): """Convert a report instance to form field dict {id_field_name: field_val}""" report_form = ReportForm(initial=report.base_opts) forms = [report_form] if report.filter_class: filter_set = report.filter_class(report.report_opts) filter_form = filter_set.get_form_class()(initial=report.report_opts) forms.append(filter_form) form_data = serialize_forms(forms) return form_data
def assertNoFormErrors(self, response): if response.context is None: return # if all went well the request probably redirected, # otherwise, there will be form objects with errors: forms = [] for ctx in response.context: for cdict in ctx: for v in cdict.values(): if isinstance(v, django.forms.BaseForm): forms.append(v) for form in forms: self.assertEquals(form.errors.as_text(), "")
def fc_get_forms_from_POST(self, request): forms = [] # What prefixes are there? prefixes = [p for p in request.POST.get('fc-prefixes', '').split(',') if p] # Loop through each submitted item and process its data. for p in prefixes: # Check the PK for this prefix pk = request.POST.get('{}-pk'.format(p), None) # If this prefix is for an existing item, load its data. instance = None if pk: try: instance = (BaseItem.objects.filter(pk=pk). select_subclasses()[:1][0]) except IndexError: message = ("Form reported update of BaseItem with id {}, " "but no such BaseItem exists.".format(pk)) raise ValueError(message) # We need to copy the POST data so it can be updated (QueryDicts # are immutable). Plus, there's less redundant data. # Append a hypen to the prefix. Django does this in the form, but # we need to prevent getting fc-item-10 when we ask for fc-item-1, # and adding the hyphen will avoid that. search_prefix = '{}-'.format(p) # Assemble a dictionary of only this form's data. this_form_data = dict([(k, v) for (k, v) in request.POST.items() if k.startswith(p)]) # Alright, it's time to create the form! If we found an instance, # use that to create it. if isinstance(instance, BaseItem): form = instance.get_form(data=this_form_data, files=request.FILES, prefix=p) # Otherwise, we'll have to get the model from the content type # field first. else: model_class = self.fc_get_form_model_by_prefix(request, p) form = model_class().get_form(data=this_form_data, files=request.FILES, prefix=p) # Append the form to the end of the list. forms.append(form) return forms
def initialize(self, initial=None, instance=None, **kwargs): forms = [] self.instance = instance or self.instance or None self.initial = initial or self.initial or None #assert False, self.initial form_initial = {} for i, Form in enumerate(self.formclasses): prefix = self.prefix_for_form(i) if self.initial is not None: form_initial = self.initial.get(force_text(i), {}) form = Form(prefix=prefix, initial=form_initial) forms.append(form) self.forms = forms return self
def prepare_applicant_forms(applicant, names, results, post_data=None): forms = [] for n, res in zip(names, results): if res != None: initial = { 'is_passed': res.is_passed, 'applicant_note': res.applicant_note, 'internal_note': res.internal_note, 'is_submitted': True } else: initial = None forms.append(ReviewResultForm(post_data, prefix=n, initial=initial)) return forms
def get_extra_model(category_id=None, data=None, advert=None): """magic of OOP""" if int(category_id) is 0: if advert: category_id = advert.category.pk forms = [] for form in FORM_BY_CAT.get(int(category_id), [ NoneForm, ]): if data and not advert: # if isset post request forms.append(form(data=data)) else: if advert: # if we do redact the advert for additional model frm = form() exstra = frm._meta.model try: exstra, c = exstra.objects.get_or_create(advert=advert) forms.append(form(data=data, instance=exstra)) except exstra.DoesNotExist: print "F**K!!!" exstra = frm._meta.model forms.append(form()) else: forms.append(form()) return forms
def test_step_forms(request): if request.method == "POST": data = request.POST print(data) context = {} forms = [] for st in StepType.objects.all(): forms.append(StepForm(step_type_id=st.pk)) context['forms'] = forms # return render(request, 'flowapp/test_forms.html', context) # context = {} context['step_types'] = StepType.objects.all() return render(request, 'flowapp/test_forms.html', context)
def prepare_applicant_forms(applicant, names, results, post_data=None): forms = [] for n, res in zip(names, results): if res!=None: initial={'is_passed': res.is_passed, 'applicant_note': res.applicant_note, 'internal_note': res.internal_note, 'is_submitted': True } else: initial=None forms.append(ReviewResultForm(post_data, prefix=n, initial=initial)) return forms
def initialize_form(self, instance, model, data=None, extra=None): """ Takes a "finalized" query and generate it's form data """ model_fields = self.get_fields_from_model(model, self._filter_fields) forms = [] if instance: for field_data in instance.list_fields(): forms.append( AdvancedFilterQueryForm._parse_query_dict( field_data, model)) formset = AFQFormSetNoExtra if not extra else AFQFormSet self.fields_formset = formset(data=data, initial=forms or None, model_fields=model_fields)
def partial_update(self): all_valid = True error_list = [] forms = [] for instance in self.get_filtered_queryset(): valid, form, errors = self.check_partial_update_instance( update_data=self.get_request_body(), instance=instance) all_valid = valid and all_valid error_list.append(errors) forms.append(form) if not all_valid: raise BaseHttpException(json.dumps(error_list)) return self.get_filtered_queryset().update(**self.get_request_body())
def forms(self): """ Формируем формы товаров. """ forms = [] for item in self.cart: defaults = { 'data': self.data or None, 'prefix': self.add_prefix(item.id), 'instance': item, } form = ItemForm(**defaults) forms.append(form) return forms
def empty_forms(self): """ Return all possible empty forms """ forms = [] for model, form_class in self.child_forms.items(): kwargs = self.get_form_kwargs(None) form = form_class(auto_id=self.auto_id, prefix=self.add_prefix('__prefix__'), empty_permitted=True, **kwargs) self.add_fields(form, None) forms.append(form) return forms
def get_rebookitem_forms(self): forms = [] index = 0 for stock in self.stocks: data = {} if self.request.method == "POST": amount = self.request.POST.getlist("amount")[index] data["amount"] = amount form = RebookOrderItemForm(data=data) form.instance.stock = stock form.instance.position = stock.lagerplatz form.instance.sku = stock.sku_instance forms.append((form, stock)) index += 1 return forms
def reserve_week(self, request, year, week): is_forbidden = self.app.check_forbidden( request, ["view", "create"]) if is_forbidden: return is_forbidden year, week = int(year), int(week) weekdays = dayplanner.get_weekdays(year, week) monthu = weekdays[:4] fri = weekdays[4] def new_object(**kwargs): our_kwargs = dict(kwargs, **{"person": request.user, "namespace": self.app.namespace}) return self.reservation_model(**our_kwargs) if request.method == "POST": forms = [] for i, date in enumerate(monthu): forms.append(self.day_form(request.POST, date=date, prefix=i, queryset=self.app.queryset, new_object=new_object)) forms.append(self.friday_form(request.POST, date=fri, prefix=i+1, queryset=self.app.queryset, new_object=new_object)) if all(f.is_valid() for f in forms): for form in forms: form.save() return self.http.HttpResponseRedirect( self.app.reverse("browse_week", { "year": year, "week": week})) else: forms = [] for i, date in enumerate(monthu): forms.append(self.day_form( date=date, prefix=i, queryset=self.app.queryset, new_object=new_object)) forms.append(self.friday_form( date=fri, prefix=i+1, queryset=self.app.queryset, new_object=new_object)) return self.app.get_response( request, template="reserve_week", context={"forms": forms, "app_name": self.app.get_app_name()})
def get_list(enrollment, *args, **kwargs): # load up some datums fees = Fee.objects.filter(term=enrollment.term, population=enrollment.population) # setup fee forms forms = [] for fee in fees: form = WaiverForm(fee, enrollment.student, prefix=str(fee.pk), *args, **kwargs) waiver = fee.feewaiver_set.filter(student=enrollment.student) if waiver.count(): form.set_current(waiver.get()) forms.append(form) forms.sort(cmp=lambda x, y: x.fee.pk < y.fee.pk) return forms
def empty_forms(self): """ Return all possible empty forms """ forms = [] for model, form_class in self.child_forms.items(): kwargs = self.get_form_kwargs(None) form = form_class( auto_id=self.auto_id, prefix=self.add_prefix('__prefix__'), empty_permitted=True, **kwargs ) self.add_fields(form, None) forms.append(form) return forms
def empty_forms(self): """ Return all possible empty forms """ forms = [] for model, form_class in self.child_forms.items(): if django.VERSION >= (1, 9): kwargs = self.get_form_kwargs(None) # New Django 1.9 method else: kwargs = {} form = form_class( auto_id=self.auto_id, prefix=self.add_prefix("__prefix__"), empty_permitted=True, **kwargs ) self.add_fields(form, None) forms.append(form) return forms
def get_formset_dict(self, form): nested_dict = {} # handle the empty form empty_form = form.empty_form empty_form.fields['id'].choices = [] empty_form = RemoteForm(empty_form).as_dict() # create a dict to hold our forms nested_dict[form.prefix] = { 'empty_form': empty_form, 'management_form': self.process_nested_form(form.management_form) } for formset_form in form.forms: formset_form.fields['id'].choices = [] # formset adds choices to the id, which can make for some ugly long queries forms = nested_dict[form.prefix].setdefault('forms', []) forms.append(self.process_nested_form(formset_form)) return nested_dict
def _all_forms(self): forms = [] unknown_forms = [] for f in get_exports_by_form(self.domain): form = f["value"] if form.get("app_deleted") and not form.get("submissions"): continue if "app" in form: form["has_app"] = True forms.append(form) else: app_id = f["key"][1] or "" form["app"] = {"id": app_id} form["has_app"] = False form["show_xmlns"] = True unknown_forms.append(form) forms.extend(self._attach_unknown_suggestions(unknown_forms)) return sorted(forms, key=self._sorkey_form)
def add_view(request): forms=[] for i in range(0,10): form=CustAddForm(initial={'category': Category.objects.get(id=1)}) forms.append(form) if request.method=='POST': try: print('post request made in add_view') print(request.POST['image']) entry=Entry(image=request.POST['image'], category=Category.objects.get(id=1)) entry.save() except: print('there was an error form not saved') print forms[0] c={} c['forms']=forms c.update(csrf(request)) return render_to_response('Rate/add_images.html',c)
def construct_section_forms(post_data=None, culture_obj=None, section_obj=None): """Constructs a form for the given culture, section, with the specified post data""" assert culture_obj assert section_obj forms = [] # get all existing Responses responses = {} source1 = {} for r in Response.objects.all().filter( culture=culture_obj, question__section=section_obj): responses[r.question_id] = r source1[r.question_id] = r.source1 # loop over questions in this section and inject with existing # responses & post data for q in Question.objects.all().order_by('number').filter(section=section_obj): formtype = FORM_MAP[q.response_type] # manipulate response to constrain cultures/questions resp = responses.get(q.id) s = source1.get(q.id) if resp is not None: resp.culture = culture_obj resp.question = q resp.source1 = s # create a form, injecting POST data form = formtype( post_data, instance=resp, initial={'culture': culture_obj, 'question': q}, prefix=q.id ) # add correct choices for OptionForms if formtype == OptionResponseForm: form.fields['response'].choices = q.get_choices(with_empty=True) # add these here so I can get them in the template. form.qnumber = q.number form.qinformation = q.information form.qtext = q.question form.qresponsetype = q.response_type forms.append(form) return forms
def render_deleted(self): forms = [] self.forall_forms(lambda f: forms.append(f), include_adds=True) out = [] for form in forms: for f in form: out.append(f.as_hidden()) return mark_safe('\n'.join(out))
def fc_get_forms(self, request, obj=None): """ Use the request to get the forms that should be rendered to the page. """ forms = [] # Are they POSTing data, or should we merely get it from the DB? if request.method == 'POST': forms = self.fc_get_forms_from_POST(request) # If this is a GET on an existing area. elif obj: for i in obj.items: prefix = get_form_prefix(len(forms) + 1) forms.append(i.get_form(prefix=prefix)) # If this is a GET on an area's ADD page. else: forms = [] return forms
def _all_forms(self): forms = [] unknown_forms = [] for f in get_exports_by_form(self.domain): form = f['value'] if form.get('app_deleted') and not form.get('submissions'): continue if 'app' in form: form['has_app'] = True forms.append(form) else: app_id = f['key'][1] or '' form['app'] = { 'id': app_id } form['has_app'] = False form['show_xmlns'] = True unknown_forms.append(form) forms.extend(self._attach_unknown_suggestions(unknown_forms)) return sorted(forms, key=self._sorkey_form)
def vote(request, name): poll = poll_Es.poll_by_name(name) if not poll: raise Http404 filling = poll.filling_for(request.user) initial = False if not filling: initial = True filling = poll_Es.Filling({'user': _id(request.user), 'poll': _id(poll), 'answers': [None] * len(poll.questions)}) allValid = True forms = [] # question forms for q_id, question in enumerate(poll.questions): form_kwargs = {'prefix': str(q_id)} answer = filling.answers[q_id] if answer is None: answer = -1 form_kwargs['initial'] = {'answer': answer} if request.method == 'POST': form = create_questionForm(question)(request.POST, **form_kwargs) if not form.is_valid(): allValid = False else: form = create_questionForm(question)(**form_kwargs) forms.append(form) if request.method == 'POST' and not poll.is_open: messages.error(request, _("De enquete is gesloten")) elif allValid and request.method == 'POST': messages.info(request, _("Veranderingen opgeslagen!")) for q_id, form in enumerate(forms): filling.answers[q_id] = int(form.cleaned_data['answer']) filling.date = datetime.datetime.now() filling.save() return render_to_response( 'poll/vote.html', {'forms': forms, 'poll': poll, 'initial': initial}, context_instance=RequestContext(request) )
def vote(request, name): poll = poll_Es.poll_by_name(name) if not poll: raise Http404 filling = poll.filling_for(request.user) initial = False if not filling: initial = True filling = poll_Es.Filling( {"user": _id(request.user), "poll": _id(poll), "answers": [None] * len(poll.questions)} ) allValid = True forms = [] # question forms for q_id, question in enumerate(poll.questions): form_kwargs = {"prefix": str(q_id)} answer = filling.answers[q_id] if answer is None: answer = -1 form_kwargs["initial"] = {"answer": answer} if request.method == "POST": form = create_questionForm(question)(request.POST, **form_kwargs) if not form.is_valid(): allValid = False else: form = create_questionForm(question)(**form_kwargs) forms.append(form) if request.method == "POST" and not poll.is_open: messages.error(request, "De enquete is gesloten") elif allValid and request.method == "POST": messages.info(request, "Veranderingen opgeslagen!") for q_id, form in enumerate(forms): filling.answers[q_id] = int(form.cleaned_data["answer"]) filling.date = datetime.datetime.now() filling.save() return render_to_response( "poll/vote.html", {"forms": forms, "poll": poll, "initial": initial}, context_instance=RequestContext(request) )
def contest_vote(request, context): contest = context['object'] forms = [] forms_are_valid = True # question forms for question in contest.questions: form = QuestionForm(question)(request.POST or None, prefix=str(question.id)) if not form.is_valid(): forms_are_valid = False forms.append((question, form)) # contestant form initial = {} if request.user.is_authenticated(): initial['name'] = request.user.first_name initial['surname'] = request.user.last_name initial['email'] = request.user.email contestant_form = ContestantForm(request.POST or None, initial=initial) if not contestant_form.is_valid(): forms_are_valid = False # saving contestant if forms_are_valid and contest.is_active(): return contest_finish(request, context, forms, contestant_form) context.update({ 'forms' : forms, 'contestant_form' : contestant_form, 'activity_not_yet_active' : polls_settings.ACTIVITY_NOT_YET_ACTIVE, 'activity_active' : polls_settings.ACTIVITY_ACTIVE, 'activity_closed' : polls_settings.ACTIVITY_CLOSED }) return render_to_response( get_templates_from_placement('form.html', context['placement']), context, context_instance=RequestContext(request) )
def post(self): user = check_privileged(self) if not user: return entities = self._get_forms() forms = [] # this way, we get them in order for key in self.FORMS: entities[key].name = key f = SettingForm(instance=entities[key], prefix=key, data=self.request.POST) value = f.data['%s-value'%key] if f.is_valid() and value and len(value): entity = f.save(commit=False) entity.name = key entity.put() forms.append(f) template_values = { 'action':self.request.uri, 'forms':forms } self.response.out.write(template.render('static/admin_publish.html', template_values))