def profile_create(request):
context = RequestContext(request)
if request.user.is_authenticated():
userid = int(request.user.id)
queryset = profiles.objects.filter(user=userid)
if queryset:
messages.error(request, "You have already created a profile!")
return HttpResponseRedirect('/profiles/myprofile/')
form = Profileregister(request.POST or None, request.FILES or None)
if form.is_valid():
instance = form.save(commit=False)
instance.user = request.user
instance.save()
if instance.pId == "TMG":
instance.pId = "TMG" + "00" + str(instance.tmId)
instance.save()
messages.add_message(request,messages.SUCCESS,"Successfully created a profile!")
return HttpResponseRedirect("/profiles/myprofile")
else:
form = Profileregister(request.POST or None, request.FILES or None)
content = {
"form": form,
"title": "Create/Register"
}
return render(request, "register.html", content)
def _save_calendar_defaults(request, start, days, timezone):
"""
Saves the start date, days, and timezone values using the Django
message framework. These can then be retrieved using
_get_calendar_defaults().
_save_calendar_defaults(request, start, days, timezone)
"""
# NOTE: clear out old messages before adding new one. According
# to the Django docs, if the messages exceed 4096 bytes the
# oldest messages will drop off the end. Experience shows
# however that instead you get a "ValueError: Not all temporary
# messages could be stored." from
# '"/home/dss/robin/django-1.2.3/django/contrib/messages/middleware.py",
# line 25, in process_response'.
old_start, old_days, old_tz, old_ts = _get_calendar_defaults(request)
if old_start == start and old_days == days and old_tz == timezone:
ts = old_ts # preserve freshness dating if no change.
else:
ts = datetime.now()
msg = "GBT_SCHEDULE_INFO %s %s %s %s" % (start.date(), days, timezone, ts)
messages.add_message(request, messages.INFO, msg, fail_silently = True)
def flash(level, message):
messages.add_message(
self.request,
level,
message,
extra_tags='safe photo-review'
)
def video_delete(request, slug):
video = get_object_or_404(Pod, slug=slug)
if request.user != video.owner and not request.user.is_superuser:
messages.add_message(
request, messages.ERROR, _(u'You can\'t delete this video'))
raise PermissionDenied
"""
from django.contrib.admin.util import NestedObjects
collector = NestedObjects(using='default') # or specific database
collector.collect([video])
to_delete = collector.nested()
print "to_delete : %s" %to_delete
print "--------"
for obj in to_delete:
print obj
"""
if request.method == "POST":
video.delete()
messages.add_message(
request, messages.INFO, _(u'The video has been deleted'))
return HttpResponseRedirect(reverse('pods.views.videos'))
return render_to_response("videos/video_delete.html",
{"video": video},
context_instance=RequestContext(request))
def perform_login(request, user, redirect_url=None):
from .models import EmailAddress
# not is_active: social users are redirected to a template
# local users are stopped due to form validation checking is_active
assert user.is_active
if (app_settings.EMAIL_VERIFICATION == EmailVerificationMethod.MANDATORY
and not EmailAddress.objects.filter(user=user,
verified=True).exists()):
send_email_confirmation(request, user)
return render(request,
"account/verification_sent.html",
{ "email": user.email })
# HACK: This may not be nice. The proper Django way is to use an
# authentication backend, but I fail to see any added benefit
# whereas I do see the downsides (having to bother the integrator
# to set up authentication backends in settings.py
if not hasattr(user, 'backend'):
user.backend = "django.contrib.auth.backends.ModelBackend"
signals.user_logged_in.send(sender=user.__class__,
request=request,
user=user)
login(request, user)
messages.add_message(request, messages.SUCCESS,
ugettext("Successfully signed in as %(user)s.") % { "user": user_display(user) } )
redirect_url = (redirect_url
or get_next_redirect_url(request)
or get_adapter().get_login_redirect_url(request))
return HttpResponseRedirect(redirect_url)
def forgot_username(request):
"""Forgot username form page.
On POST, this view sends an email with the username.
"""
if request.method == "POST":
form = ForgotUsernameForm(request.POST)
was_valid = form.is_valid()
if was_valid:
try_send_email_with_form(
form.save, form, 'email',
use_https=request.is_secure())
# Form may now be invalid if email failed to send.
# ForgotUsernameForm is invalid iff there is no user with the entered
# email address.
# The condition below ensures we don't leak existence of email address
# _unless_ sending an email fails.
if form.is_valid() or not was_valid:
# Don't leak existence of email addresses.
messages.add_message(
request, messages.INFO,
_(u"We've sent an email with the username to any account"
" using {email}.").format(email=form.data['email']))
return HttpResponseRedirect(reverse('users.login'))
else:
form = ForgotUsernameForm()
return jingo.render(request, 'users/forgot_username.html', {'form': form})
def activate(request, activation_key, user_id=None):
"""Activate a User account."""
activation_key = activation_key.lower()
if user_id:
user = get_object_or_404(User, id=user_id)
else:
user = RegistrationProfile.objects.get_user(activation_key)
if user and user.is_active:
messages.add_message(
request, messages.INFO,
_(u'Your account is already activated, log in below.'))
return HttpResponseRedirect(reverse('users.login'))
account = RegistrationProfile.objects.activate_user(activation_key,
request)
my_questions = None
form = AuthenticationForm()
if account:
# Claim anonymous watches belonging to this email
statsd.incr('user.activate')
claim_watches.delay(account)
my_questions = Question.uncached.filter(creator=account)
return jingo.render(request, 'users/activate.html',
{'account': account, 'questions': my_questions,
'form': form})
def user_membership_add(request, username, form_class=UserMembershipForm, template_name="profiles/add_membership.html"):
user = get_object_or_404(User, username=username)
try:
profile = Profile.objects.get(user=user)
except Profile.DoesNotExist:
profile = Profile.objects.create_profile(user=user)
if not request.user.profile.is_superuser:
raise Http403
if request.method == 'POST':
form = form_class(request.POST)
if form.is_valid():
membership = form.save(commit=False)
membership = update_perms_and_save(request, form, membership)
messages.add_message(request, messages.SUCCESS, 'Successfully updated memberships for %s' % user.get_full_name())
membership.populate_or_clear_member_id()
return HttpResponseRedirect("%s%s" % (reverse('profile', args=[user.username]),'#userview-memberships'))
else:
form = form_class(initial={'user':user})
return render_to_response(template_name, {
'form': form,
'user_this': user,
}, context_instance=RequestContext(request))
def edit_settings(request):
"""Edit user settings"""
if request.method == 'POST':
form = SettingsForm(request.POST)
if form.is_valid():
form.save_for_user(request.user)
messages.add_message(request, messages.INFO,
_(u'Your settings have been saved.'))
return HttpResponseRedirect(reverse('users.edit_settings'))
# Invalid form
return jingo.render(request, 'users/edit_settings.html',
{'form': form})
# Pass the current user's settings as the initial values.
values = request.user.settings.values()
initial = dict()
for v in values:
try:
# Uses ast.literal_eval to convert 'False' => False etc.
# TODO: Make more resilient.
initial[v['name']] = literal_eval(v['value'])
except (SyntaxError, ValueError):
# Attempted to convert the string value to a Python value
# but failed so leave it a string.
initial[v['name']] = v['value']
form = SettingsForm(initial=initial)
return jingo.render(request, 'users/edit_settings.html',
{'form': form})
def show_person(request, permalink):
person = get_object_or_404(Person, permalink=permalink)
form = WallForm(request.POST or None)
if request.POST and request.user.is_authenticated() and form.is_valid():
sr = ShortReview.objects.create(
kind=ShortReview.WALLPOST,
user=request.user,
object=person,
review_text=form.cleaned_data['text'],
type=ShortReview.TYPE_SHORT_REVIEW,
)
messages.add_message(request, messages.INFO, gettext('Wall post has been published'))
form = WallForm()
activities = UserActivity.objects.wall_filter(request).filter(person=person)
activities = ajax_activity_pager(request, activities)
context = {
'person':person,
'form':form,
'activities':activities,
}
return render(
request,
ajax_select_template(request, 'person/person.html'),
context
)
def user_role_edit(request, username, membership_id, form_class=GroupMembershipEditForm, template_name="profiles/edit_role.html"):
user = get_object_or_404(User, username=username)
membership = get_object_or_404(GroupMembership, id=membership_id)
try:
profile = Profile.objects.get(user=user)
except Profile.DoesNotExist:
profile = Profile.objects.create_profile(user=user)
if not profile.allow_edit_by(request.user):
raise Http403
if not has_perm(request.user,'user_groups.view_group', membership.group):
raise Http403
if request.method == 'POST':
form = form_class(request.POST, instance=membership)
if form.is_valid():
form.save()
messages.add_message(request, messages.SUCCESS, 'Successfully edited membership for %s' % membership.group)
return HttpResponseRedirect("%s%s" % (reverse('profile', args=[user.username]),'#userview-groups'))
else:
form = form_class(instance=membership)
return render_to_response(template_name, {
'form': form,
'membership': membership,
}, context_instance=RequestContext(request))
def dispatch(self, request, organization_slug):
from sentry.auth.helper import AuthHelper
helper = AuthHelper.get_for_request(request)
# SP initiated authentication, request helper is provided
if helper:
from sentry.web.frontend.auth_provider_login import AuthProviderLoginView
sso_login = AuthProviderLoginView()
return sso_login.handle(request)
# IdP initiated authentication. The organizatio_slug must be valid and
# an auth provider must exist for this organization to proceed with
# IdP initiated SAML auth.
try:
organization = Organization.objects.get(slug=organization_slug)
except Organization.DoesNotExist:
messages.add_message(request, messages.ERROR, ERR_NO_SAML_SSO)
return self.redirect(reverse('sentry-login'))
try:
auth_provider = AuthProvider.objects.get(organization=organization)
except AuthProvider.DoesNotExist:
messages.add_message(request, messages.ERROR, ERR_NO_SAML_SSO)
return self.redirect(reverse('sentry-login'))
helper = AuthHelper(
request=request,
organization=organization,
auth_provider=auth_provider,
flow=AuthHelper.FLOW_LOGIN,
)
helper.init_pipeline()
return helper.current_step()
def edit_cv(request, pk):
cv = get_object_or_404(Resume, pk=pk)
if request.method == 'POST':
form = CVForm(request.POST)
if form.is_valid():
update_cv(form, pk)
messages.add_message(request, messages.SUCCESS, 'CV successfully updated.')
return HttpResponseRedirect('../../')
else :
form = CVForm(initial={
'name' : cv.name,
'email' : cv.email,
'phone' : cv.phone,
'skills' : cv.skills,
'experience' : cv.experience,
'education' : cv.education,
'awards' : cv.awards,
'honors' : cv.honors,
'languages' : cv.languages,
'personal_references' : cv.personal_references,
'interests' : cv.interests,
'technology' : cv.technology,
'certification' : cv.certification,
'projects' : cv.projects,
'summary' : cv.summary,
'objective' : cv.objective
})
return render(request, "edit_cv.html", {'form': form})
def form_valid(self, form):
cg = self.contactgroup
request = self.request
if not cg.userperms & perms.WRITE_FILES:
raise PermissionDenied
upfile = request.FILES['file_to_upload']
# name has already been sanitized by UploadedFile._set_name
path = self.kwargs['path']
fullfilename = cg.get_fullfilename(os.path.join(path, upfile.name))
destination = None
try: # We're not using "with" because we want to show errors
destination = open(force_str(fullfilename), 'wb')
for chunk in upfile.chunks():
destination.write(chunk)
messages.add_message(
request, messages.SUCCESS,
_('File {} has been uploaded successfully.')
.format(upfile.name))
except IOError as err:
messages.add_message(
request, messages.ERROR,
_('Could not upload file {filename}: {error}').format(
filename=upfile.name,
error=err))
finally:
if destination:
destination.close()
return self.get(self.request)
def dispatch(self, request, organization_slug):
provider = get_provider(organization_slug)
if provider is None:
messages.add_message(request, messages.ERROR, ERR_NO_SAML_SSO)
return self.redirect('/')
saml_config = build_saml_config(provider.config, organization_slug)
auth = build_auth(request, saml_config)
# No need to logout an anonymous user.
should_logout = request.user.is_authenticated()
def force_logout():
request.user.refresh_session_nonce()
request.user.save()
logout(request)
redirect_to = auth.process_slo(
delete_session_cb=force_logout,
keep_local_session=not should_logout,
)
if not redirect_to:
redirect_to = get_login_url()
return self.redirect(redirect_to)
def access_group_members(request, team, group_id):
try:
group = AccessGroup.objects.get(team=team, id=group_id)
except AccessGroup.DoesNotExist:
return HttpResponseRedirect(reverse('sentry-manage-access-groups', args=[team.slug]))
form = NewAccessGroupMemberForm(request.POST or None)
if form.is_valid():
user = form.cleaned_data['user']
group.members.add(user)
messages.add_message(request, messages.SUCCESS,
_('%s was added to this access group.') % (user.email,))
return HttpResponseRedirect(reverse('sentry-access-group-members', args=[team.slug, group.id]))
context = csrf(request)
context.update({
'group': group,
'form': form,
'member_list': group.members.all(),
'group_list': AccessGroup.objects.filter(team=team),
'page': 'members',
'SUBSECTION': 'groups',
})
return render_with_team_context(team, 'sentry/teams/groups/members.html', context, request)
def access_group_projects(request, team, group_id):
try:
group = AccessGroup.objects.get(team=team, id=group_id)
except AccessGroup.DoesNotExist:
return HttpResponseRedirect(reverse('sentry-manage-access-groups', args=[team.slug]))
form = NewAccessGroupProjectForm(group, request.POST or None)
if form.is_valid():
project = form.cleaned_data['project']
group.projects.add(project)
messages.add_message(request, messages.SUCCESS,
_('%s was added to this access group.') % (project.name,))
return HttpResponseRedirect(reverse('sentry-access-group-projects', args=[team.slug, group.id]))
group_list = list(AccessGroup.objects.filter(team=team))
for g_ in group_list:
g_.team = team
context = csrf(request)
context.update({
'group': group,
'form': form,
'project_list': group.projects.all(),
'group_list': group_list,
'page': 'projects',
'SUBSECTION': 'groups',
})
return render_with_team_context(team, 'sentry/teams/groups/projects.html', context, request)
def edit_team_member(request, team, member_id):
try:
member = team.member_set.get(pk=member_id)
except TeamMember.DoesNotExist:
return HttpResponseRedirect(reverse('sentry-manage-team', args=[team.slug]))
if not can_edit_team_member(request.user, member):
return HttpResponseRedirect(reverse('sentry'))
form = EditTeamMemberForm(team, request.POST or None, instance=member)
if form.is_valid():
member = form.save(commit=True)
messages.add_message(request, messages.SUCCESS,
_('Changes to your team member were saved.'))
return HttpResponseRedirect(request.path)
context = csrf(request)
context.update({
'page': 'members',
'member': member,
'form': form,
'SUBSECTION': 'members',
})
return render_with_team_context(team, 'sentry/teams/members/edit.html', context, request)
def remove_access_group(request, team, group_id):
try:
group = AccessGroup.objects.get(team=team, id=group_id)
except AccessGroup.DoesNotExist:
return HttpResponseRedirect(reverse('sentry-manage-access-groups', args=[team.slug]))
if request.method == 'POST':
form = RemoveAccessGroupForm(request.POST)
else:
form = RemoveAccessGroupForm()
if form.is_valid():
group.delete()
messages.add_message(request, messages.SUCCESS,
_('%s was permanently removed.') % (group.name,))
return HttpResponseRedirect(reverse('sentry-manage-access-groups', args=[team.slug]))
context = csrf(request)
context.update({
'form': form,
'group': group,
'page': 'details',
'SUBSECTION': 'groups',
})
return render_with_team_context(team, 'sentry/teams/groups/remove.html', context, request)
def admin_invite_user(request, **kwargs):
"""
This view, by default, works inside the Django admin.
"""
form_class = kwargs.pop("form_class", InviteUserForm)
template_name = kwargs.pop("template_name", "signup_codes/admin_invite_user.html")
group, bridge = group_and_bridge(request)
if request.method == "POST":
form = form_class(request.POST, group=group)
if form.is_valid():
email = form.cleaned_data["email"]
form.send_signup_code()
messages.add_message(request, messages.INFO,
ugettext("An email has been sent to %(email)s.") % {
"email": email
}
)
form = form_class() # reset
else:
form = form_class(group=group)
ctx = group_context(group, bridge)
ctx.update({
"title": ugettext("Invite user"),
"form": form,
})
return render_to_response(template_name, RequestContext(request, ctx))
def form_valid(self, form):
form.save()
form.save_user_details(self.get_object())
messages.add_message(
self.request, messages.SUCCESS, _('Successfully saved staff member'))
return super(UserProfileUpdate, self).form_valid(form)
def requests(request, group_id):
try:
grp = Group.objects.get(id=int(group_id))
except:
raise Http404
if grp.teacher != request.user:
return HttpResponse(status=403)
if request.method == 'POST':
try:
jr = JoinRequest.objects.get(id=int(request.POST['request_id']))
request.POST['action']
if jr.group != grp: raise Exception
except:
return redirect('/teacher/groups/%s/requests/' % (grp.id, ))
if request.POST['action'] == 'confirm':
jr.execute()
messages.add_message(request, messages.SUCCESS, u'Zaakceptowano')
else:
jr.delete()
messages.add_message(request, messages.SUCCESS, u'Usunięto wniosek')
return redirect('/teacher/groups/%s/requests/' % (grp.id, ))
return render_to_response('rteacher/manage_groups_requests.html', request, **klist(
selected_group_id=grp.id,
request=request,
group=grp))
def create(request):
class NewGroupForm(forms.Form):
name = forms.CharField(max_length=30, label=u'Nazwa')
description = forms.CharField(required=True, label=u'Opis', widget=forms.TextInput())
if request.method == 'POST':
form = NewGroupForm(request.POST)
if form.is_valid():
g = Group(teacher=request.user,
name=form.cleaned_data['name'],
description=form.cleaned_data['description'])
g.save()
messages.add_message(request, messages.SUCCESS, u'Grupa utworzona')
return redirect('/teacher/groups/%s/' % (g.id, ))
else:
form = NewGroupForm()
return render_to_response('rteacher/manage_groups_add.html', request, **klist(
selected_group_id='create',
request=request,
form=form))
def delete(request, id, template_name="committees/delete.html"):
committee = get_object_or_404(Committee, pk=id)
if not has_perm(request.user, 'committees.delete_committee'):
raise Http403
if request.method == "POST":
EventLog.objects.log(instance=committee)
messages.add_message(request, messages.SUCCESS, 'Successfully deleted %s' % committee)
# send notification to administrators
recipients = get_notice_recipients('module', 'committees', 'committeerecipients')
if recipients:
if notification:
extra_context = {
'object': committee,
'request': request,
}
notification.send_emails(recipients, 'committee_deleted', extra_context)
committee.delete()
return HttpResponseRedirect(reverse('committees.search'))
return render_to_response(template_name, {'committee': committee},
context_instance=RequestContext(request))
def login_complete_view(request):
try:
voter_api_device_id = get_voter_api_device_id(request)
if not positive_value_exists(voter_api_device_id):
messages.add_message(request, messages.INFO, 'Missing voter_api_device_id.')
return HttpResponseRedirect(reverse('admin_tools:admin_home', args=()))
voter_object = request.user
if not voter_object:
messages.add_message(request, messages.INFO, 'Missing voter.')
return HttpResponseRedirect(reverse('admin_tools:admin_home', args=()))
# TODO Write the Twitter or Facebook information to the voter table so we can access it via the APIs
# Currently all of the twitter authentication for Django is in the separate social_auth* tables
# Relink this voter_api_device_id to this Voter account
voter_device_manager = VoterDeviceLinkManager()
voter_device_link_results = voter_device_manager.retrieve_voter_device_link(voter_api_device_id)
voter_device_link = voter_device_link_results['voter_device_link']
update_voter_device_link_results = voter_device_manager.update_voter_device_link(
voter_device_link, voter_object)
if update_voter_device_link_results['voter_device_link_updated']:
messages.add_message(request, messages.INFO, 'Voter updated.')
else:
messages.add_message(request, messages.INFO, 'Voter could not be relinked.')
except:
messages.add_message(request, messages.INFO, 'Voter not updated.')
return HttpResponseRedirect(reverse('admin_tools:admin_home', args=()))
def process_response(self, request, response):
# Making sure messages middleware is loaded
if hasattr(request, '_messages') and "deferred_messages" in request.session:
for message in request.session["deferred_messages"]:
messages.add_message(request, message.level, message.message, message.extra_tags)
del request.session["deferred_messages"]
return response
def edit_meta(request, id, form_class=MetaForm, template_name="committees/edit-meta.html"):
"""
Return committee that allows you to edit meta-html information.
"""
# check permission
committee = get_object_or_404(Committee, pk=id)
if not has_perm(request.user, 'committees.change_committee', committee):
raise Http403
EventLog.objects.log(instance=committee)
defaults = {
'title': committee.get_title(),
'description': committee.get_description(),
'keywords': committee.get_keywords(),
'canonical_url': committee.get_canonical_url(),
}
committee.meta = MetaTags(**defaults)
if request.method == "POST":
form = form_class(request.POST, instance=committee.meta)
if form.is_valid():
committee.meta = form.save() # save meta
committee.save() # save relationship
messages.add_message(request, messages.SUCCESS, 'Successfully updated meta for %s' % committee)
return HttpResponseRedirect(reverse('committees.detail', args=[committee.slug]))
else:
form = form_class(instance=committee.meta)
return render_to_response(template_name, {'committee': committee, 'form': form},
context_instance=RequestContext(request))
def group(request, group_id):
try:
grp = Group.objects.get(id=int(group_id))
except:
raise Http404
if grp.teacher != request.user:
return HttpResponse(status=403)
class GroupForm(forms.ModelForm):
class Meta:
model = Group
fields = ['name', 'description', 'is_archival']
if request.method == 'POST':
form = GroupForm(request.POST, instance=grp)
if form.is_valid():
form.save()
messages.add_message(request, messages.SUCCESS, u'Zapisano')
else:
form = GroupForm(instance=grp)
return render_to_response('rteacher/manage_groups_grp.html', request, **klist(
group=grp,
request=request,
form=form))
def build_this(self, request, obj):
activation = BuildPollFlow.start.run(question=obj, split_count=3)
process = activation.process
process_url = reverse('{}:details'.format(process.flow_cls.instance.namespace), kwargs={'process_pk': process.pk})
message = 'Build Poll Process <a href="{}">{}</a> has started'.format(process_url, process.pk)
messages.add_message(request, messages.SUCCESS, mark_safe(message))
def chpass(request):
"""
Change user's password
"""
if request.method == 'POST':
f = PasswordResetForm(request.POST)
if f.is_valid():
current = f.cleaned_data['current']
password = f.cleaned_data['password']
user = User.objects.get(pk=request.user.id)
username = user.username
chk = auth.authenticate(username = username, password = current)
if chk is not None:
if chk.is_active:
user.set_password(password)
user.save()
messages.add_message(request, messages.SUCCESS, _('Settings saved'))
return redirect('user:index')
else:
messages.add_message(request, messages.ERROR, _('Your current password is invalid.'))
return redirect(reverse('user:chpass'))
else:
return HttpResponse(_('Form invalid'))
f = PasswordResetForm()
ctx = {
'title': _('Change password'),
'form': f,
}
return render(request, 'userspace/chpass.html', ctx)
def post(self, request, *args, **kwargs):
form = self.get_form()
model = self.get_model()
if form.is_valid():
if ('file' not in form.changed_data
and 'content' not in form.changed_data)\
or ('file' in form.changed_data
and 'content' in form.changed_data):
form.errors['content'] = [
'Vous devez remplir un seul de ces '
'champs'
]
form.errors['file'] = [
'Vous devez remplir un seul de ces '
'champs'
]
return self.form_invalid(form)
# parsing the CSV
if 'file' in form.changed_data: # upload
field = 'file'
content = form.cleaned_data['file'].read()
detection = chardet.detect(content)
if detection['confidence'] < .5:
form.errors['file'] = ['Encodage non reconnu']
return self.form_invalid(form)
content = content.decode(detection['encoding'])
else: # we parse the inline content
field = 'content'
try:
content = form.cleaned_data['content'].encode('latin-1')
except UnicodeEncodeError:
content = form.cleaned_data['content'].encode()
detection = chardet.detect(content)
content = content.decode(detection['encoding'])
dialect = csv.Sniffer().sniff(content)
if dialect.escapechar is None:
dialect.escapechar = '\\' # hack
reader = csv.DictReader(StringIO(content), dialect=dialect)
# mapping extraction
mapping = {
k[:-6]: v
for k, v in form.cleaned_data.items()
if k.endswith('_field') and v != ''
}
# values charset detection
data = reencode_data(reader, detection)
properties = None
if 'properties_list' in form.cleaned_data and\
form.cleaned_data['properties_list'] != '':
properties = [
p.strip()
for p in form.cleaned_data['properties_list'].split(',')
]
if 'date_format' in form.cleaned_data:
properties = form.cleaned_data['date_format'] # urk!
try:
inserted, updated, errors = model\
.import_data(data, mapping, properties,
self.request.user)
except (UnicodeEncodeError, UnicodeDecodeError):
form.errors[field] = ['Encodage incorrect']
return self.form_invalid(form)
context = {
'object_list':
set(sorted(inserted + updated, key=lambda i: i.update_date)),
'errors':
errors
}
if len(inserted + updated) > 0:
model_name_plural = model._meta.verbose_name_plural\
if len(inserted + updated) > 0\
else model._meta.verbose_name
messages.add_message(
self.request, messages.SUCCESS,
'Import de {} {} effectué.'.format(len(inserted + updated),
model_name_plural))
if errors > 0:
plural = 's' if errors > 0 else ''
messages.add_message(
self.request, messages.ERROR,
'Import de {} : {} erreur{}.'.format(
model._meta.verbose_name_plural, errors, plural))
return redirect(
resolve_url('contacts:{}-list'.format(self.kwargs['type'])) +
'?id=' + ','.join([str(o.pk) for o in context['object_list']]))
# return render(self.request,
# 'contacts/{}_import.html'
# .format(self.kwargs['type']),
# context)
else:
return self.form_invalid(form)
def get_success_url(self):
messages.add_message(self.request, messages.INFO, _(u'Promo code applied successfully.'))
return reverse('cart')
def confirm_delete_lesson(request, lesson_pk, class_pk):
lesson = Lesson.objects.get(pk=lesson_pk)
lesson.delete()
messages.add_message(request, messages.SUCCESS, 'Lesson deleted successfully.')
return class_lesson_check(request, class_pk)
def Admin_Transact_Bitcoin(request):
if 'admin' in request.session:
if request.POST:
reciver = request.POST['reciver']
bitcoin = float(request.POST['amount'])
send_mess = request.POST['send_note']
tran_count = 0
sender_data = Regestration.objects.get(
u_hash=request.session['admin'])
if float(sender_data.bitcoin) <= 0.00014:
messages.add_message(request, messages.ERROR, 'You Must Have More Bitcoin Then 0.00014 ' +
", And You have "+str(sender_data.bitcoin)+" Bitcoin")
return redirect('admin_transact_bitcoin')
tran_count = Transaction.objects.filter(user=sender_data).count()
print(tran_count)
if reciver == sender_data.u_hash:
messages.add_message(
request, messages.ERROR, "You Can't Send Bitcoin To Yourself")
return redirect('admin_transact_bitcoin')
if float(bitcoin) > float(sender_data.bitcoin):
messages.add_message(
request, messages.ERROR, "You Have Not Sufficient Bitcoin " + str(sender_data.bitcoin))
return redirect('admin_transact_bitcoin')
else:
# if tran_count >= 5:
# new = 0.0001
# bitcoin = bitcoin - new
try:
reciver_data = Regestration.objects.get(
u_hash=str(reciver))
print("Sender Bitcoin", sender_data.bitcoin)
# if tran_count >= 5:
# sender_data.bitcoin -= float(bitcoin + new)
# else:
# sender_data.bitcoin -= float(bitcoin)
sender_data.bitcoin -= float(bitcoin)
print("Sender Bitcoin", sender_data.bitcoin)
print('Reciver Bitcoin', reciver_data.bitcoin)
reciver_data.bitcoin += float(bitcoin)
print('Reciver Bitcoin', reciver_data.bitcoin)
# Transaction Enter in Sender's Side
blockchain.add_data(name=sender_data.name,
email=sender_data.email,
amount=sender_data.amount,
bitcoin=sender_data.bitcoin,
m_no=sender_data.m_no,
pass1=sender_data.password)
blockchain.transactions.append({
'sender': sender_data.u_hash,
'receiver': reciver_data.u_hash,
'amount': 0,
'bitcoin': bitcoin,
'time': str(datetime.datetime.now())})
blockchain.create_block(sender_data.index, sender_data.timestamp,
sender_data.u_hash, sender_data.nonce, sender_data.u_prev_hash)
# Transaction Entery in Sender's Block ( to Admin )
# if tran_count >= 5:
# admin_user = Registration.objects.get(email='*****@*****.**')
# blockchain.add_data(name = sender_data.name, email = sender_data.email, amount= sender_data.amount ,bitcoin= sender_data.bitcoin, m_no=sender_data.m_no, pass1=sender_data.password)
# blockchain.transactions.append({
# 'sender':sender_data.u_hash,
# 'receiver':admin_user.u_hash,
# 'amount':0,
# 'bitcoin':new,
# 'time':str(datetime.datetime.now())})
# blockchain.create_block(sender_data.index,sender_data.timestamp,sender_data.u_hash,sender_data.nonce,sender_data.u_prev_hash)
# # Transaction Entry In Sender's DataBase
# tran = Transactions()
# tran.user = sender_data
# tran.sender = sender_data.u_hash
# tran.receiver = admin_user.u_hash
# tran.amount = 0
# tran.bitcoin = new
# tran.time = str(datetime.datetime.now())
# tran.save()
# Transaction Enter in Reciver's Side
blockchain.add_data(name=reciver_data.name,
email=reciver_data.email,
amount=reciver_data.amount,
bitcoin=reciver_data.bitcoin,
m_no=reciver_data.m_no,
pass1=reciver_data.password)
blockchain.transactions.append({
'sender': sender_data.u_hash,
'receiver': reciver_data.u_hash,
'amount': 0,
'bitcoin': bitcoin,
'time': str(datetime.datetime.now())})
blockchain.create_block(reciver_data.index, reciver_data.timestamp,
reciver_data.u_hash, reciver_data.nonce, reciver_data.u_prev_hash)
# Transaction Entery In Admin Side
# if tran_count >= 5:
# admin_user = Registration.objects.get(email='*****@*****.**')
# blockchain.add_data(name = admin_user.name, email = admin_user.email,amount= admin_user.amount,bitcoin= admin_user.bitcoin, m_no=admin_user.m_no, pass1=admin_user.password)
# blockchain.transactions.append({
# 'sender':sender_data.u_hash,
# 'receiver':admin_user.u_hash,
# 'amount':0,
# 'bitcoin':new,
# 'time':str(datetime.datetime.now())})
# blockchain.create_block(admin_user.index,admin_user.timestamp,admin_user.u_hash,admin_user.nonce,admin_user.u_prev_hash)
# admin_user.bitcoin += new
# admin_user.save()
# tran = Transactions()
# tran.user = admin_user
# tran.sender = sender_data.u_hash
# tran.receiver = admin_user.u_hash
# tran.amount = 0
# tran.bitcoin = new
# tran.time = str(datetime.datetime.now())
# tran.send_notes = send_mess
# tran.save()
sender_data.save()
reciver_data.save()
# Transaction Entry In Sender's DataBase
tran = Transaction()
tran.user = sender_data
tran.sender = sender_data.u_hash
tran.receiver = reciver_data.u_hash
tran.amount = 0
tran.bitcoin = bitcoin
tran.time = str(datetime.datetime.now())
tran.send_notes = send_mess
tran.save()
# Transaction Entry In Reciver's DataBase
tran = Transaction()
tran.user = reciver_data
tran.sender = sender_data.u_hash
tran.receiver = reciver_data.u_hash
tran.amount = 0
tran.bitcoin = bitcoin
tran.time = str(datetime.datetime.now())
tran.recive_notes = send_mess
tran.save()
messages.add_message(
request, messages.ERROR, 'Bitcoin Sent Successfully...')
return redirect('admin_transact_bitcoin')
except:
messages.add_message(
request, messages.ERROR, 'No Resiver Exists ...')
return redirect('admin_transact_bitcoin')
return render(request, 'transact.html')
return redirect('login')
def Admin_Transact_Money(request):
if 'admin' in request.session:
if request.POST:
reciver = request.POST['reciver']
amount = float(request.POST['amount'])
send_mess = request.POST['send_note']
print(reciver, amount, send_mess)
tran_count = 0
sender_data = Regestration.objects.get(
u_hash=request.session['admin'])
tran_count = Transaction.objects.filter(user=sender_data).count()
print(tran_count)
if reciver == sender_data.u_hash:
messages.add_message(
request, messages.ERROR, "You Can't Send Money To Yourself")
return redirect('admin_transact_money')
if float(amount) > float(sender_data.amount):
messages.add_message(
request, messages.ERROR, "You Have Not Sufficient Balance " + str(sender_data.amount)+"₹")
return redirect('admin_transact_money')
else:
# if tran_count >= 5:
# new = ((amount * 2)/100)
# amount = amount - new
try:
reciver_data = Regestration.objects.get(
u_hash=str(reciver))
print(sender_data.amount)
# if tran_count >= 5:
# sender_data.amount -= float(amount + new)
# else:
# sender_data.amount -= float(amount)
sender_data.amount -= float(amount)
print(sender_data.amount)
print(reciver_data.amount)
reciver_data.amount += float(amount)
print(reciver_data.amount)
# TRansaction Entry In Sender's Block
blockchain.add_data(name=sender_data.name, email=sender_data.email, amount=sender_data.amount,
bitcoin=sender_data.bitcoin, m_no=sender_data.m_no, pass1=sender_data.password)
blockchain.transactions.append({
'sender': sender_data.u_hash,
'receiver': reciver_data.u_hash,
'amount': amount,
'bitcoin': 0.0,
'time': str(datetime.datetime.now())})
blockchain.create_block(sender_data.index, sender_data.timestamp,
sender_data.u_hash, sender_data.nonce, sender_data.u_prev_hash)
# Transaction Entery in Sender's Block ( to Admin )
# if tran_count >= 5:
# admin_user = Registration.objects.get(email='*****@*****.**')
# blockchain.add_data(name = sender_data.name, email = sender_data.email, amount= sender_data.amount ,bitcoin= sender_data.bitcoin, m_no=sender_data.m_no, pass1=sender_data.password)
# blockchain.transactions.append({
# 'sender':sender_data.u_hash,
# 'receiver':admin_user.u_hash,
# 'amount':new,
# 'bitcoin':0.0,
# 'time':str(datetime.datetime.now())})
# blockchain.create_block(sender_data.index,sender_data.timestamp,sender_data.u_hash,sender_data.nonce,sender_data.u_prev_hash)
# # Transaction Entry In Sender's DataBase
# tran = Transactions()
# tran.user = sender_data
# tran.sender = sender_data.u_hash
# tran.receiver = admin_user.u_hash
# tran.amount = new
# tran.bitcoin = 0.0
# tran.time = str(datetime.datetime.now())
# tran.save()
# Transaction Entry In Reciver's Block
blockchain.add_data(name=reciver_data.name, email=reciver_data.email, amount=reciver_data.amount,
bitcoin=reciver_data.bitcoin, m_no=reciver_data.m_no, pass1=reciver_data.password)
blockchain.transactions.append({
'sender': sender_data.u_hash,
'receiver': reciver_data.u_hash,
'amount': amount,
'bitcoin': 0.0,
'time': str(datetime.datetime.now())})
blockchain.create_block(reciver_data.index, reciver_data.timestamp,
reciver_data.u_hash, reciver_data.nonce, reciver_data.u_prev_hash)
# Transaction Entery In Admin Side
# if tran_count >= 5:
# admin_user = Registration.objects.get(email='*****@*****.**')
# blockchain.add_data(name = admin_user.name, email = admin_user.email,amount= admin_user.amount,bitcoin= admin_user.bitcoin, m_no=admin_user.m_no, pass1=admin_user.password)
# blockchain.transactions.append({
# 'sender':sender_data.u_hash,
# 'receiver':admin_user.u_hash,
# 'amount':new,
# 'bitcoin':0.0,
# 'time':str(datetime.datetime.now())})
# blockchain.create_block(admin_user.index,admin_user.timestamp,admin_user.u_hash,admin_user.nonce,admin_user.u_prev_hash)
# admin_user.amount += new
# admin_user.save()
# tran = Transactions()
# tran.user = admin_user
# tran.sender = sender_data.u_hash
# tran.receiver = admin_user.u_hash
# tran.amount = new
# tran.bitcoin = 0.0
# tran.time = str(datetime.datetime.now())
# tran.send_notes = send_mess
# tran.save()
sender_data.save()
reciver_data.save()
# Transaction Entry In Sender's DataBase
tran = Transaction()
tran.user = sender_data
tran.sender = sender_data.u_hash
tran.receiver = reciver_data.u_hash
tran.amount = amount
tran.bitcoin = 0.0
tran.time = str(datetime.datetime.now())
tran.send_notes = send_mess
tran.save()
# Transaction Entry In Reciver's DataBase
tran = Transaction()
tran.user = reciver_data
tran.sender = sender_data.u_hash
tran.receiver = reciver_data.u_hash
tran.amount = amount
tran.bitcoin = 0.0
tran.time = str(datetime.datetime.now())
tran.recive_notes = send_mess
tran.save()
messages.add_message(
request, messages.ERROR, 'Money Sent Successfully...')
return redirect('admin_transact_money')
except:
messages.add_message(
request, messages.ERROR, 'No Resiver Exists ...')
return redirect('admin_transact_money')
return render(request, 'transact.html')
return redirect('login')
def Transact_bitcoin(request):
print("****************Transact_bitcoin CALLING*****************")
if 'user' in request.session:
if request.POST:
reciver = request.POST['reciver']
bitcoin = float(request.POST['amount'])
send_mess = request.POST['send_note']
tran_count = 0
sender_data = Regestration.objects.get(u_hash=request.session['user'])
if float(sender_data.bitcoin) <= 0.00014:
messages.add_message(
request, messages.ERROR, "You Must have more bitcoin then 0.00014" + str(sender_data.bitcoin))
tran_count = Transaction.objects.filter(user=sender_data).count()
print(tran_count)
if reciver == sender_data.u_hash:
messages.add_message(
request, messages.ERROR, "You can't send money to yourself")
return redirect('Transact_bitcoin')
if float(bitcoin) > float(sender_data.bitcoin):
messages.add_message(
request, messages.ERROR, "You have Not sufficient Balance " + str(sender_data.bitcoin))
return redirect('Transact_bitcoin')
else:
if tran_count >= 5:
new = 0.0001
bitcoin = bitcoin-new
try:
reciver_data = Regestration.objects.get(
u_hash=str(reciver))
print("Sender Bitcoin", sender_data.bitcoin)
if tran_count >= 5:
sender_data.bitcoin -= float(bitcoin+new)
else:
sender_data.bitcoin -= float(bitcoin)
print("Sender Bitcoin", sender_data.bitcoin)
print("Reciver Bitcoin", reciver_data.bitcoin)
reciver_data.bitcoin += float(bitcoin)
print("Reciver Bitcoin", reciver_data.bitcoin)
# Transaction entry in sender databese
blockchain.add_data(
name=sender_data.name,
email=sender_data.email,
amount=sender_data.amount,
bitcoin=sender_data.bitcoin,
m_no=sender_data.m_no,
pass1=sender_data.password,
)
blockchain.transactions.append(
{
'sender': sender_data.u_hash,
'reciver': reciver_data.u_hash,
'amount': 0,
'bitcoin': bitcoin,
'time': str(datetime.datetime.now()),
}
)
blockchain.create_block(sender_data.index, sender_data.timestamp,
sender_data.u_hash, sender_data.nonce, sender_data.u_prev_hash)
# Transaction Entry in sender's block(to Admin)
if tran_count >= 5:
admin_user = Regestration.objects.get(
email='*****@*****.**')
blockchain.add_data(
name=sender_data.name,
email=sender_data.email,
amount=sender_data.amount,
bitcoin=sender_data.bitcoin,
m_no=sender_data.m_no,
pass1=sender_data.password
)
blockchain.transactions.append(
{
'sender': sender_data.u_hash,
'reciver': admin_user.u_hash,
'amount': 0,
'bitcoin': new,
'time': str(datetime.datetime.now()),
}
)
blockchain.create_block(sender_data.index, sender_data.timestamp,
sender_data.u_hash, sender_data.nonce, sender_data.u_prev_hash)
###################Transaction Entry In Sender's Database (admin)####################
tran = Transaction()
tran.user = sender_data
tran.sender = sender_data.u_hash
tran.receiver = admin_user.u_hash
tran.amount = 0
tran.bitcoin = new
tran.time = str(datetime.datetime.now())
tran.send_notes = send_mess
tran.save()
# Transaction entry in resiver databese
blockchain.add_data(
name=reciver_data.name,
email=reciver_data.email,
amount=reciver_data.amount,
bitcoin=reciver_data.bitcoin,
m_no=reciver_data.m_no,
pass1=reciver_data.password
)
blockchain.transactions.append(
{
'sender': sender_data.u_hash,
'reciver': reciver_data.u_hash,
'amount': 0,
'bitcoin': bitcoin,
'time': str(datetime.datetime.now())
}
)
blockchain.create_block(reciver_data.index, reciver_data.timestamp,
reciver_data.u_hash, reciver_data.nonce, reciver_data.u_prev_hash)
# Transaction entry in Admin side
if tran_count >= 5:
admin_user = Regestration.objects.get(
email='*****@*****.**')
blockchain.add_data(
name=admin_user.name,
email=admin_user.email,
amount=admin_user.amount,
bitcoin=admin_user.bitcoin,
m_no=admin_user.m_no,
pass1=admin_user.password
)
blockchain.transactions.append(
{
'sender': sender_data.u_hash,
'reciver': admin_user.u_hash,
'amount': 0,
'bitcoin': new,
'time': str(datetime.datetime.now())
}
)
blockchain.create_block(
admin_user.index, admin_user.timestamp, admin_user.u_hash, admin_user.nonce, admin_user.u_prev_hash)
admin_user.bitcoin += new
admin_user.save()
tran = Transaction()
tran.user = reciver_data
tran.sender = sender_data.u_hash
tran.receiver = reciver_data.u_hash
tran.amount = new
tran.bitcoin = new
tran.time = str(datetime.datetime.now())
tran.receive_notes = send_mess
tran.save()
sender_data.save()
reciver_data.save()
###################Transaction Entry In Sender's Database####################
tran = Transaction()
tran.user = sender_data
tran.sender = sender_data.u_hash
tran.receiver = reciver_data.u_hash
tran.amount = 0
tran.bitcoin = bitcoin
tran.time = str(datetime.datetime.now())
tran.send_notes = send_mess
tran.save()
##################Transaction Entry In Reciver's Database##################
tran = Transaction()
tran.user = reciver_data
tran.sender = sender_data.u_hash
tran.receiver = reciver_data.u_hash
tran.amount = 0
tran.bitcoin = bitcoin
tran.time = str(datetime.datetime.now())
tran.receive_notes = send_mess
tran.save()
messages.add_message(
request, messages.ERROR, "Bitcoin Sent Successfully.......!!!!!!!")
return redirect('Transact_bitcoin')
except:
messages.add_message(
request, messages.ERROR, "No Reciver Exists.......!!!!!!!")
return redirect('Transact_bitcoin')
return render(request, 'transact.html')
return redirect('login')
def add_message(self, msgtype, message):
add_message(self.request, msgtype, message)
def form_valid(self, form):
messages.add_message(
self.request, messages.SUCCESS,
'Recherche {} modifiée avec succès.'.format(self.object))
return super().form_valid(form)
def form_detail(request, slug, template="forms/form_detail.html"):
"""
Display a built form and handle submission.
"""
published = Form.objects.published(for_user=request.user)
form = get_object_or_404(published, slug=slug)
if not has_view_perm(request.user, 'forms.view_form', form):
raise Http403
# If form has a recurring payment, make sure the user is logged in
if form.recurring_payment and request.user.is_anonymous():
response = redirect('auth_login')
response['Location'] += '?next=%s' % form.get_absolute_url()
return response
form_for_form = FormForForm(form, request.user, request.POST or None,
request.FILES or None)
for field in form_for_form.fields:
field_default = request.GET.get(field, None)
if field_default:
form_for_form.fields[field].initial = field_default
if request.method == "POST":
if form_for_form.is_valid():
entry = form_for_form.save()
entry.entry_path = request.POST.get("entry_path", "")
if request.user.is_anonymous():
if entry.get_email_address():
emailfield = entry.get_email_address()
firstnamefield = entry.get_first_name()
lastnamefield = entry.get_last_name()
phonefield = entry.get_phone_number()
password = ''
for i in range(0, 10):
password += random.choice(string.ascii_lowercase +
string.ascii_uppercase)
user_list = User.objects.filter(
email=emailfield).order_by('-last_login')
if user_list:
anonymous_creator = user_list[0]
else:
anonymous_creator = User(username=emailfield[:30],
email=emailfield,
first_name=firstnamefield,
last_name=lastnamefield)
anonymous_creator.set_password(password)
anonymous_creator.is_active = False
anonymous_creator.save()
anonymous_profile = Profile(user=anonymous_creator,
owner=anonymous_creator,
creator=anonymous_creator,
phone=phonefield)
anonymous_profile.save()
entry.creator = anonymous_creator
else:
entry.creator = request.user
entry.save()
entry.set_group_subscribers()
# Email
subject = generate_email_subject(form, entry)
email_headers = {} # content type specified below
if form.email_from:
email_headers.update({'Reply-To': form.email_from})
# Email to submitter
# fields aren't included in submitter body to prevent spam
submitter_body = generate_submitter_email_body(
entry, form_for_form)
email_from = form.email_from or settings.DEFAULT_FROM_EMAIL
sender = get_setting(
'site', 'global',
'siteemailnoreplyaddress') or settings.DEFAULT_FROM_EMAIL
email_to = form_for_form.email_to()
if email_to and form.send_email and form.email_text:
# Send message to the person who submitted the form.
msg = EmailMessage(subject,
submitter_body,
sender, [email_to],
headers=email_headers)
msg.content_subtype = 'html'
try:
msg.send(fail_silently=True)
except:
pass
# Email copies to admin
admin_body = generate_admin_email_body(entry, form_for_form)
email_from = email_to or email_from # Send from the email entered.
email_headers = {} # Reset the email_headers
email_headers.update({'Reply-To': email_from})
email_copies = [
e.strip() for e in form.email_copies.split(',') if e.strip()
]
subject = subject.encode(errors='ignore')
admin_body = admin_body.encode(errors='ignore')
if email_copies:
# Send message to the email addresses listed in the copies.
msg = EmailMessage(subject,
admin_body,
sender,
email_copies,
headers=email_headers)
msg.content_subtype = 'html'
for f in form_for_form.files.values():
try:
f.open()
f.seek(0)
msg.attach(f.name, f.read())
f.close()
except Exception:
pass
try:
msg.send(fail_silently=True)
except:
pass
# Email copies to recipient list indicated in the form
email_recipients = entry.get_function_email_recipients()
if email_recipients:
# Send message to the email addresses selected in the form.
msg = EmailMessage(subject,
admin_body,
sender,
email_recipients,
headers=email_headers)
msg.content_subtype = 'html'
for f in form_for_form.files.values():
f.seek(0)
msg.attach(f.name, f.read())
msg.send()
# payment redirect
if (form.custom_payment
or form.recurring_payment) and entry.pricing:
# get the pricing's price, custom or otherwise
price = entry.pricing.price or form_for_form.cleaned_data.get(
'custom_price')
if form.recurring_payment:
billing_start_dt = datetime.datetime.now()
trial_period_start_dt = None
trial_period_end_dt = None
if entry.pricing.has_trial_period:
trial_period_start_dt = datetime.datetime.now()
trial_period_end_dt = trial_period_start_dt + datetime.timedelta(
1)
billing_start_dt = trial_period_end_dt
# Create recurring payment
rp = RecurringPayment(
user=request.user,
description=entry.pricing.label,
billing_period=entry.pricing.billing_period,
billing_start_dt=billing_start_dt,
num_days=entry.pricing.num_days,
due_sore=entry.pricing.due_sore,
payment_amount=price,
taxable=entry.pricing.taxable,
tax_rate=entry.pricing.tax_rate,
has_trial_period=entry.pricing.has_trial_period,
trial_period_start_dt=trial_period_start_dt,
trial_period_end_dt=trial_period_end_dt,
trial_amount=entry.pricing.trial_amount,
creator=request.user,
creator_username=request.user.username,
owner=request.user,
owner_username=request.user.username,
)
rp.save()
rp.add_customer_profile()
# redirect to recurring payments
messages.add_message(request, messages.SUCCESS,
'Successful transaction.')
return redirect('recurring_payment.my_accounts')
else:
# create the invoice
invoice = make_invoice_for_entry(entry, custom_price=price)
# log an event for invoice add
EventLog.objects.log(instance=form)
# redirect to billing form
return redirect('form_entry_payment', invoice.id,
invoice.guid)
# default redirect
if form.completion_url:
return HttpResponseRedirect(form.completion_url)
return redirect("form_sent", form.slug)
# set form's template to default if no template or template doesn't exist
if not form.template or not template_exists(form.template):
form.template = "default.html"
context = {
"form": form,
"form_for_form": form_for_form,
'form_template': form.template,
}
return render_to_response(template, context, RequestContext(request))
def delete(self, *args, **kwargs):
messages.add_message(
self.request, messages.SUCCESS,
'La recherche {} a été supprimée.'.format(self.get_object()))
return super().delete(*args, **kwargs)
def view_settings(request):
old_email = request.user.email # this line has to be at the top to work.
old_wants_newsletter = request.user.profile.wants_newsletter
user = request.user
up = user.profile
user_form = UserForm(request.POST or None, instance=user)
profile_form = ProfileForm(request.POST or None, instance=up)
if profile_form.is_valid() and user_form.is_valid():
user_cd = user_form.cleaned_data
profile_cd = profile_form.cleaned_data
new_email = user_cd["email"]
changed_email = old_email != new_email
if changed_email:
# Email was changed.
up.activation_key = sha1_activation_key(user.username)
up.key_expires = now() + timedelta(5)
up.email_confirmed = False
# Unsubscribe the old address in mailchimp (we'll
# resubscribe it when they confirm it later).
update_mailchimp.delay(old_email, "unsubscribed")
# Send an email to the new and old addresses. New for verification;
# old for notification of the change.
email = emails["email_changed_successfully"]
send_mail(
email["subject"],
email["body"] % (user.username, up.activation_key),
email["from"],
[new_email],
)
email = emails["notify_old_address"]
send_mail(
email["subject"],
email["body"] % (user.username, old_email, new_email),
email["from"],
[old_email],
)
msg = message_dict["email_changed_successfully"]
messages.add_message(request, msg["level"], msg["message"])
logout(request)
else:
# if the email wasn't changed, simply inform of success.
msg = message_dict["settings_changed_successfully"]
messages.add_message(request, msg["level"], msg["message"])
new_wants_newsletter = profile_cd["wants_newsletter"]
if old_wants_newsletter != new_wants_newsletter:
if new_wants_newsletter is True and not changed_email:
# They just subscribed. If they didn't *also* update their
# email address, subscribe them.
subscribe_to_mailchimp.delay(new_email)
elif new_wants_newsletter is False:
# They just unsubscribed
update_mailchimp.delay(new_email, "unsubscribed")
# New email address and changes above are saved here.
profile_form.save()
user_form.save()
return HttpResponseRedirect(reverse("view_settings"))
return render(
request,
"profile/settings.html",
{
"profile_form": profile_form,
"user_form": user_form,
"private": True,
},
)
def delete(self, *args, **kwargs):
messages.add_message(
self.request, messages.SUCCESS,
'L’échange avec {} a été supprimé.'.format(self.get_object()))
return super().delete(*args, **kwargs)
def form_valid(self, form):
messages.add_message(self.request, messages.INFO,
_("Infos successfully updated"))
return super().form_valid(form)
def copy(request, id):
"""
Copies a form_instance and all the fields related to it.
"""
form_instance = get_object_or_404(Form, pk=id)
# check permission
if not (has_perm(request.user, 'forms.add_form', form_instance)
and has_perm(request.user, 'forms.change_form', form_instance)):
raise Http403
# create a new slug
slug = form_instance.slug
if len(slug.rsplit('-', 1)) > 1 and slug.rsplit('-', 1)[1].isdigit():
slug = slug.rsplit('-', 1)[0]
i = 1
while True:
if i > 0:
if i > 1:
slug = slug.rsplit("-", 1)[0]
slug = "%s-%s" % (slug, i)
match = Form.objects.filter(slug=slug)
if not match:
break
i += 1
# copy the form
new_form = Form.objects.create(
title=form_instance.title,
slug=slug,
intro=form_instance.intro,
response=form_instance.response,
email_text=form_instance.email_text,
subject_template=form_instance.subject_template,
send_email=form_instance.send_email,
email_from=form_instance.email_from,
email_copies=form_instance.email_copies,
completion_url=form_instance.completion_url,
template=form_instance.template,
allow_anonymous_view=form_instance.allow_anonymous_view,
allow_user_view=form_instance.allow_user_view,
allow_member_view=form_instance.allow_member_view,
allow_user_edit=form_instance.allow_user_edit,
allow_member_edit=form_instance.allow_member_edit,
creator=request.user,
creator_username=request.user.username,
owner=request.user,
owner_username=request.user.username,
status=True,
status_detail='draft',
)
# copy form fields
for field in form_instance.fields.all():
Field.objects.create(
form=new_form,
label=field.label,
field_type=field.field_type,
field_function=field.field_function,
required=field.required,
visible=field.visible,
choices=field.choices,
position=field.position,
default=field.default,
)
EventLog.objects.log(instance=form_instance)
messages.add_message(request, messages.SUCCESS,
'Successfully added %s' % new_form)
return redirect('form_edit', new_form.pk)
def create_recurring_events(pctx):
if not pctx.has_permission(pperm.edit_events):
raise PermissionDenied(_("may not edit events"))
request = pctx.request
message = None
message_level = None
if request.method == "POST":
form = RecurringEventForm(
pctx.course.identifier, request.POST, request.FILES)
if form.is_valid():
if form.cleaned_data["starting_ordinal"] is not None:
starting_ordinal = form.cleaned_data["starting_ordinal"]
starting_ordinal_specified = True
else:
starting_ordinal = 1
starting_ordinal_specified = False
while True:
try:
_create_recurring_events_backend(
course=pctx.course,
time=form.cleaned_data["time"],
kind=form.cleaned_data["kind"],
starting_ordinal=starting_ordinal,
interval=form.cleaned_data["interval"],
count=form.cleaned_data["count"],
duration_in_minutes=(
form.cleaned_data["duration_in_minutes"]),
all_day=form.cleaned_data["all_day"],
shown_in_calendar=(
form.cleaned_data["shown_in_calendar"])
)
message = _("Events created.")
message_level = messages.SUCCESS
except EventAlreadyExists as e:
if starting_ordinal_specified:
message = (
string_concat(
"%(err_type)s: %(err_str)s. ",
_("No events created."))
% {
"err_type": type(e).__name__,
"err_str": str(e)})
message_level = messages.ERROR
else:
starting_ordinal += 10
continue
except Exception as e:
if isinstance(e, ValidationError):
for field, error in e.error_dict.items():
try:
form.add_error(field, error)
except ValueError:
# This happens when ValidationError were
# raised for fields which don't exist in
# RecurringEventForm
form.add_error(
"__all__", "'%s': %s" % (field, error))
else:
message = (
string_concat(
"%(err_type)s: %(err_str)s. ",
_("No events created."))
% {
"err_type": type(e).__name__,
"err_str": str(e)})
message_level = messages.ERROR
break
else:
form = RecurringEventForm(pctx.course.identifier)
if message and message_level:
messages.add_message(request, message_level, message)
return render_course_page(pctx, "course/generic-course-form.html", {
"form": form,
"form_description": _("Create recurring events"),
})
def add_instance(request, group_name):
params = request.POST
num = int(params["instanceCnt"])
subnet = None
placement_group = None
asg_status = params['asgStatus']
launch_in_asg = False
use_placement_group = False
try:
# Configure subnet to launch hosts
if 'subnet' in params:
subnet = params['subnet']
# check if custom subnet is specified and custom placement group is in it.
if 'customSubnet' in params and 'customPlacementGroup' in params and 'placementGroup' in params:
# The check box is ticked and placement group is entered.
placement_group = params['placementGroup']
use_placement_group = True
# Check if asg is enabled and does not use placement group. Then launch in asg
if str(asg_status).upper() == "ENABLED" and not use_placement_group:
launch_in_asg = True
if launch_in_asg:
# Launch hosts inside ASG / Bump ASG size by required instances
autoscaling_groups_helper.launch_hosts(request, group_name, num, None)
content = 'Capacity increased by {} for Auto Scaling Group {}. Please go to ' \
'<a href="https://deploy.pinadmin.com/groups/{}/">group page</a> ' \
'to check new hosts information.'.format(num, group_name, group_name)
messages.add_message(request, messages.SUCCESS, content)
else:
# Launch hosts outside ASG / static hosts
if not subnet:
# No subnet specified show error message
content = 'Failed to launch hosts to group {}. Please choose subnets in' \
' <a href="https://deploy.pinadmin.com/groups/{}/config/">group config</a>.' \
' If you have any question, please contact your friendly Teletraan owners' \
' for immediate assistance!'.format(group_name, group_name)
messages.add_message(request, messages.ERROR, content)
else:
# Subnet is specified. Toggle based on presence of placement group param
if placement_group is not None:
# Launch static hosts in the given PG
host_ids = autoscaling_groups_helper.launch_hosts_with_placement_group(
request, group_name, num, subnet, placement_group)
else:
host_ids = autoscaling_groups_helper.launch_hosts(request, group_name, num, subnet)
if len(host_ids) > 0:
content = '{} hosts have been launched to group {} (host ids: {})'.format(num, group_name, host_ids)
messages.add_message(request, messages.SUCCESS, content)
else:
content = 'Failed to launch hosts to group {}. Please make sure the' \
' <a href="https://deploy.pinadmin.com/groups/{}/config/">group config</a>' \
' is correct. If you have any question, please contact your friendly Teletraan owners' \
' for immediate assistance!'.format(group_name, group_name)
messages.add_message(request, messages.ERROR, content)
except Exception as e:
messages.add_message(request, messages.ERROR, str(e))
log.error(traceback.format_exc())
raise
return redirect('/groups/{}'.format(group_name))
def get_success_url(self, *args, **kwargs):
messages.add_message(self.request, messages.INFO,
'Successfully Created Time Slot.')
success_url = '/manager/room/' + str(self.kwargs.get("room_id"))
return success_url
def renumber_events(pctx):
if not pctx.has_permission(pperm.edit_events):
raise PermissionDenied(_("may not edit events"))
request = pctx.request
message = None
message_level = None
if request.method == "POST":
form = RenumberEventsForm(
pctx.course.identifier, request.POST, request.FILES)
if form.is_valid():
kind = form.cleaned_data["kind"]
order_field = "time"
if form.cleaned_data["preserve_ordinal_order"]:
order_field = "ordinal"
events = list(
Event.objects.filter(
course=pctx.course, kind=kind,
# there might be event with the same kind but no ordinal,
# we don't renumber that
ordinal__isnull=False)
.order_by(order_field))
assert events
queryset = (Event.objects.filter(
course=pctx.course, kind=kind,
# there might be event with the same kind but no ordinal,
# we don't renumber that
ordinal__isnull=False))
queryset.delete()
ordinal = form.cleaned_data["starting_ordinal"]
for event in events:
new_event = Event()
new_event.course = pctx.course
new_event.kind = kind
new_event.ordinal = ordinal
new_event.time = event.time
new_event.end_time = event.end_time
new_event.all_day = event.all_day
new_event.shown_in_calendar = event.shown_in_calendar
new_event.save()
ordinal += 1
message = _("Events renumbered.")
message_level = messages.SUCCESS
else:
form = RenumberEventsForm(pctx.course.identifier)
if messages and message_level:
messages.add_message(request, message_level, message)
return render_course_page(pctx, "course/generic-course-form.html", {
"form": form,
"form_description": _("Renumber events"),
})
def get_success_url(self):
messages.add_message(self.request, messages.INFO,
'Room Created Successfully.')
success_url = '/manager/room/' + str(self.object.pk)
return success_url
def add_messages(request):
username = request.user.username
messages.add_message(request, messages.INFO, f"Hello { username }")
messages.add_message(request, messages.WARNING, "DANGER WILL ROBINSON!")
return HttpResponse("Messages added", content_type="text/plain")
def generic_edit_related(
self,
request,
model_or_manager,
related_model,
extra_context={},
form_class=None,
form_kwargs={},
form_fields="__all__",
form_widgets=None,
formset_class=None,
formset_kwargs={},
formset_fields="__all__",
instance=None,
pk=None,
post_save_callback=lambda o: None,
post_save_redirect_args=(),
post_save_redirect_kwargs={},
post_save_redirect="index",
post_save_related_callback=lambda o: None,
templates=None,
):
model, manager = model_and_manager(model_or_manager)
if instance is None and pk is not None:
instance = get_object_or_404(manager, pk=pk)
# If the developer has not provided a custom form, then dynamically
# construct a default ModelForm for them.
if form_class is None:
meta_class = type(
smart_str("Meta"),
(),
{"model": model, "fields": form_fields, "widgets": form_widgets},
)
form_class = type(
smart_str("EditForm"), self.model_form_bases, {"Meta": meta_class}
)
# If the developer has not provided a custom formset, then dynamically
# construct a default one with inlineformset_factory.
if formset_class is None:
formset_class = inlineformset_factory(
model, related_model, fields=formset_fields, extra=0
)
# Add form and formset prefixes if not already present in the kwargs
form_kwargs.setdefault("prefix", "form")
formset_kwargs.setdefault("prefix", "formset")
# Keep verbose names for model and related_model for use in messages
model_verbose_name = model._meta.verbose_name.lower()
related_verbose_name_plural = related_model._meta.verbose_name_plural.lower()
verbose = {
"model_verbose_name": model_verbose_name,
"related_verbose_name_plural": related_verbose_name_plural,
}
# Vanilla form processing here, take the post data and files, create
# an instance of form_class, save and redirect.
if request.method == "POST":
sid = transaction.savepoint()
form = form_class(
data=request.POST, files=request.FILES, instance=instance, **form_kwargs
)
if form.is_valid():
obj = form.save()
logger.debug("Saved %r to database.", obj)
# Rebuild formset with updated instance object.
formset = formset_class(
data=request.POST,
files=request.FILES,
instance=obj,
**formset_kwargs
)
if formset.is_valid():
logger.debug(
"Related formset is valid, if we don't "
"complete successfully then an exception "
"will bubble up."
)
related = formset.save()
post_save_callback(obj)
for each in related:
post_save_related_callback(each)
transaction.savepoint_commit(sid)
messages.add_message(
request,
messages.SUCCESS,
_(
"Your %(model_verbose_name)s and "
"%(related_verbose_name_plural)s "
"have been saved."
)
% verbose,
)
if isinstance(post_save_redirect, HttpResponse):
return post_save_redirect
redirect_to = self.reverse(
post_save_redirect,
args=post_save_redirect_args,
kwargs=post_save_redirect_kwargs,
)
return redirect(redirect_to)
# if we've made it out without returning a HttpRedirect then
# we should not be persisting the result.
logger.debug("ROLLBACK, we were not redirected.")
transaction.savepoint_rollback(sid)
else:
formset = formset_class(
data=request.POST,
files=request.FILES,
instance=instance,
**formset_kwargs
)
else:
form = form_class(instance=instance, **form_kwargs)
formset = formset_class(instance=instance, **formset_kwargs)
context = {
"model": manager.none(),
"form": form,
"formset": formset,
"object": instance,
"media": form.media + formset.media,
# For template compatibility, we don't use related ourselves but this
# method is only used in touchtechnology.content.admin
"related": (),
}
context.update(extra_context)
if templates is None:
templates = self.template_path("edit.related.html", model._meta.model_name)
return self.render(request, templates, context)
def get_success_url(self, *args, **kwargs):
messages.add_message(self.request, messages.INFO,
'Room Successfully Deleted.')
success_url = '/manager/create_room/'
return success_url
def generic_edit(
self,
request,
model_or_manager,
pk=None,
instance=None,
form_class=None,
form_kwargs=None,
form_fields="__all__",
form_widgets=None,
post_save_callback=lambda o: None,
post_save_redirect=None,
templates=None,
changed_messages=((messages.SUCCESS, _("Your {model} has been " "saved.")),),
unchanged_messages=((messages.INFO, _("Your {model} was not changed.")),),
permission_required=False,
perms=None,
accept_global_perms=True,
return_403=None,
related=None,
extra_context=None,
):
model, manager = model_and_manager(model_or_manager)
# If not explicitly declared, redirect the user to login if they are
# currently anonymous. If they are already identified, we can safely
# return an HTTP 403 Forbidden.
if return_403 is None:
return_403 = not request.user.is_anonymous
if instance is None and pk is not None:
instance = get_object_or_404(manager, pk=pk)
if form_kwargs is None:
form_kwargs = {}
if extra_context is None:
extra_context = {}
if post_save_redirect is None:
redirect_to = urljoin(request.path, "..") if pk is None else request.path
post_save_redirect = self.redirect(redirect_to)
# Implement permission checking for specified object instance, throw
# an HTTP 403 (using django-guardian configuration) when the user is
# not entitled to edit the instance.
if permission_required:
# If no perms are specified, build sensible default using built in
# permission types that come batteries included with Django.
if perms is None:
perms = get_perms_for_model(model, change=True)
# When there is no pk value, we're doing a creation and should
# have permission to create the object.
if pk is None or instance.pk is None:
perms = get_perms_for_model(model, add=True)
# Determine the user's permission to edit this object using the
# get_40x_or_None - saves decorating view method with
# @permission_required_or_403
has_permission = get_40x_or_None(
request,
perms,
obj=instance,
return_403=return_403,
accept_global_perms=accept_global_perms,
)
# If permission is denied, return the response. May already have
# thrown an exception by now.
if has_permission is not None:
return has_permission
# If the developer has not provided a custom form, then dynamically
# construct a default ModelForm for them.
if form_class is None:
meta_class = type(
smart_str("Meta"),
(),
{"model": model, "fields": form_fields, "widgets": form_widgets},
)
form_class = type(
smart_str("EditForm"), self.model_form_bases, {"Meta": meta_class}
)
# Whether we've dynamically constructed our form_class or not, check to
# ensure that we've inherited from all the bases. Log when we haven't,
# but don't raise any exceptions.
for base in self.model_form_bases:
if not issubclass(form_class, base):
logger.error('"%s" does not inherit "%s"', form_class, base)
# Pass the instance to the form constructor if this is a ModelForm
# subclass, otherwise it will need to be explicitly added to
# form_kwargs if expected.
if issubclass(form_class, BaseModelForm) and instance is not None:
form_kwargs.setdefault("instance", instance)
# Vanilla form processing here, take the post data and files, create
# an instance of form_class, save and redirect.
if request.method == "POST":
form = form_class(data=request.POST, files=request.FILES, **form_kwargs)
if form.is_valid():
replace = dict(
model=smart_str(model._meta.verbose_name),
models=smart_str(model._meta.verbose_name_plural),
)
if form.has_changed():
obj = form.save()
callback_res = post_save_callback(obj)
for level, message in changed_messages:
messages.add_message(request, level, message.format(**replace))
if callback_res is not None:
return callback_res
else:
for level, message in unchanged_messages:
messages.add_message(request, level, message.format(**replace))
return post_save_redirect
else:
form = form_class(**form_kwargs)
if templates is None:
templates = self.template_path("edit.html", model._meta.model_name)
templates.append("edit.html")
context = {
"model": manager.none(),
"template": select_template_name(templates),
"form": form,
"object": instance,
"related": related,
"cancel_url": post_save_redirect.url,
}
context.update(extra_context or {})
return self.render(request, templates, context)
def post(self, request, *args, **kwargs):
self.logger.info('========== Start adding Mechanic ==========')
context = super(AddMechanic, self).get_context_data(**kwargs)
rule_id = context['rule_id']
triger = request.POST.get('trigger')
input_start_date = request.POST.get('dtp_start_date')
input_end_date = request.POST.get('dtp_end_date')
input_start_time = request.POST.get('dtp_start_time')
input_end_time = request.POST.get('dtp_end_time')
start_hour = int(input_start_time[0:2])
start_minute = int(input_start_time[-2:])
start_date = datetime.strptime(input_start_date, "%Y-%m-%d")
start_date = start_date.replace(hour=start_hour, minute=start_minute,
second=0)
param_start_date = start_date.strftime('%Y-%m-%dT%H:%M:%SZ')
params = {
"event_name": triger,
"start_timestamp": param_start_date,
}
if input_end_date:
end_date = datetime.strptime(input_end_date, "%Y-%m-%d")
if input_end_time:
end_hour = int(input_end_time[0:2])
end_minute = int(input_end_time[-2:])
else:
end_hour = 0
end_minute = 1
end_date = end_date.replace(hour=end_hour, minute=end_minute, second=0)
param_end_date = end_date.strftime('%Y-%m-%dT%H:%M:%SZ')
params["end_timestamp"] = param_end_date
success, status_code, message, data = RestFulClient.post(
url=CREATE_MECHANIC.format(rule_id=rule_id),
headers=self._get_headers(),
loggers=self.logger,
params=params)
API_Logger.post_logging(loggers=self.logger, params=params,
response=data, status_code=status_code)
self.logger.info('========== Finish adding Mechanic ==========')
if success:
return redirect('rule_configuration:add_condition', rule_id=rule_id, mechanic_id=data['id'])
else:
context['dtp_start_time'] = input_start_time
context['dtp_end_time'] = input_end_time
context['dtp_start_date'] = input_start_date
context['dtp_end_date'] = input_end_date
context['trigger'] = triger
if message == 'Invalid date time':
error_msg = 'End Date could not be less than Start Date, and Start date and End date should be within range of this Rule'
else:
error_msg = message
messages.add_message(
request,
messages.ERROR,
error_msg
)
return render(request, self.template_name, context=context)
def Logout(request):
template = get_template('homePage.html')
auth.logout(request)
messages.add_message(request, messages.INFO, '成功注销了')
html = template.render(locals(), request)
return HttpResponse(html)
def generic_edit_multiple(
self,
request,
model_or_manager,
extra_context=None,
formset_class=None,
formset_kwargs=None,
formset_fields="__all__",
post_save_callback=lambda o: None,
post_save_redirect_args=None,
post_save_redirect_kwargs=None,
post_save_redirect=None,
templates=None,
changed_messages=None,
perms=None,
permission_required=False,
accept_global_perms=True,
return_403=None,
*args,
**kwargs
):
if extra_context is None:
extra_context = {}
if formset_kwargs is None:
formset_kwargs = {}
if post_save_redirect_args is None:
post_save_redirect_args = ()
if post_save_redirect_kwargs is None:
post_save_redirect_kwargs = {}
if changed_messages is None:
changed_messages = (
(messages.SUCCESS, _("Your {models} have been saved.")),
)
# If not explicitly declared, redirect the user to login if they are
# currently anonymous. If they are already identified, we can safely
# return an HTTP 403 Forbidden.
if return_403 is None:
return_403 = not request.user.is_anonymous
# Try and introspect the model if possible.
model, manager = model_and_manager(model_or_manager)
queryset = manager.all()
# Implement permission checking for list of objects, will filter the
# list to those objects the user is entitled to work on if we do not
# throw an HTTP 403 for no permission.
if permission_required:
if perms is None:
perms = get_all_perms_for_model_cached(model)
# Determine the user's permission to see the list using the
# get_40x_or_None - saves decorating view method with
# @permission_required_or_403
has_permission = get_40x_or_None(
request,
perms,
return_403=return_403,
accept_global_perms=accept_global_perms,
any_perm=True,
)
# If the user does not have any global permissions then adjust the
# queryset to return only the objects they can act on.
if not any([request.user.has_perm(p) for p in perms]):
queryset = get_objects_for_user(
request.user, perms, queryset, use_groups=True, any_perm=True
)
# If permission is denied, return the response. May already have
# thrown an exception by now.
if not queryset and has_permission is not None:
return has_permission
queryset = get_objects_for_user(
request.user, perms, queryset, any_perm=True
)
# If queryset is not already specified as a keyword argument to the
# formset attach it now. Value in formset_kwargs will take precedence.
queryset = formset_kwargs.pop("queryset", queryset)
# If the developer has not provided a custom formset, then dynamically
# construct a default ModelFormSet for them.
if formset_class is None:
formset_class = modelformset_factory(model, extra=0, fields=formset_fields)
if post_save_redirect is None:
redirect_to = urljoin(request.path, "..")
post_save_redirect = self.redirect(redirect_to)
# Vanilla formset processing here, take the post data and files, create
# an instance of formset_class, save and redirect.
if request.method == "POST":
formset = formset_class(
data=request.POST,
files=request.FILES,
queryset=queryset,
**formset_kwargs
)
if formset.is_valid():
replace = dict(
model=smart_str(model._meta.verbose_name),
models=smart_str(model._meta.verbose_name_plural),
)
objects = formset.save()
for each in objects:
post_save_callback(each)
for level, message in changed_messages:
messages.add_message(request, level, message.format(**replace))
if isinstance(post_save_redirect, HttpResponse):
return post_save_redirect
redirect_to = self.reverse(
post_save_redirect,
args=post_save_redirect_args,
kwargs=post_save_redirect_kwargs,
)
return redirect(redirect_to)
else:
formset = formset_class(queryset=queryset, **formset_kwargs)
context = {
"model": manager.none(),
"formset": formset,
"object_list": queryset,
}
context.update(extra_context)
if templates is None:
templates = self.template_path("edit_multiple.html", model._meta.model_name)
templates.append("edit_multiple.html")
return self.render(request, templates, context)
def form_invalid(self, form):
messages.add_message(self.request, messages.ERROR, 'Form-Fehler!')
return super().form_invalid(form)
def form_invalid(self, form):
messages.add_message(self.request, messages.ERROR,
_('Please correct the following errors.'))
return super().form_invalid(form)
def form_valid(self, form):
messages.add_message(self.request, messages.SUCCESS,
_("Your donor info has been updated!"))
return super().form_valid(form)
def logout_view(request):
logout(request)
messages.add_message(request, messages.INFO, "Successfully logged out")
return redirect(index)
