def get_form_kwargs(self):
""" Setup additional kwargs for the form """
kwargs = FormView.get_form_kwargs(self)
kwargs["request"] = self.request
kwargs["initial"]["win"] = self.kwargs["win_id"]
return kwargs
def form_valid(self, form):
"""Create operation with optional splits."""
self.form = form
date = form.cleaned_data['date']
if form.cleaned_data['splits'] == 1:
models.Operation.objects.create(
account=form.cleaned_data['account'],
transaction=form.cleaned_data['transaction'],
date=date,
amount=form.cleaned_data['amount'],
description=form.cleaned_data['description'],
)
else:
splits = split_amount(
form.cleaned_data['amount'],
form.cleaned_data['splits'])
for position, amount in enumerate(splits):
description = u'{desc} ({total}/{splits}, part {pos})'.format(
desc=form.cleaned_data['description'],
pos=position + 1,
splits=form.cleaned_data['splits'],
total=form.cleaned_data['amount'])
models.Operation.objects.create(
account=form.cleaned_data['account'],
transaction=form.cleaned_data['transaction'],
date=date + relativedelta(months=position),
amount=amount,
description=description,
)
return FormView.form_valid(self, form)
def form_valid(self, form):
try:
pos=self.add_logger(form.cleaned_data)
self.success_url='/net/added/{}'.format(pos.pk)
except IntegrityError as e:
raise ValidationError(e)
return FormView.form_valid(self, form)
def get_context_data(self, **kwargs):
context = super(BaseAccessListLab, self).get_context_data(
**kwargs)
context.update(FormView.get_context_data(self, **kwargs))
context['role'] = self.role
context['user_create_form'] = self.user_create_form()
return context
def get_form_kwargs(self):
""" Setup additional kwargs for the form """
kwargs = FormView.get_form_kwargs(self)
kwargs["request"] = self.request
kwargs["initial"]["win"] = self.kwargs["win_id"]
return kwargs
def form_valid(self, form):
csv_file = form.cleaned_data.get("csv_file")
df = pandas.read_excel(csv_file)
df.dropna(how="all", inplace=True)
for i in range(len(df)):
try:
exam_name = df['quiz'][i]
q_category = df['category'][i]
q_subcategory = df['sub_category'][i]
exam, crt = Exam.objects.get_or_create(name=exam_name, exam_type=Exam.EXAM)
q_text = df['content'][i]
q_explanation = df['explanation'][i]
correct_answer_text = df['correct'][i]
wrong_1 = df['answer1'][i]
wrong_2 = df['answer2'][i]
wrong_3 = df['answer3'][i]
if q_text != "n" and correct_answer_text != "n" and str(q_text) != "nan" and q_text != " ":
q, crt = Question.objects.get_or_create(exam=exam, text=q_text)
if crt:
q.explanation = q_explanation
q.text = q_text
q.category = q_category
q.subcategory = q_subcategory
q.save()
Answer.objects.create(question=q, text=correct_answer_text, correct=True)
Answer.objects.create(question=q, text=wrong_1)
Answer.objects.create(question=q, text=wrong_2)
Answer.objects.create(question=q, text=wrong_3)
except:
print("Skip row")
messages.info(self.request, "your exam data imported successfully.")
return FormView.form_valid(self, form)
def form_valid(self, form):
response = FormView.form_valid(self, form)
# After successful login, save dict of user data given by data server
# API into JWT cookie. Also save session id of session from data
# server, for use when making requests to data server via Rabbit.
# Note UI server and admin server have different secrets and domains.
jwt_val = jwt.encode(
{
"user": form.user,
"session": form.session_cookie.value
},
settings.COOKIE_SECRET,
)
expires = datetime.fromtimestamp(form.session_cookie.expires)\
.strftime('%a, %d %b %Y %H:%M:%S')
kwargs = {
'value': jwt_val,
'expires': expires,
'secure': settings.SESSION_COOKIE_SECURE,
'httponly': True,
'domain': cookie_domain(),
}
response.set_cookie("alice", **kwargs)
return response
def get_context_data(self, **kwargs):
""" Get Win data for use in the template """
context = FormView.get_context_data(self, **kwargs)
context.update({"win": self.win_dict})
context['win']['date'] = date_parser(self.win_dict['date'])
return context
def get_context_data(self, **kwargs):
context = super(BaseAccessListLab, self).get_context_data(
**kwargs)
context.update(FormView.get_context_data(self, **kwargs))
context['role'] = self.role
context['user_create_form'] = self.user_create_form()
return context
def get_context_data(self, **kwargs):
""" Get Win data for use in the template """
context = FormView.get_context_data(self, **kwargs)
context.update({"win": self.win_dict})
context['win']['date'] = date_parser(self.win_dict['date'])
return context
def get_context_data(self, **kwargs):
# Needed since Django 1.9 because get_context_data is no longer called
# with the form instance
if "form" not in kwargs:
kwargs["form"] = self.get_form()
kwargs = ArticleMixin.get_context_data(self, **kwargs)
kwargs.update(FormView.get_context_data(self, **kwargs))
return kwargs
def get_context_data(self, **kwargs):
ctx = FormView.get_context_data(self, **kwargs)
basket = self.request.basket # type: shoop.front.basket.objects.BaseBasket
ctx["basket"] = basket
errors = list(basket.get_validation_errors(shop=self.request.shop))
ctx["errors"] = errors
ctx["orderable"] = (not errors)
return ctx
def post(self, request, *args, **kwargs):
print("bamboo.views.page.create.CreateView.post ")
print(request.POST)
page_form = PageForm(request.POST)
print("bamboo.views.page.create.CreateView.post page_form")
print(page_form)
page_form.save()
return FormView.post(self, request, *args, **kwargs)
def get_context_data(self, **kwargs):
ctx = FormView.get_context_data(self, **kwargs)
basket = self.request.basket # type: shoop.front.basket.objects.BaseBasket
ctx["basket"] = basket
errors = list(basket.get_validation_errors(shop=self.request.shop))
ctx["errors"] = errors
ctx["orderable"] = (not errors)
return ctx
def get(self, request, *args, **kwargs):
# if only single payment method, store that
# and then follow default (redirect to preview)
# else show payment method choice form
if len(settings.OSCAR_PAYMENT_METHODS) == 1:
self.checkout_session.pay_by(settings.OSCAR_PAYMENT_METHODS[0][0])
return redirect(self.get_success_url())
else:
return FormView.get(self, request, *args, **kwargs)
def post(self, request, *args, **kwargs):
form = CommentForm(request.POST)
blog = self.get_object()
if form.is_valid():
form = form.save(commit=False)
form.user = request.user
form.blog_id = blog.id
form.save()
return FormView.post(self, request, *args, **kwargs)
def get_context_data(self, **kwargs):
ctx = FormView.get_context_data(self, **kwargs)
basket = self.request.basket # type: shoop.front.basket.objects.BaseBasket
ctx["basket"] = basket
basket.calculate_taxes()
errors = list(basket.get_validation_errors())
ctx["errors"] = errors
ctx["orderable"] = not errors
return ctx
def get(self, request, *args, **kwargs):
""" a safe guard to make sure that user is already authenticated
:returns: if user is authenticated return form page OR return to form user login
using overiding @method_decorator(login_required)
"""
self.args=args
if self.request.user.is_authenticated():
return FormView.get(self, request, *args, **kwargs)
def post(self, request, *args, **kwargs): return FormView.post(self, request, *args, **kwargs) if not request.user.is_authenticated: return HttpResponseForbidden() self.object = self.get_object() form = self.get_form() if form.is_valid(): return self.form_valid(form) else: return self.form_invalid(form)
def get_initial(self):
initial = FormView.get_initial(self)
for field_name in ['title', 'content']:
session_key = 'unsaved_article_%s_%d' % (field_name,
self.article.id)
if session_key in self.request.session:
content = self.request.session[session_key]
initial[field_name] = content
del self.request.session[session_key]
return initial
def get_form_view(file, form):
return FormView.as_view(
form_class=form,
template_name='misc/resource_password.html',
extra_context={
'title':
'Password required',
'content':
f'The file <code>{escape(file.name)}</code> has been password '
'protected by its owner.',
},
)
def dispatch(self, request, *args, **kwargs):
""" Override dispatch to do some checks before displaying form """
# quick hack to show sample customer response form with known test win
if request.path.endswith('sample/'):
kwargs['win_id'] = os.getenv('SAMPLE_WIN', 'notconfigured')
self.kwargs['win_id'] = kwargs['win_id']
self.sample = True
try:
self.win_dict = self._get_valid_win(kwargs["win_id"], request)
except self.SecurityException as e:
return self._deny_access(request, message=str(e))
return FormView.dispatch(self, request, *args, **kwargs)
def dispatch(self, request, *args, **kwargs):
""" Override dispatch to do some checks before displaying form """
# quick hack to show sample customer response form with known test win
if request.path.endswith('sample/'):
kwargs['win_id'] = os.getenv('SAMPLE_WIN', 'notconfigured')
self.kwargs['win_id'] = kwargs['win_id']
self.sample = True
try:
self.win_dict = self._get_valid_win(kwargs["win_id"], request)
except self.SecurityException as e:
return self._deny_access(request, message=str(e))
return FormView.dispatch(self, request, *args, **kwargs)
def get_context_data(self, **kwargs):
context = FormView.get_context_data(self, **kwargs)
form = context["form"]
headers = []
context["page_label"] = form.cleaned_data["page_label"]
context["contents"] = []
if form.is_valid():
f = io.StringIO(
form.cleaned_data["csv_file"].read().decode('utf-8'))
csv_reader = csv.reader(f, delimiter=',')
headers = next(csv_reader)
for row in csv_reader:
content = OrderedDict({})
for i, header in enumerate(headers):
content[header] = row[i]
context["contents"].append(content)
return context
def form_valid(self, form):
# Create signature instance in local DB.
SignatureType = django_anysign.get_signature_type_model()
Signature = django_anysign.get_signature_model()
Signer = django_anysign.get_signer_model()
signature_type, created = SignatureType.objects.get_or_create(
signature_backend_code='dummysign')
signature = Signature.objects.create(signature_type=signature_type)
Signer.objects.create(signature=signature)
logger.debug(
'[django_anysign_demo] Signature ID={id} created in local DB'
.format(id=signature.id))
# Register signature in backend's DB.
signature.signature_backend.create_signature(signature)
# Remember the signature object for later use (:meth:`get_success_url`)
self.signature = signature
# Handle the form as always.
return FormView.form_valid(self, form)
def get_context_data(self, **kwargs):
context = FormView.get_context_data(self, **kwargs)
context["travels"] = self.request.session["travels"]
total = 0
for travel in context["travels"]:
total += float(travel["go"]["travel_price"])
if "return" in travel and travel["return"]:
total += float(travel["return"]["travel_price"])
context["total"] = total
if self.order_num:
try:
order = Order.objects.get(num=self.order_num)
payplug.set_secret_key(settings.PAYPLUG_KEY)
cancel_url = self.request.build_absolute_uri(
reverse('transportation-checkout'))
return_url = self.request.build_absolute_uri(
reverse('transportation-checkout-confirmation',
args=(order.num, )))
payment_data = {
'amount': int(total * 100),
'currency': 'EUR',
'customer': {
'first_name': order.customer.first_name,
'last_name': order.customer.last_name,
'email': order.customer.email
},
'hosted_payment': {
'return_url': return_url,
'cancel_url': cancel_url,
},
'metadata': {
'order_num': order.num,
'customer_id': order.customer.id,
},
}
payment = payplug.Payment.create(**payment_data)
context["payment"] = payment
context["order"] = order
except Order.DoesNotExist:
pass
return context
def form_valid(self, form):
user = self.request.user
recipe = get_object_or_404(Recipe, pk=self.kwargs['recipe_pk'])
score = form.cleaned_data['score']
comment = form.cleaned_data['comment']
try:
obj = RecipeComment.objects.get(
user=user,
recipe=recipe,
)
obj.score = form.cleaned_data['score']
obj.comment = form.cleaned_data['comment']
except RecipeComment.DoesNotExist:
obj = RecipeComment.objects.create(
recipe=recipe,
comment=comment,
score=score,
user=user,
)
obj.save()
return FormView.form_valid(self, form)
def get_context_data(self, **kwargs):
context = FormView.get_context_data(self, **kwargs)
form = context["form"]
context["headers"] = ("username", "level", "xp", "courses",
"certificates") #, "achievements")
context["rows"] = []
for url in form.cleaned_data["account_list"].split('\n'):
resp = requests.get(url.strip())
html_soup = BeautifulSoup(resp.text, 'html.parser')
try:
username = list(
html_soup.select_one(
"div.userProfile .details .name").stripped_strings)[0]
level = list(
html_soup.select_one("div.userProfile .details .detail div"
).stripped_strings)[1]
xp = html_soup.select_one(
"div.userProfile .details .detail div:nth-child(2) span"
).text.replace(" XP", "")
courses = ", ".join([
"%s (%s)" % (course.select_one('a')["title"].split(' ')[0],
course.select_one('.courseXp').string)
for course in html_soup.select(
"div.userCourses .courseWrapper")
])
certificates = ", ".join([
"%s (%s)" % (certif["title"], " ".join(
list(
certif.select_one(
".details .date").stripped_strings))) for
certif in html_soup.select("#certificates .certificate")
])
# achievements = ", ".join(["%s (%s)" % (achiev["title"], " ".join(list(achiev.select_one(".description").stripped_strings))) for achiev in html_soup.select(".userAchievements.full .achievement:not(.disabled)")])
context["rows"].append((username, level, xp, courses,
certificates)) #, achievements))
except:
print("ERROR", url.strip())
# break
return context
def form_valid(self, form):
from os import path
csv_file = form.cleaned_data.get("csv_file")
df = pandas.read_excel(csv_file)
df.dropna(how="all", inplace=True)
for i in range(len(df)):
try:
presentation_name = df['presentation_name'][i]
topic = df['topic'][i]
slide = df['slide'][i]
slide = slide.replace("-", "_")
space_slide = slide.replace(" ", "_")
presentation, crt = Presentation.objects.get_or_create(
elearning=presentation_name,
topic=topic,
slide=space_slide)
except:
print("Skip row")
messages.info(self.request,
"your presentation data imported successfully.")
return FormView.form_valid(self, form)
def form_valid(self, form):
csv_file = form.cleaned_data.get("csv_file")
from os import path
df = pandas.read_excel(csv_file)
df.dropna(how="all", inplace=True)
for i in range(len(df)):
try:
data = {
'username': df['username'][i],
'surname': df['surname'][i],
'email': df['email'][i],
'name': df['username'][i],
'manager': df['Manager'][i],
'member_type': df['Member type'][i],
}
user, crt = User.objects.get_or_create(**data)
user.set_password(df['password'][i])
user.save()
except:
print("Skip row")
messages.info(self.request, "your user data imported successfully.")
return FormView.form_valid(self, form)
def get_context_data(self, **kwargs):
""" pass args form get to template as context
the add_choices context is to give how many additional input choices
to the form
"""
context = FormView.get_context_data(self, **kwargs)
# checking from POST request
request_choice = self.request.POST.get('request_choice',0)
last_choice = int (request_choice) - 2 if request_choice else 0
# assign from last_choice, ignore from GET, because input from POST
# from javascript has higher precedence than GET
if last_choice :
context['add_choices'] = last_choice
else :
# checking from arguments (GET)
# get previous total choices in the form, if exist
previous = int(self.args[1])if len (self.args) == 2 else 0
context['add_choices'] = int(self.args[0]) + previous if len(self.args) > 0 else 0
return context
def get_success_url(self):
next_page = self.request.POST.get('next', '')
if next_page:
return next_page
else:
return FormView.get_success_url(self)
# (r'^site_media/(?P<path>.*)$', 'django.views.static.server',
# { 'document_root':site_media }),
# (r'^site_media/css/(?P<path>.*)$', 'django.views.static.server',
# { 'document_root':site_media + '/css/' }),
# (r'^site_media/js/(?P<path>.*)$', 'django.views.static.server',
# { 'document_root':site_media + '/js/' }),
# (r'^site_media/img/(?P<path>.*)$', 'django.views.static.server',
# { 'document_root':site_media + '/img/' }),
url(r'^register/$', register_page, name="register_page"),
(r'^register/success/$', direct_to_template,
{ 'template': 'registration/register_success.html' }),
# Account management
url(r'^save/$', blogpost_save_page, name="blogpost_save"),
url(r'^blogpost/edit/(\d+)/$', blogpost_save_page, name="blogpost_update"),
url(r'^blogpost/delete/(\d+)/$', blogpost_delete, name="blogpost_delete"),
# url(r'^blogpost/delete/$', blogpost_delete, name="blogpost_delete"),
# if there is no parameters from security respect?
# url(r'^blogpost/edit/$', blogpost_save_page, name="blogpost_update"),
# Friends
(r'^following/(\w+)/$', friends_page),
(r'^friend/add/$', friend_add),
(r'^friend/remove/$', friend_remove),
# django comments
(r'^comments/', include('django.contrib.comments.urls')),
(r'^ratings/', include('ratings.urls')),
(r'^ajax/tag/autocomplete/$', ajax_tag_autocomplete),
url(r'^$', FormView.as_view(
template_name="blogpost_detail.html",
form_class=BlogPostSaveForm)),
)
urlpatterns += staticfiles_urlpatterns()
from django.conf.urls import patterns, url
from django.views.generic import FormView
from test_project.example_app.forms import Form1
urlpatterns = patterns('',
url(r'^',
FormView.as_view(
template_name="example_app/form1.html",
form_class=Form1,
),
name="form1"),
)
def get_context_data(self, **kwargs):
context = FormView.get_context_data(self, **kwargs)
context['page_title'] = self.page_title
context['allow_new_registrations'] = settings.ALLOW_NEW_REGISTRATIONS
return context
def dispatch(self, request, *args, **kwargs):
return FormView.dispatch(self, request, *args, **kwargs)
def get_success_response(self):
# No errors in get(), apply our form logic.
# NOTE that the checks are not make in the post() call, but this is not a problem.
# We can just store the payment method, and let the next view validate the other states again.
return FormView.get(self, self.request, self.args, self.kwargs)
"""
from django.conf import settings
from django.conf.urls.static import static
from rejestracja import settings
from django.contrib import admin
from django.urls import path, re_path
from olimpiada import views
from django.views.generic import FormView
from olimpiada import forms
urlpatterns = [
path('admin/', admin.site.urls),
path(r'', views.index),
path('index/', views.index),
re_path(
r'^form/$',
FormView.as_view(template_name="form.html", form_class=forms.Article)),
re_path(r'^article/(?P<id>\d+)/$', views.article),
re_path(r'^profile/$', views.profile),
re_path(r'^changepassword/$', views.changepassword),
re_path(r'^school/$', views.school),
re_path(r'^students/$', views.students),
re_path(r'^student/(?P<id>\d+)/$', views.student),
re_path(r'^studentspanel/$', views.studentspanel),
re_path(r'^registerschool/$', views.registerschool),
re_path(r'^registeruser/$', views.registeruser),
re_path(r'^registerinfo/$', views.registerinfo),
re_path(r'^registration/$', views.registration),
re_path(r'^accounts/login/$', views.userlogin),
re_path(r'^accounts/logout/$', views.userlogout),
] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
def get_success_url(self):
self.success_url = self.request.POST['next']
return FormView.get_success_url(self)
from django.conf.urls import patterns, url
from django.views.generic import TemplateView, FormView
from forms import ExampleForm
urlpatterns = patterns('',
url(r'^$', FormView.as_view(template_name='example.html', form_class=ExampleForm))
)
def get_initial(self):
initial = FormView.get_initial(self)
initial["name"] = self.kwargs["pk"]
return initial
def post(self, *args, **kwargs):
self.object = self.get_object()
return FormView.post(self, *args, **kwargs)
def post(self, request, *args, **kwargs):
print("The Post info: ")
print(request.POST)
return FormView.post(self, request, *args, **kwargs)
from django.conf.urls import url, include
from django.views.generic import FormView, TemplateView
from polls import forms
from polls import views
from polls.rest import router
urlpatterns = [
url(r'^$', views.PollListView.as_view(), name='poll_home'),
url(r'^rest/', include(router.urls), name='rest'),
url(r'^about/', views.AboutView.as_view(vistor="Changbin"), name='about'),
url(r'^bootstrap3/', FormView.as_view(template_name='polls/bootstrap3.html', form_class=forms.MyRegistrationForm),
name='bootstrap3'),
url(r'^(?P<pk>\d+)/$', views.DetailView.as_view(), name='detail'),
url(r'^(?P<pk>\d+)/results/$', views.ResultsView.as_view(), name='results'),
url(r'^(?P<poll_id>\d+)/vote/$', views.vote, name='vote'),
url(r'^jinja2/$', TemplateView.as_view(template_name="polls/jinja.jinja2"), {'words': 'Hello, Jinja2.'},
name='jinja2', ),
]
def get_context_data(self, **kwargs):
context = FormView.get_context_data(self, **kwargs)
context['page_title'] = self.page_title
return context
def get_form_kwargs(self):
kwargs = FormView.get_form_kwargs(self)
kwargs["user"] = self.request.user
return kwargs
def form_valid(self, form):
with transaction.atomic():
form.save()
from django.contrib.auth import update_session_auth_hash
update_session_auth_hash(self.request, form.user)
return FormView.form_valid(self, form)
def post(self, request, *args, **kwargs):
note_form = NoteForm(request.POST)
note_form.save()
return FormView.post(self, request, *args, **kwargs)
# -*- coding:utf-8 -*-
from __future__ import absolute_import, unicode_literals
from django.conf.urls import include, patterns, url
from django.views.generic import FormView
from . import forms, views
urlpatterns = patterns(
'',
url(r'^s3file/', include('s3file.urls')),
url(r'^s3/$', views.S3MockView.as_view(), name='s3mock'),
url(r'^upload/$',
FormView.as_view(form_class=forms.UploadForm,
template_name='form.html'),
name='upload'),
)
def form_valid(self, form):
form.save()
messages.info(self.request, "Your information has been updated")
return FormView.form_valid(self, form)
def form_valid(self, form):
form.save()
return FormView.form_valid(self, form)
def dispatch(self, request, *args, **kwargs):
if request.user.is_authenticated():
return redirect('upload')
return FormView.dispatch(self, request, *args, **kwargs)
def get(self, request, *args, **kwargs):
return FormView.post(self, request, *args, **kwargs)
def form_valid(self, form):
form.add_vote()
return FormView.form_valid(self, form)
def get(self, request, *args, **kwargs):
return FormView.get(self, request, *args, **kwargs)
def form_valid(self, form):
self._profile = form.register_tenant()
return FormView.form_valid(self, form)
def get(self, request, *args, **kwargs):
if 'async_id' in request.GET and settings.HAS_CELERY:
return self.get_result(request)
return FormView.get(self, request, *args, **kwargs)
def as_view(cls, **kwargs):
return csrf_exempt(FormView.as_view(**kwargs))
