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 _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(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_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 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))
