def _apply_changes(request, old_status, new_status):
"""Apply the changes"""
modified = False
if old_status['enabled'] != new_status['enabled']:
sub_command = 'enable' if new_status['enabled'] else 'disable'
actions.superuser_run('transmission', [sub_command])
transmission.service.notify_enabled(None, new_status['enabled'])
modified = True
if old_status['download_dir'] != new_status['download_dir'] or \
old_status['rpc_username'] != new_status['rpc_username'] or \
old_status['rpc_password'] != new_status['rpc_password']:
new_configuration = {
'download-dir': new_status['download_dir'],
'rpc-username': new_status['rpc_username'],
'rpc-password': new_status['rpc_password'],
}
actions.superuser_run('transmission', ['merge-configuration'],
input=json.dumps(new_configuration).encode())
modified = True
if modified:
messages.success(request, _('Configuration updated'))
else:
messages.info(request, _('Setting unchanged'))
def merge_path(request):
"""
Path merging view
"""
response = {}
if request.method == 'POST':
try:
ids_path_merge = request.POST.getlist('path[]')
if len(ids_path_merge) == 2:
path_a = Path.objects.get(pk=ids_path_merge[0])
path_b = Path.objects.get(pk=ids_path_merge[1])
if not path_a.same_structure(request.user) or not path_b.same_structure(request.user):
response = {'error': _(u"You don't have the right to change these paths")}
elif path_a.merge_path(path_b):
response = {'success': _(u"Paths merged successfully")}
messages.success(request, _(u"Paths merged successfully"))
else:
response = {'error': _(u"No matching points to merge paths found")}
else:
raise
except Exception as exc:
response = {'error': exc, }
return HttpResponse(json.dumps(response), mimetype="application/json")
def permissions(request, title):
document = get_object_or_404(Document, url_title=title)
content_type = ContentType.objects.get_for_model(document)
check_permissions(document, request.user, [document.edit_permission_name])
if not document.show_permissions_editor():
raise PermissionDenied()
PermissionForm = get_permission_form(document)
PermissionFormset = formset_factory(get_permission_form(document), extra=0)
initial_data = PermissionForm.prepare_initial_data(Group.objects.all(), content_type, document)
formset = PermissionFormset(request.POST or None, initial=initial_data)
if request.POST and formset.is_valid():
for form in formset:
form.save(document)
messages.success(request, _("Permissions have been changed successfully."))
if request.user.has_perm(document.edit_permission_name, document):
return HttpResponseRedirect(reverse(document.get_permissions_url_name(), args=[document.url_title]))
if request.user.has_perm(document.view_permission_name, document):
return HttpResponseRedirect(reverse(document.get_view_url_name(), args=[document.url_title]))
return HttpResponseRedirect(reverse('index'))
return render(request, 'documents_permissions.html', {
'document': document,
'formset_header': PermissionForm.header(content_type),
'formset': formset,
'active_page': 'permissions',
'permission_overview': document_permission_overview(request.user, document),
})
def obj_perms_manage_group_view(self, request, object_pk, group_id):
"""
Manages selected groups' permissions for current object.
"""
group = get_object_or_404(Group, id=group_id)
obj = get_object_or_404(self.queryset(request), pk=object_pk)
form_class = self.get_obj_perms_manage_group_form()
form = form_class(group, obj, request.POST or None)
if request.method == 'POST' and form.is_valid():
form.save_obj_perms()
msg = ugettext("Permissions saved.")
messages.success(request, msg)
info = (
self.admin_site.name,
self.model._meta.app_label,
self.model._meta.module_name
)
url = reverse(
'%s:%s_%s_permissions_manage_group' % info,
args=[obj.pk, group.id]
)
return redirect(url)
context = self.get_obj_perms_base_context(request, obj)
context['group_obj'] = group
context['group_perms'] = get_perms(group, obj)
context['form'] = form
return render_to_response(self.get_obj_perms_manage_group_template(),
context, RequestContext(request, current_app=self.admin_site.name))
def delete_document(request, title):
document = get_object_or_404(Document, url_title=title)
check_permissions(document, request.user, [document.edit_permission_name])
document.delete()
messages.success(request, _("Successfully deleted document: {}".format(document.title)))
return HttpResponse()
def form_valid(self, form):
osf_id = form.cleaned_data.get('osf_id')
osf_user = OSFUser.load(osf_id)
if not osf_user:
raise Http404('OSF user with id "{}" not found. Please double check.'.format(osf_id))
osf_user.is_staff = True
osf_user.save()
# create AdminProfile for this new user
profile, created = AdminProfile.objects.get_or_create(user=osf_user)
osf_user.groups.clear()
prereg_admin_group = Group.objects.get(name='prereg_admin')
for group in form.cleaned_data.get('group_perms'):
osf_user.groups.add(group)
split = group.name.split('_')
group_type = split[0]
if group_type == 'reviews':
provider_id = split[1]
provider = PreprintProvider.load(provider_id)
provider.notification_subscriptions.get(event_name='new_pending_submissions').add_user_to_subscription(osf_user, 'email_transactional')
if group == prereg_admin_group:
administer_permission = Permission.objects.get(codename='administer_prereg')
osf_user.user_permissions.add(administer_permission)
osf_user.save()
if created:
messages.success(self.request, 'Registration successful for OSF User {}!'.format(osf_user.username))
else:
messages.success(self.request, 'Permissions update successful for OSF User {}!'.format(osf_user.username))
return super(RegisterUser, self).form_valid(form)
def get(self, request, puzzle_name):
try:
user = User.objects.get(id=request.session["id"])
except:
return redirect("accounts-login")
try:
puzzle = Puzzle.objects.get(short_name = puzzle_name)
except:
raise Http404("Puzzle does not exist")
context = {
"puzz_id": puzzle.id,
"name": puzzle.name,
}
answers = AnswerAttempt.objects.filter(user=user).filter(puzzle=puzzle)
answer_list = []
unsolved = True
if len(answers) > 0:
for answer in answers:
is_right = check_answer(answer.answer, puzzle.answer)
answer_list.append( {"answer": answer.answer, "correct": is_right })
if is_right:
messages.success(request, "{} is correct!".format(answer.answer))
unsolved = False
context["answers"] = answer_list
context["unsolved"] = unsolved
return render(request, puzzle.url, context)
def beer_type_add(request):
#btype = get_object_or_404(models.BeerType, id=beer_id)
form = forms.BeerTypeForm()
if request.method == 'POST':
form = forms.BeerTypeForm(request.POST)
if form.is_valid():
btype = form.save()
new_image = request.FILES.get('new_image')
if new_image:
pic = models.Picture.objects.create()
ext = new_image.name.split('.')[-1]
pic.image.save(btype.brewer.name+'.'+btype.name+'.'+ext, new_image)
pic.btype_id = btype.id
pic.btype_name = btype.name
pic.brewer_id = btype.brewer
pic.brewer_name = btype.brewer.name
pic.save()
btype.image = pic
btype.save()
messages.success(request, 'Beer type added.')
context = RequestContext(request)
context['beer_type'] = "new"
context['form'] = form
return render_to_response('beer_type_add.html', context_instance=context)
def edit(request, petreport_id):
pet_report = get_object_or_404(PetReport, pk=petreport_id)
if request.method == "GET":
form = PetReportForm(instance=pet_report)
elif request.method == "POST":
form = PetReportForm(request.POST, request.FILES)
if form.is_valid() == True:
pr = form.save(commit=False)
pet_report.update_fields(pr, request=request.POST)
messages.success(request, "You've successfully updated your pet report.")
return redirect(URL_PRDP + "%d/" % pet_report.id)
form = PetReportForm(instance=pet_report)
messages.error(request, "Something went wrong. Please check the fields and try again.")
else:
raise Http404
return render_to_response(HTML_EDIT_PETREPORT, {
"form": form,
"petreport": pet_report,
"RECAPTCHA_CLIENT_SECRET": settings.RECAPTCHA_CLIENT_SECRET,
"PETREPORT_TAG_INFO_LENGTH":PETREPORT_TAG_INFO_LENGTH,
"PETREPORT_DESCRIPTION_LENGTH":PETREPORT_DESCRIPTION_LENGTH,
"PETREPORT_CONTACT_NAME_LENGTH": PETREPORT_CONTACT_NAME_LENGTH,
"PETREPORT_CONTACT_NUMBER_LENGTH": PETREPORT_CONTACT_NUMBER_LENGTH,
"PETREPORT_CONTACT_EMAIL_LENGTH": PETREPORT_CONTACT_EMAIL_LENGTH,
"PETREPORT_CONTACT_LINK_LENGTH": PETREPORT_CONTACT_LINK_LENGTH
}, RequestContext(request))
def add_edit(request, link_id=None):
if link_id:
link = get_object_or_404(request.user.links, pk=link_id)
else:
link = None
if request.method == 'POST':
form = LinkForm(request.POST, instance=link)
if form.is_valid():
link = form.save(commit=False)
link.user = request.user
link.save()
if link:
messages.success(request, "Link updated successfully.")
else:
messages.success(request, "Link added successfully.")
return redirect('profile:links:view')
else:
form = LinkForm(instance=link)
return render(request, 'profile/links/add_edit.html', {
'link': link,
'form': form,
})
def object_action(self, form, instance):
try:
if instance.is_superuser or instance.is_staff:
messages.error(
self.request,
_(
'Super user and staff user password '
'reseting is not allowed, use the admin '
'interface for these cases.'
)
)
else:
instance.set_password(form.cleaned_data['new_password_1'])
instance.save()
messages.success(
self.request, _(
'Successfull password reset for user: %s.'
) % instance
)
except Exception as exception:
messages.error(
self.request, _(
'Error reseting password for user "%(user)s": %(error)s'
) % {
'user': instance, 'error': exception
}
)
def delete(request, drum_component_id):
drum_component = ComponentDrum.objects.get(pk=drum_component_id)
drum_component.delete()
messages.success(request, 'Record deleted successfully!')
return redirect('/drum-component/')
def project_versions(request, project_slug):
"""Project version list view
Shows the available versions and lets the user choose which ones to build.
"""
project = get_object_or_404(Project.objects.protected(request.user),
slug=project_slug)
versions = Version.objects.public(user=request.user, project=project, only_active=False)
active_versions = versions.filter(active=True)
inactive_versions = versions.filter(active=False)
inactive_filter = VersionSlugFilter(request.GET, queryset=inactive_versions)
active_filter = VersionSlugFilter(request.GET, queryset=active_versions)
# If there's a wiped query string, check the string against the versions
# list and display a success message. Deleting directories doesn't know how
# to fail. :)
wiped = request.GET.get('wipe', '')
wiped_version = versions.filter(slug=wiped)
if wiped and wiped_version.count():
messages.success(request, 'Version wiped: ' + wiped)
return render_to_response(
'projects/project_version_list.html',
{
'inactive_filter': inactive_filter,
'active_filter': active_filter,
'project': project,
},
context_instance=RequestContext(request)
)
def video_handler(request, video, format="mp4", prev=None, next=None):
if not video["available"]:
if request.is_admin:
# TODO(bcipolli): add a link, with querystring args that auto-checks this video in the topic tree
messages.warning(request, _("This video was not found! You can download it by going to the Update page."))
elif request.is_logged_in:
messages.warning(request, _("This video was not found! Please contact your teacher or an admin to have it downloaded."))
elif not request.is_logged_in:
messages.warning(request, _("This video was not found! You must login as an admin/teacher to download the video."))
# Fallback mechanism
available_urls = dict([(lang, avail) for lang, avail in video["availability"].iteritems() if avail["on_disk"]])
if video["available"] and not available_urls:
vid_lang = "en"
messages.success(request, "Got video content from %s" % video["availability"]["en"]["stream"])
else:
vid_lang = select_best_available_language(request.language, available_codes=available_urls.keys())
context = {
"video": video,
"title": video["title"],
"selected_language": vid_lang,
"video_urls": video["availability"].get(vid_lang),
"subtitle_urls": video["availability"].get(vid_lang, {}).get("subtitles"),
"prev": prev,
"next": next,
"backup_vids_available": bool(settings.BACKUP_VIDEO_SOURCE),
"use_mplayer": settings.USE_MPLAYER and is_loopback_connection(request),
}
return context
def edit(request, drum_component_id):
drum_component = ComponentDrum.objects.get(pk=drum_component_id)
if request.method == 'POST':
form = FormDrumComponent(request.POST)
if form.is_valid():
drum_component.name = request.POST['name']
drum_component.price = request.POST['price']
drum_component.description = request.POST['description']
drum_component.save()
messages.success(request, 'Record updated successfully!')
return redirect('/drum-component/')
else:
data = {'name':drum_component.name,
'price':drum_component.price,
'description':drum_component.description}
form = FormDrumComponent(initial=data)
return render(request, 'drum-component/edit.html',{
'form':form,
'drum_component_id':drum_component.id
})
def manage_otherfunding(request, grad_slug):
grad = get_object_or_404(GradStudent, slug = grad_slug)
otherfunding = OtherFunding.objects.filter(student=grad).order_by('semester__name')
if request.method == 'POST':
form = OtherFundingForm(request.POST)
if form.is_valid():
fund = form.save(commit=False)
fund.student = grad
fund.save()
messages.success(request, "Other funding for %s sucessfully saved." % (grad))
l = LogEntry(userid=request.user.username,
description="added other funding \"%s\" for %s" % (fund.description, grad.slug),
related_object=fund )
l.save()
return HttpResponseRedirect(reverse('grad.views.manage_otherfunding', kwargs={'grad_slug':grad.slug}))
else:
form = OtherFundingForm(initial={'student':grad, 'semester':Semester.get_semester(), 'amount':'0.00'})
context = {
'grad':grad,
'form': form,
'otherfunding': otherfunding,
}
return render(request, 'grad/manage_otherfunding.html', context)
def alias_add_for_member(request, id, template_name='membership/membership_add_alias.html'):
membership = get_object_or_404(Membership, id=id)
class Form(ModelForm):
class Meta:
model = Alias
exclude = ('owner', 'account', 'expiration_date')
if request.method == 'POST':
form = Form(request.POST)
if form.is_valid():
f = form.cleaned_data
name = f['name']
comment = f['comment']
alias = Alias(owner=membership, name=name, comment=comment)
alias.save()
messages.success(request,
_('Alias {alias} successfully created for {membership}.'
'').format(alias=alias, membership=membership))
logger.info("Alias %s added by %s." % (alias, request.user.username))
return redirect('membership_edit', membership.id)
else:
form = Form()
return render_to_response(template_name,
{'form': form,
'membership': membership },
context_instance=RequestContext(request))
def modificarcita(request, codigo):
instancia = get_object_or_404(UltimaCita, pk=codigo)
nueva_cita= CitaForm(request.POST or None, instance=instancia)
if nueva_cita.is_valid():
nueva_cita.save()
messages.success(request, 'SU NUEVA CITA SERA EL %s '% (request.POST['proximo']))
return render_to_response('administrador/modificarcita.html',{'nueva_cita':nueva_cita},context_instance=RequestContext(request))
def send_success_message(self, instance, request):
"""
Sends a success message to the request user
using django's contrib.messages app.
"""
message = instance.success_message or ugettext('The form has been sent.')
messages.success(request, message)
def send_mail_to_owners(self, request, queryset):
for momend in queryset:
_successful = DataManagerUtil.send_momend_created_email(momend)
if _successful:
messages.success(request, 'Successful: '+str(momend.id))
else:
messages.error(request, 'Error: '+str(momend.id))
def index(request):
if request.method == 'POST':
form = SettingsForm(request.POST)
if form.is_valid():
Settings().start_sell = datetime_to_string(form.cleaned_data['start_sell'])
Settings().end_sell = datetime_to_string(form.cleaned_data['end_sell'])
Settings().start_purchase = datetime_to_string(form.cleaned_data['start_purchase'])
Settings().end_purchase = datetime_to_string(form.cleaned_data['end_purchase'])
Settings().profit_per_book = form.cleaned_data['profit_per_book']
Settings().tos_url = form.cleaned_data['tos_url']
Settings().homepage_info = form.cleaned_data['homepage_info']
messages.success(request, _("Settings were updated successfully."))
return HttpResponseRedirect("")
else:
settings = Settings('start_sell', 'end_sell', 'start_purchase', 'end_purchase',
'profit_per_book', 'tos_url', 'homepage_info')
# Pack the retrieved values into new dictionary, formatting them as HTML datetime first
values = dict(
filter(lambda x: x is not None,
[add_date_value(settings, 'start_sell'),
add_date_value(settings, 'end_sell'),
add_date_value(settings, 'start_purchase'),
add_date_value(settings, 'end_purchase'),
add_value(settings, 'profit_per_book', 1),
add_value(settings, 'tos_url', ''),
add_value(settings, 'homepage_info', '')]))
form = SettingsForm(initial=values)
return render(request, 'settings/index.html', {'form': form})
def user_unsubscribe_address(request, address_subscription_id):
'''
For logged-in users to unsubscribe an address
'''
address_subscription = get_object_or_404(AddressSubscription, id=address_subscription_id)
assert address_subscription.auth_user == request.user
if address_subscription.unsubscribed_at:
msg = _("You've already unsubscribed from this alert")
messages.info(request, msg)
else:
address_subscription.unsubscribed_at = now()
address_subscription.save()
address_uri = reverse('address_overview', kwargs={
'coin_symbol': address_subscription.coin_symbol,
'address': address_subscription.b58_address,
})
msg = _('You have been unsubscribed from notifications on <a href="%(address_uri)s">%(b58_address)s</a>' % {
'b58_address': address_subscription.b58_address,
'address_uri': address_uri,
})
messages.success(request, msg, extra_tags='safe')
return HttpResponseRedirect(reverse('dashboard'))
def tags(request):
import json
if request.method == 'POST':
name = request.POST.get('tag')
object_id = request.POST.get('object_id')
content_type_id = request.POST.get('content_type_id')
tag = TaggedItem(tag=name, object_id=object_id)
tag.content_type_id = content_type_id
tag.created_by = request.user
tag.save()
messages.success(request, 'Tag %s added' % name)
return redirect(request.META['HTTP_REFERER'])
query = TaggedItem.objects.all()
oid = request.GET.get('oid')
ctype = request.GET.get('ctype')
term = request.GET.get('term')
if oid and ctype:
query = query.exclude(object_id=oid, content_type=ctype)
if term:
query = query.filter(tag__icontains=term)
# DISTINCT ON fields is not supported by this database backend
tags = list()
[tags.append(x.tag) for x in query if x.tag not in tags]
return HttpResponse(json.dumps(tags), content_type="application/javascript")
def update_course_details(request):
if request.method == 'POST' and request.is_ajax():
course_description = '\n'+request.POST.get('_c_desc').strip()
course_objective = '\n'+request.POST.get('_c_objve').strip()
course_eligibility = '\n'+request.POST.get('_c_eligbty').strip()
course_crt_benefits = '\n'+request.POST.get('_c_cbf').strip()
course_short_desc = '\n'+request.POST.get('_c_csd').strip()
if len(course_description)<10 or len(course_objective) < 10 or len(course_eligibility) < 10:
messages.error(request,'All 3 fields must have at least 10 characters.')
return HttpResponse(json.dumps(True), content_type="application/json")
course = CourseDetail.objects.get(course_uuid=request.POST.get('_c_id'))
if course:
try:
course.course_information.description = course_description
course.course_information.objective = course_objective
course.course_information.crt_benefits = course_crt_benefits
course.course_information.eligibility = course_eligibility
course.course_information.short_description = course_short_desc
course.course_information.save()
messages.success(request,'Course details updated.')
return HttpResponse(json.dumps(True), content_type="application/json")
except Exception as e:
CourseInformation.objects.create(course = course,course_description=course_description,course_objective=course_objective)
return HttpResponse(json.dumps(False), content_type="application/json")
def delete_module_video(request):
'''Delete a video of perticular module and able to re-fill it with new video'''
if request.is_ajax() and request.method == 'POST':
try:
course = CourseDetail.objects.get(course_uuid = request.POST.get('_c_id'))
# total_modules = CourseWeek.objects.filter(course = course).count()
module_name = request.POST.get('_module')
week = request.POST.get('_week')
import shutil
course_week = CourseWeek.objects.filter(course = course, week_module_name = module_name, week_number = week)
assert course_week,'AssertError: this course_week not found with course'
course_week = course_week[0]
# deleted_module_number = course_week.module_number
course_video = CourseVideos.objects.filter(course = course, week = course_week, module_name = module_name)
assert course_video,'AssertError: this course_video not found with course'
course_video = course_video[0]
to_be_deleted = '/'.join(str(course_video.video_file).split('/')[:-1])
# print to_be_deleted
if os.path.isdir(to_be_deleted):
shutil.rmtree(to_be_deleted)
course_video.delete()
course_week.is_available = True
course_week.save()
else:
return HttpResponse(json.dumps(False), content_type = "application/json")
messages.success(request,'Week '+ week +' : Module named '+ module_name +' all its video(s) deleted successfully.')
except Exception as e:
print e.args
return HttpResponse(json.dumps(False), content_type = "application/json")
return HttpResponse(json.dumps(True), content_type = "application/json")
def teacher_register(request):
if request.method == 'POST':
post_req_data = request.POST
data = {}
register_form = TeacherRegistrationForm(data=post_req_data)
teacher_model = TeacherModel(data=post_req_data)
if register_form.is_valid():
try:
teacher_model = TeacherModel(data=post_req_data)
if teacher_model.is_valid():
address_model = AddressModel(data=post_req_data)
if address_model.is_valid():
try:
city = City.objects.get(city_name=post_req_data.get('city', ''))
address = address_model.save(commit=False)
address.city_obj = city
address.street1 = post_req_data.get('street1', '')
address.street2 = post_req_data.get('street2', '')
address.pincode = post_req_data.get('pincode', '')
address.save()
except Exception as e:
print e.args
try:
import uuid
teacher = teacher_model.save(commit=False)
teacher.address = address
teacher.uuid_key = uuid.uuid4()
teacher_pass = post_req_data.get('password')
teacher.set_password(teacher_pass)
teacher.gender = post_req_data.get('gender',None)
p_date = post_req_data.get('d_o_b',None)
if p_date:
import datetime
d_o_b = datetime.datetime.strptime(p_date, '%m/%d/%Y').date()
teacher.d_o_b = d_o_b
else:
pass
teacher.higher_education = post_req_data.get('higher_education',None)
teacher.is_active = False
teacher.save()
kawrgs = {'teacher_pass' : teacher_pass,'teacher_uname' : teacher.username}
messages.success(request,'Teacher created. Please ask the server administrator to activate your account.')
return HttpResponseRedirect('/teacher/login/')
except Exception as e:
print e.args
else:
data = {'form': address_model,'register_error':True}
else:
data = {'form': teacher_model,'register_error':True}
except Exception as e:
print e.args
else:
data = {'form': register_form,'register_error':True}
return render(request, 'teacher/register_teacher.html', data)
else:
teacher_form = TeacherModel()
return render(request, 'teacher/register_teacher.html', {'form':teacher_form})
def teacher_login(request):
if request.user.is_authenticated():
messages.info(request,'Please logout first and then re-login with a different account.')
return HttpResponseRedirect('/home/')
if request.method == 'POST':
t_username = request.POST.get('username')
t_password = request.POST.get('password')
try:
t_user = authenticate(username=t_username, password=t_password)
teacher = Teacher.objects.get(pk=t_user.id)
except Exception as e:
t_user = None
teacher = None
if teacher is not None:
if t_user.is_active:
login(request, t_user)
messages.success(request,'You logged in successfully.')
return HttpResponseRedirect('/teacher/')
else:
messages.warning(request,'Your account is not yet active.')
return render(request, 'teacher/login_teacher.html', {'t_not_active': True, 'next': request.POST.get('next')})
else:
course_list = CourseDetail.objects.all()
course_list = pagination.get_paginated_list(obj_list=course_list,page = request.GET.get('page'))
messages.error(request,'Please enter valid credentials.')
return render(request, 'teacher/login_teacher.html', {'t_login_error': True, 'next': request.POST.get('next')})
else:
return render(request,'teacher/login_teacher.html',{})
def create_organism(request):
if request.method == 'POST':
form = CreateOrganismForm(data = request.POST)
if form.is_valid():
query_dict = {
"method" : "add_organism",
"key": request.user.sessionkey,
"params" : {
"data" : {
"name": form.cleaned_data['name']
}
}
}
content_dict = api_request(query_dict)
if content_dict.has_key('result'):
cache.delete('organisms')
messages.success(request, 'Organism "{}" successfully create.'.format(form.cleaned_data['name']))
elif content_dict.has_key('error'):
messages.error(request, 'ERROR: {}'.format(content_dict['error']['message']))
else:
form = CreateOrganismForm()
template_context = {'form': form,}
return render_to_response('create_organism.html', template_context, context_instance=RequestContext(request))
def post(self, request, *args, **kwargs):
resource = get_object_or_404(Resource, pk=self.kwargs['pk'])
user = self.request.user
if user.has_perm('engine.remove_from_collection'):
user.engine_user.account.collection.remove(resource)
next = self.request.GET.get('next', '')
if next:
url = next
else:
url = reverse('resource_detail', kwargs={'pk': resource.pk})
messages.success(self.request, 'Resource removed from collection')
#Send a signal to reindex this resource
reindex_resource.send(
sender=self.__class__,
instance=resource
)
return HttpResponseRedirect(url)
raise PermissionDenied()
def speaker_create(request):
try:
return redirect(request.user.speaker_profile)
except ObjectDoesNotExist:
pass
if request.method == "POST":
try:
speaker = Speaker.objects.get(invite_email=request.user.email)
found = True
except Speaker.DoesNotExist:
speaker = None
found = False
form = SpeakerForm(request.POST, request.FILES, instance=speaker)
if form.is_valid():
speaker = form.save(commit=False)
speaker.user = request.user
if not found:
speaker.invite_email = None
speaker.save()
messages.success(request, "Speaker profile created.")
return redirect("speaker_dashboard")
else:
form = SpeakerForm()
ctx = {
"form": form,
}
ctx = RequestContext(request, ctx)
return render_to_response("speakers/speaker_create.html", ctx)
def form_valid(self, form):
result = super().form_valid(form)
companies.create_default_company_departments(self.object)
messages.success(self.request, "Создана компания %s вместе со стандартными отделами Dispatchers, Update, "
"Safety, Fleet, Trailer, Logbook" % form.cleaned_data['name'])
return result
def delete(self, *args, **kwargs):
messages.success(self.request, "Comment Deleted")
return super().delete(*args, **kwargs)
def getout(request):
logout(request)
messages.success(request, F"Tu sesion se ha cerrado")
return redirect("flights")
def get_payment_info_isUser(request):
current_user = request.user
profile = Profile.objects.get(user=current_user)
payment_type = request.POST['payment_type']
paymentType = PaymentType.objects.get(name=payment_type)
address_id = request.POST['address']
adres = Address.objects.get(pk=address_id)
address = adres.address
address_city = adres.city
address_district = adres.district
orderProduct = ""
subtotal = 0
discount = 0
net_total = 0
total = 0
kargo = Cargo.objects.get(name='Üzeri Kargo')
kdv = Settings.objects.get(name='kdv')
kargo1 = 0
products = general_methods.products_in_card(json.loads(request.POST['card'])) # Sepetteki ürünler çağrılıyor
for order in products:
subtotal = order.subtotal + subtotal
c_code = json.loads(request.POST['c_code'])
if c_code == None:
discount = discount
else:
code = c_code['c_code']
discount = couponControl(code, subtotal)
if products:
net_total = subtotal * 100 / (100 + float(kdv.value))
if subtotal >= kargo.lower_limit: # ücretsiz kargo
kargo1 = 0
total = subtotal
kdv = total - net_total
total = Decimal(subtotal) - Decimal(discount)
else:
kargo1 = kargo.price # ücretli kargo
total = subtotal
kdv = total - net_total
total = subtotal + kargo.price - discount
order = Order()
if request.POST['address-value'] == 'TRUE': # fatura adresi = adres
order.otherAddress = address
else:
order.otherAddress = request.POST['invoice_address'] # Farklı fatura adresi
# siparis olusturuluyor
order.payment_type = paymentType
order.totalPrice = total
order.cargo = kargo1
order.profile = profile
order.address = address
order.city = address_city
order.kdv = kdv
order.discount = discount
order.netTotal = net_total
order.subTotal = subtotal
order.isGuest = False
order.district = address_district
order.save()
# siparişin ürünleri
for product_order in products:
totalProductPrice = product_order.count * product_order.price
product = Product.objects.get(pk=product_order.id)
orderProduct = OrderProduct(order=order, product=product,
quantity=product_order.count, totalProductPrice=totalProductPrice)
orderProduct.save()
"""invoice_data = {'orders': products, 'subtotal': Decimal(subtotal), 'total': Decimal(total),
'net_total': Decimal(net_total), 'discount': discount,
'kdv': kdv, 'address': order.address, 'city': address_city, 'district': address_district,
'payment_type': order.payment_type, 'invoice_address': order.otherAddress, 'order': order,
'profile': profile}
subject, from_email, to = 'Oxit Bilişim Teknolojileri', '*****@*****.**', current_user.email
text_content = 'Fatura Bilgileri '
html_body = render_to_string("mailTemplates/invoice2.html", invoice_data)
msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
msg.attach_alternative(html_body, "text/html")
msg.send() """
messages.success(request, 'Siparişiniz Başarıyla Oluştruldu.')
if order.payment_type == 'Havale/EFT':
messages.success(request, 'Sipariş başarıyla eklendi.')
return redirect('inoks:havale-eft-bilgi', siparis=order.id)
elif order.payment_type.name == 'Kredi Kartı':
paymentMethod = PaymentMethod.objects.get(isActive=True)
if paymentMethod.name == 'Paytr':
messages.success(request, 'Sipariş başarıyla eklendi.')
return redirect('inoks:payTr-make-creditCard-payment', siparis=order.id)
if paymentMethod.name == 'Iyzico':
messages.success(request, 'Sipariş başarıyla eklendi.')
return redirect('inoks:iyzipay-make-creditcard-payment', siparis=order.id)
else:
order.isPayed = True
orderProducts = OrderProduct.objects.filter(order=order)
for orderProduct in orderProducts:
product = Product.objects.get(pk=orderProduct.product.pk)
product.stock = product.stock - orderProduct.quantity
if product.stock <= 5:
notification = Notification()
notification.message = "Kod: " + str(product.code) + " olan ürün stoğunu güncelleyin.Stok: " + str(
product.stock) + ""
product.save()
order.order_situations.add(OrderSituations.objects.get(name="Onay Bekliyor"))
order.save()
return render(request, 'checkout/odeme-tamamla.html',
{'orders': products, 'subtotal': Decimal(subtotal), 'total': Decimal(total),
'net_total': Decimal(net_total),
'kdv': kdv, 'address': order.address, 'city': address_city, 'district': address_district,
'payment_type': order.payment_type, 'invoice_address': order.otherAddress})
def add_pushover(request):
if settings.PUSHOVER_API_TOKEN is None or settings.PUSHOVER_SUBSCRIPTION_URL is None:
raise Http404("pushover integration is not available")
if not request.user.is_authenticated:
ctx = {"page": "channels"}
return render(request, "integrations/add_pushover.html", ctx)
if request.method == "POST":
# Initiate the subscription
state = _prepare_state(request, "pushover")
failure_url = settings.SITE_ROOT + reverse("hc-channels")
success_url = settings.SITE_ROOT + reverse("hc-add-pushover") + "?" + urlencode({
"state": state,
"prio": request.POST.get("po_priority", "0"),
"prio_up": request.POST.get("po_priority_up", "0")
})
subscription_url = settings.PUSHOVER_SUBSCRIPTION_URL + "?" + urlencode({
"success": success_url,
"failure": failure_url,
})
return redirect(subscription_url)
# Handle successful subscriptions
if "pushover_user_key" in request.GET:
key = _get_validated_code(request, "pushover", "pushover_user_key")
if key is None:
return HttpResponseBadRequest()
# Validate priority
prio = request.GET.get("prio")
if prio not in ("-2", "-1", "0", "1", "2"):
return HttpResponseBadRequest()
prio_up = request.GET.get("prio_up")
if prio_up not in ("-2", "-1", "0", "1", "2"):
return HttpResponseBadRequest()
if request.GET.get("pushover_unsubscribed") == "1":
# Unsubscription: delete all Pushover channels for this project
Channel.objects.filter(project=request.project, kind="po").delete()
return redirect("hc-channels")
# Subscription
channel = Channel(project=request.project, kind="po")
channel.value = "%s|%s|%s" % (key, prio, prio_up)
channel.save()
channel.assign_all_checks()
messages.success(request, "The Pushover integration has been added!")
return redirect("hc-channels")
# Show Integration Settings form
ctx = {
"page": "channels",
"po_retry_delay": td(seconds=settings.PUSHOVER_EMERGENCY_RETRY_DELAY),
"po_expiration": td(seconds=settings.PUSHOVER_EMERGENCY_EXPIRATION),
}
return render(request, "integrations/add_pushover.html", ctx)
def form_valid(self, form):
result = super().form_valid(form)
messages.success(self.request, "Компания %s отредактирована" % self.object.name)
return result
def delete(self, request, *args, **kwargs):
company_name = self.get_object().name
result = super().delete(request, *args, **kwargs)
messages.success(request, "Компания %s и все связанные данные с ней удалены" % company_name)
return result
def salvar(request, hash):
db_slug = 'default'
try:
usuario_id = request.user.id
dict_hash = get_hash_url(hash)
s2399_procjudtrab_id = int(dict_hash['id'])
if 'tab' not in dict_hash.keys():
dict_hash['tab'] = ''
for_print = int(dict_hash['print'])
except:
usuario_id = False
return redirect('login')
usuario = get_object_or_404(Usuarios.objects.using(db_slug),
excluido=False,
id=usuario_id)
pagina = ConfigPaginas.objects.using(db_slug).get(
excluido=False, endereco='s2399_procjudtrab')
permissao = ConfigPermissoes.objects.using(db_slug).get(
excluido=False,
config_paginas=pagina,
config_perfis=usuario.config_perfis)
if s2399_procjudtrab_id:
s2399_procjudtrab = get_object_or_404(
s2399procJudTrab.objects.using(db_slug),
excluido=False,
id=s2399_procjudtrab_id)
dict_permissoes = json_to_dict(usuario.config_perfis.permissoes)
paginas_permitidas_lista = usuario.config_perfis.paginas_permitidas
modulos_permitidos_lista = usuario.config_perfis.modulos_permitidos
dados_evento = {}
dados_evento['status'] = 0
if s2399_procjudtrab_id:
dados_evento = s2399_procjudtrab.evento()
if dados_evento['status'] != 0:
dict_permissoes['s2399_procjudtrab_apagar'] = 0
dict_permissoes['s2399_procjudtrab_editar'] = 0
if permissao.permite_visualizar:
mensagem = None
if s2399_procjudtrab_id:
s2399_procjudtrab_form = form_s2399_procjudtrab(
request.POST or None, instance=s2399_procjudtrab, slug=db_slug)
else:
s2399_procjudtrab_form = form_s2399_procjudtrab(request.POST
or None,
slug=db_slug,
initial={})
if request.method == 'POST':
if s2399_procjudtrab_form.is_valid():
dados = s2399_procjudtrab_form.cleaned_data
import json
from django.forms.models import model_to_dict
if s2399_procjudtrab_id:
if dados_evento['status'] == 0:
dados['modificado_por_id'] = usuario_id
dados['modificado_em'] = datetime.datetime.now()
#s2399_procjudtrab_campos_multiple_passo1
s2399procJudTrab.objects.using(db_slug).filter(
id=s2399_procjudtrab_id).update(**dados)
obj = s2399procJudTrab.objects.using(db_slug).get(
id=s2399_procjudtrab_id)
#s2399_procjudtrab_editar_custom
#s2399_procjudtrab_campos_multiple_passo2
messages.success(request, 'Alterado com sucesso!')
gravar_auditoria(
json.dumps(model_to_dict(s2399_procjudtrab),
indent=4,
sort_keys=True,
default=str),
json.dumps(model_to_dict(obj),
indent=4,
sort_keys=True,
default=str), 's2399_procjudtrab',
s2399_procjudtrab_id, usuario_id, 2)
else:
messages.error(
request,
'Somente é possível alterar eventos com status "Cadastrado"!'
)
else:
dados['criado_por_id'] = usuario_id
dados['criado_em'] = datetime.datetime.now()
dados['excluido'] = False
#s2399_procjudtrab_cadastrar_campos_multiple_passo1
obj = s2399procJudTrab(**dados)
obj.save(using=db_slug)
#s2399_procjudtrab_cadastrar_custom
#s2399_procjudtrab_cadastrar_campos_multiple_passo2
messages.success(request, 'Cadastrado com sucesso!')
gravar_auditoria(
'{}',
json.dumps(model_to_dict(obj),
indent=4,
sort_keys=True,
default=str), 's2399_procjudtrab', obj.id,
usuario_id, 1)
if request.session['retorno_pagina'] not in (
's2399_procjudtrab_apagar',
's2399_procjudtrab_salvar', 's2399_procjudtrab'):
return redirect(request.session['retorno_pagina'],
hash=request.session['retorno_hash'])
if s2399_procjudtrab_id != obj.id:
url_hash = base64.urlsafe_b64encode(
'{"print": "0", "id": "%s"}' % (obj.id))
return redirect('s2399_procjudtrab_salvar',
hash=url_hash)
else:
messages.error(request, 'Erro ao salvar!')
s2399_procjudtrab_form = disabled_form_fields(s2399_procjudtrab_form,
permissao.permite_editar)
if s2399_procjudtrab_id:
if dados_evento['status'] != 0:
s2399_procjudtrab_form = disabled_form_fields(
s2399_procjudtrab_form, 0)
#s2399_procjudtrab_campos_multiple_passo3
for field in s2399_procjudtrab_form.fields.keys():
s2399_procjudtrab_form.fields[field].widget.attrs[
'ng-model'] = 's2399_procjudtrab_' + field
if int(dict_hash['print']):
s2399_procjudtrab_form = disabled_form_for_print(
s2399_procjudtrab_form)
#[VARIAVEIS_SECUNDARIAS_VAZIAS]
if s2399_procjudtrab_id:
s2399_procjudtrab = get_object_or_404(
s2399procJudTrab.objects.using(db_slug),
excluido=False,
id=s2399_procjudtrab_id)
pass
else:
s2399_procjudtrab = None
#s2399_procjudtrab_salvar_custom_variaveis#
tabelas_secundarias = []
#[FUNCOES_ESPECIAIS_SALVAR]
if dict_hash['tab'] or 's2399_procjudtrab' in request.session[
'retorno_pagina']:
request.session["retorno_hash"] = hash
request.session["retorno_pagina"] = 's2399_procjudtrab_salvar'
controle_alteracoes = Auditoria.objects.using(db_slug).filter(
identidade=s2399_procjudtrab_id, tabela='s2399_procjudtrab').all()
context = {
'ocorrencias': dados_evento['ocorrencias'],
'validacao_precedencia': dados_evento['validacao_precedencia'],
'validacoes': dados_evento['validacoes'],
'status': dados_evento['status'],
'controle_alteracoes': controle_alteracoes,
's2399_procjudtrab': s2399_procjudtrab,
's2399_procjudtrab_form': s2399_procjudtrab_form,
'mensagem': mensagem,
's2399_procjudtrab_id': int(s2399_procjudtrab_id),
'usuario': usuario,
'hash': hash,
#[VARIAVEIS_SECUNDARIAS]
'modulos_permitidos_lista': modulos_permitidos_lista,
'paginas_permitidas_lista': paginas_permitidas_lista,
'permissao': permissao,
'data': datetime.datetime.now(),
'pagina': pagina,
'dict_permissoes': dict_permissoes,
'for_print': int(dict_hash['print']),
'tabelas_secundarias': tabelas_secundarias,
'tab': dict_hash['tab'],
#s2399_procjudtrab_salvar_custom_variaveis_context#
}
if for_print in (0, 1):
return render(request, 's2399_procjudtrab_salvar.html', context)
elif for_print == 2:
from wkhtmltopdf.views import PDFTemplateResponse
response = PDFTemplateResponse(
request=request,
template='s2399_procjudtrab_salvar.html',
filename="s2399_procjudtrab.pdf",
context=context,
show_content_in_browser=True,
cmd_options={
'margin-top': 10,
'margin-bottom': 10,
'margin-right': 10,
'margin-left': 10,
'zoom': 1,
'dpi': 72,
'orientation': 'Landscape',
"viewport-size": "1366 x 513",
'javascript-delay': 1000,
'footer-center': '[page]/[topage]',
"no-stop-slow-scripts": True
},
)
return response
elif for_print == 3:
from django.shortcuts import render_to_response
response = render_to_response('s2399_procjudtrab_salvar.html',
context)
filename = "s2399_procjudtrab.xls"
response[
'Content-Disposition'] = 'attachment; filename=' + filename
response[
'Content-Type'] = 'application/vnd.ms-excel; charset=UTF-8'
return response
else:
context = {
'usuario': usuario,
'modulos_permitidos_lista': modulos_permitidos_lista,
'paginas_permitidas_lista': paginas_permitidas_lista,
'permissao': permissao,
'data': datetime.datetime.now(),
'pagina': pagina,
'dict_permissoes': dict_permissoes,
}
return render(request, 'permissao_negada.html', context)
def post(self, request, *args, **kwargs):
label = self.get_object()
label.delete()
messages.success(request, _("%s has been deleted.") % label)
return HttpResponseRedirect(reverse_lazy("shuup_admin:label.list"))
def apagar(request, hash):
db_slug = 'default'
try:
usuario_id = request.user.id
dict_hash = get_hash_url(hash)
s2399_procjudtrab_id = int(dict_hash['id'])
for_print = int(dict_hash['print'])
except:
usuario_id = False
return redirect('login')
usuario = get_object_or_404(Usuarios.objects.using(db_slug),
excluido=False,
id=usuario_id)
pagina = ConfigPaginas.objects.using(db_slug).get(
excluido=False, endereco='s2399_procjudtrab')
permissao = ConfigPermissoes.objects.using(db_slug).get(
excluido=False,
config_paginas=pagina,
config_perfis=usuario.config_perfis)
dict_permissoes = json_to_dict(usuario.config_perfis.permissoes)
paginas_permitidas_lista = usuario.config_perfis.paginas_permitidas
modulos_permitidos_lista = usuario.config_perfis.modulos_permitidos
s2399_procjudtrab = get_object_or_404(
s2399procJudTrab.objects.using(db_slug),
excluido=False,
id=s2399_procjudtrab_id)
dados_evento = {}
if s2399_procjudtrab_id:
dados_evento = s2399_procjudtrab.evento()
if dados_evento['status'] != 0:
dict_permissoes['s2399_procjudtrab_apagar'] = 0
dict_permissoes['s2399_procjudtrab_editar'] = 0
if request.method == 'POST':
if dados_evento['status'] == 0:
import json
from django.forms.models import model_to_dict
situacao_anterior = json.dumps(model_to_dict(s2399_procjudtrab),
indent=4,
sort_keys=True,
default=str)
s2399procJudTrab.objects.using(db_slug).filter(
id=s2399_procjudtrab_id).delete()
#s2399_procjudtrab_apagar_custom
#s2399_procjudtrab_apagar_custom
messages.success(request, 'Apagado com sucesso!')
gravar_auditoria(situacao_anterior, '', 's2399_procjudtrab',
s2399_procjudtrab_id, usuario_id, 3)
else:
messages.error(
request,
'Não foi possivel apagar o evento, somente é possível apagar os eventos com status "Cadastrado"!'
)
if request.session['retorno_pagina'] == 's2399_procjudtrab_salvar':
return redirect('s2399_procjudtrab',
hash=request.session['retorno_hash'])
else:
return redirect(request.session['retorno_pagina'],
hash=request.session['retorno_hash'])
context = {
'usuario': usuario,
'modulos_permitidos_lista': modulos_permitidos_lista,
'paginas_permitidas_lista': paginas_permitidas_lista,
'permissao': permissao,
'data': datetime.datetime.now(),
'pagina': pagina,
'dict_permissoes': dict_permissoes,
'hash': hash,
}
return render(request, 's2399_procjudtrab_apagar.html', context)
def form_valid(self, form):
form.instance.event = self.request.event
messages.success(self.request, _('The new quota has been created.'))
ret = super().form_valid(form)
form.instance.log_action('pretix.event.quota.added', user=self.request.user, data=dict(form.cleaned_data))
return ret
def delete(self, *args, **kwargs):
messages.success(self.request, 'Post Deleted')
return super().delete(*args, **kwargs)
def form_valid(self, form):
form.save()
messages.success(self.request, phrases.cfp.invite_sent)
self.get_object().log_action('pretalx.submission.speakers.invite',
person=self.request.user)
return super().form_valid(form)
def post(self, *args, **kwargs):
order = Order.objects.get(user=self.request.user, ordered=False)
token = self.request.POST.get('stripeToken')
amount = int(order.get_cart_total())
try:
# Use Stripe's library to make requests...
charge = stripe.Charge.create(
amount=amount*100,
currency="inr",
source=token,
)
# create payment
payment = Payment()
payment.stripe_charge_id = charge['id']
payment.user = self.request.user
payment.amount = order.get_cart_total()
payment.save()
order_item = order.items.all()
order_item.update(ordered=True)
for item in order_item:
item.save()
# assign the payment to the order
order.ordered = True
order.payment = payment
order.ref_code = create_ref_code()
order.save()
messages.success(self.request, "Your order was successfully placed...")
return redirect("/")
except stripe.error.CardError as e:
messages.warning(self.request, f"{ e.error.message }")
return redirect("/")
except stripe.error.RateLimitError as e:
# Too many requests made to the API too quickly
messages.warning(self.request, 'Rate Limit Error')
return redirect("/")
except stripe.error.InvalidRequestError as e:
# Invalid parameters were supplied to Stripe's API
messages.warning(self.request, 'Invalid parameters')
return redirect("/")
except stripe.error.AuthenticationError as e:
# Authentication with Stripe's API failed
# (maybe you changed API keys recently)
messages.warning(self.request, 'Not Authenticated')
return redirect("/")
except stripe.error.APIConnectionError as e:
# Network communication with Stripe failed
messages.warning(self.request, 'Network error')
return redirect("/")
except stripe.error.StripeError as e:
# Display a very generic error to the user, and maybe send
# yourself an email
messages.warning(self.request, 'Something went wrong. You were not charged. Try Again!!')
return redirect("/")
except Exception as e:
# send an emaill to ourselves
messages.warning(self.request, 'A serious occured. We are notified and working on it.')
return redirect("/")
def user_add(request):
"""Add a user"""
if not request.user.is_staff or request.method != 'POST':
raise Http404
content_type = 'application/json; charset=utf-8'
post_values = request.POST.copy()
post_email = request.POST.get('email', '')
post_role = request.POST.get('role', DEFAULT_USER)
post_values.update({
'email': post_email.lower(),
'role': post_role,
})
form = AddUserForm(post_values)
if form.is_valid():
email = form.cleaned_data['email']
name = form.cleaned_data['name']
department = form.cleaned_data['department']
role = form.cleaned_data['role']
password = form.cleaned_data['password1']
try:
user = User.objects.create_user(email, password, is_staff=False,
is_active=True)
except User.DoesNotExist as e:
logger.error(e)
err_msg = _('Fail to add user %s.') % email
return HttpResponse(json.dumps({'error': err_msg}), status=403, content_type=content_type)
# send admin operation log signal
admin_op_detail = {
"email": email,
}
admin_operation.send(sender=None, admin_name=request.user.username,
operation=USER_ADD, detail=admin_op_detail)
if user:
User.objects.update_role(email, role)
if config.FORCE_PASSWORD_CHANGE:
UserOptions.objects.set_force_passwd_change(email)
if name:
Profile.objects.add_or_update(email, name, '')
if department:
DetailedProfile.objects.add_or_update(email, department, '')
if request.user.org:
org_id = request.user.org.org_id
ccnet_threaded_rpc.add_org_user(org_id, email, 0)
if IS_EMAIL_CONFIGURED:
try:
send_user_add_mail(request, email, password)
messages.success(request, _('Successfully added user %s. An email notification has been sent.') % email)
except Exception as e:
logger.error(str(e))
messages.success(request, _('Successfully added user %s. An error accurs when sending email notification, please check your email configuration.') % email)
else:
messages.success(request, _('Successfully added user %s.') % email)
return HttpResponse(json.dumps({'success': True}), content_type=content_type)
else:
if IS_EMAIL_CONFIGURED:
if SEND_EMAIL_ON_ADDING_SYSTEM_MEMBER:
try:
send_user_add_mail(request, email, password)
messages.success(request, _('Successfully added user %s. An email notification has been sent.') % email)
except Exception as e:
logger.error(str(e))
messages.success(request, _('Successfully added user %s. An error accurs when sending email notification, please check your email configuration.') % email)
else:
messages.success(request, _('Successfully added user %s.') % email)
else:
messages.success(request, _('Successfully added user %s. But email notification can not be sent, because Email service is not properly configured.') % email)
return HttpResponse(json.dumps({'success': True}), content_type=content_type)
else:
return HttpResponse(json.dumps({'error': str(list(form.errors.values())[0])}), status=400, content_type=content_type)
def redirect_to_invest(request, status_of_message,message=''):
if status_of_message:
messages.success(request,message)
else:
messages.warning(request, message)
return HttpResponseRedirect(reverse('office:invest'))
def logout(request):
''' log the user out '''
auth.logout(request)
messages.success(request, "You Have Successfully Logged Out!")
return redirect(reverse('index'))
def salvar(request, pk=None, tab='master', output=None):
from emensageriapro.esocial.models import STATUS_EVENTO_CADASTRADO
from emensageriapro.settings import VERSAO_EMENSAGERIA, VERSAO_LAYOUT_ESOCIAL
TP_AMB = config.ESOCIAL_TP_AMB
if pk:
s2241_evtinsapo = get_object_or_404(s2241evtInsApo, id=pk)
if request.user.has_perm('esocial.can_see_s2241evtInsApo'):
if pk:
s2241_evtinsapo_form = form_s2241_evtinsapo(
request.POST or None,
instance=s2241_evtinsapo,
initial={'ativo': True})
else:
s2241_evtinsapo_form = form_s2241_evtinsapo(
request.POST or None,
initial={
'versao': VERSAO_LAYOUT_ESOCIAL,
'status': STATUS_EVENTO_CADASTRADO,
'tpamb': TP_AMB,
'procemi': 1,
'verproc': VERSAO_EMENSAGERIA,
'ativo': True
})
if request.method == 'POST':
if s2241_evtinsapo_form.is_valid():
obj = s2241_evtinsapo_form.save(request=request)
messages.success(request, u'Salvo com sucesso!')
if not pk:
from emensageriapro.functions import identidade_evento
identidade_evento(obj, 'esocial')
if 'return_page' in request.session and request.session[
'return_page'] and 's2241-evtinsapo' not in request.session[
'return_page']:
return HttpResponseRedirect(request.session['return_page'])
if pk != obj.id:
return redirect('s2241_evtinsapo_salvar', pk=obj.id)
else:
messages.error(request, u'Erro ao salvar!')
s2241_evtinsapo_form = disabled_form_fields(
s2241_evtinsapo_form,
request.user.has_perm('esocial.change_s2241evtInsApo'))
if pk:
if s2241_evtinsapo.status != 0:
s2241_evtinsapo_form = disabled_form_fields(
s2241_evtinsapo_form, False)
for field in s2241_evtinsapo_form.fields.keys():
s2241_evtinsapo_form.fields[field].widget.attrs[
'ng-model'] = 's2241_evtinsapo_' + field
if output:
s2241_evtinsapo_form = disabled_form_for_print(
s2241_evtinsapo_form)
s2241_insalperic_lista = None
s2241_insalperic_form = None
s2241_aposentesp_lista = None
s2241_aposentesp_form = None
if pk:
s2241_evtinsapo = get_object_or_404(s2241evtInsApo, id=pk)
s2241_insalperic_form = form_s2241_insalperic(
initial={'s2241_evtinsapo': s2241_evtinsapo})
s2241_insalperic_form.fields['s2241_evtinsapo'].widget.attrs[
'readonly'] = True
s2241_insalperic_lista = s2241insalPeric.objects.\
filter(s2241_evtinsapo_id=s2241_evtinsapo.id).all()
s2241_aposentesp_form = form_s2241_aposentesp(
initial={'s2241_evtinsapo': s2241_evtinsapo})
s2241_aposentesp_form.fields['s2241_evtinsapo'].widget.attrs[
'readonly'] = True
s2241_aposentesp_lista = s2241aposentEsp.objects.\
filter(s2241_evtinsapo_id=s2241_evtinsapo.id).all()
else:
s2241_evtinsapo = None
tabelas_secundarias = []
controle_alteracoes = Auditoria.objects.filter(
identidade=pk, tabela='s2241_evtinsapo').all()
if not request.POST:
request.session['return_page'] = request.META.get('HTTP_REFERER')
context = {
'usuario': Usuarios.objects.get(user_id=request.user.id),
'pk': pk,
'output': output,
'evento_totalizador': False,
'controle_alteracoes': controle_alteracoes,
's2241_evtinsapo': s2241_evtinsapo,
's2241_evtinsapo_form': s2241_evtinsapo_form,
's2241_insalperic_form': s2241_insalperic_form,
's2241_insalperic_lista': s2241_insalperic_lista,
's2241_aposentesp_form': s2241_aposentesp_form,
's2241_aposentesp_lista': s2241_aposentesp_lista,
'data': datetime.datetime.now(),
'modulos': [
'esocial',
],
'paginas': [
's2241_evtinsapo',
],
'tabelas_secundarias': tabelas_secundarias,
'tab': tab,
}
if output == 'pdf':
response = PDFTemplateResponse(
request=request,
template='s2241_evtinsapo_salvar.html',
filename="s2241_evtinsapo.pdf",
context=context,
show_content_in_browser=True,
cmd_options={
'margin-top': 10,
'margin-bottom': 10,
'margin-right': 10,
'margin-left': 10,
'zoom': 1,
'dpi': 72,
'orientation': 'Landscape',
"viewport-size": "1366 x 513",
'javascript-delay': 1000,
'footer-center': '[page]/[topage]',
"no-stop-slow-scripts": True
},
)
return response
elif output == 'xls':
response = render_to_response('s2241_evtinsapo_salvar.html',
context)
filename = "s2241_evtinsapo.xls"
response[
'Content-Disposition'] = 'attachment; filename=' + filename
response[
'Content-Type'] = 'application/vnd.ms-excel; charset=UTF-8'
return response
else:
return render(request, 's2241_evtinsapo_salvar.html', context)
else:
context = {
'usuario': Usuarios.objects.get(user_id=request.user.id),
'pk': pk,
'tab': tab,
'output': output,
'modulos': [
'esocial',
],
'paginas': [
's2241_evtinsapo',
],
'data': datetime.datetime.now(),
}
return render(request, 'permissao_negada.html', context)
def receive(request, key, txid, network):
"""Handle the receiving of a kudos (the POST).
Returns:
TemplateResponse: the UI with the kudos confirmed
"""
these_kudos_emails = KudosTransfer.objects.filter(web3_type='v3', txid=txid, network=network)
kudos_emails = these_kudos_emails.filter(metadata__reference_hash_for_receipient=key) | these_kudos_emails.filter(
metadata__reference_hash_for_funder=key)
kudos_transfer = kudos_emails.first()
is_authed = kudos_transfer.trust_url or request.user.username.replace('@', '') in [
kudos_transfer.username.replace('@', ''),
kudos_transfer.from_username.replace('@', '')
]
not_mined_yet = get_web3(kudos_transfer.network).eth.getBalance(
Web3.toChecksumAddress(kudos_transfer.metadata['address'])) == 0
if not kudos_transfer.trust_url:
if not request.user.is_authenticated or request.user.is_authenticated and not getattr(
request.user, 'profile', None
):
login_redirect = redirect('/login/github?next=' + request.get_full_path())
return login_redirect
if kudos_transfer.receive_txid:
messages.info(request, _('This kudos has been received'))
elif not is_authed:
messages.error(
request, f'This kudos is for {kudos_transfer.username} but you are logged in as {request.user.username}. Please logout and log back in as {kudos_transfer.username}.')
elif not_mined_yet and not request.GET.get('receive_txid'):
message = mark_safe(
f'The <a href="https://etherscan.io/tx/{txid}">transaction</a> is still mining. '
'Please wait a moment before submitting the receive form.'
)
messages.info(request, message)
elif request.GET.get('receive_txid') and not kudos_transfer.receive_txid:
params = request.GET
# db mutations
try:
if params['save_addr']:
profile = get_profile(kudos_transfer.username)
if profile:
# TODO: Does this mean that the address the user enters in the receive form
# Will overwrite an already existing preferred_payout_address? Should we
# ask the user to confirm this?
profile.preferred_payout_address = params['forwarding_address']
profile.save()
kudos_transfer.receive_txid = params['receive_txid']
kudos_transfer.receive_address = params['forwarding_address']
kudos_transfer.received_on = timezone.now()
kudos_transfer.save()
record_user_action(kudos_transfer.from_username, 'receive_kudos', kudos_transfer)
record_kudos_email_activity(kudos_transfer, kudos_transfer.username, 'receive_kudos')
messages.success(request, _('This kudos has been received'))
except Exception as e:
messages.error(request, str(e))
logger.exception(e)
params = {
'issueURL': request.GET.get('source'),
'class': 'receive',
'gas_price': round(recommend_min_gas_price_to_confirm_in_time(120), 1),
'kudos_transfer': kudos_transfer,
'title': f"Receive {kudos_transfer.kudos_token_cloned_from.humanized_name} Kudos" if kudos_transfer and kudos_transfer.kudos_token_cloned_from else _('Receive Kudos'),
'avatar_url': kudos_transfer.kudos_token_cloned_from.img_url if kudos_transfer and kudos_transfer.kudos_token_cloned_from else None,
'card_desc': f"You've received a {kudos_transfer.kudos_token_cloned_from.humanized_name} kudos!" if kudos_transfer and kudos_transfer.kudos_token_cloned_from else _('You\'ve received a kudos'),
'key': key,
'is_authed': is_authed,
'disable_inputs': kudos_transfer.receive_txid or not_mined_yet or not is_authed,
}
return TemplateResponse(request, 'transaction/receive.html', params)
def get_success_url(self):
messages.success(self.request, 'Profile successfully updated.')
return reverse_lazy('userprofile', kwargs={'username': self.request.user})
def logout(request):
if request.method == "POST":
auth.logout(request)
messages.success(request, "You are log out")
return redirect('/')
def logout(request):
if request.method == 'POST':
auth.logout(request)
messages.success(request,"You are successfully logged out")
return redirect('login')
def logout(request):
auth.logout(request)
messages.success(request, 'You are logged out.')
return redirect('login')
def posts_delete(request, id=None): #As delete
instance = get_object_or_404(Post, id=id)
instance.delete()
messages.success(request, "post deleted")
return redirect("posts:list")
def form_valid(self, form):
messages.success(self.request, 'Interests updated with success!')
return super().form_valid(form)
def login(request):
if request.method == 'POST':
email = request.POST['email']
password = request.POST['password']
user = auth.authenticate(email=email, password=password)
if user is not None:
try:
cart = Cart.objects.get(cart_id=_cart_id(request))
is_cart_item_exists = CartItem.objects.filter(cart=cart).exists()
if is_cart_item_exists:
cart_item = CartItem.objects.filter(cart=cart)
# Getting the product variations by cart id
product_variation = []
for item in cart_item:
variation = item.variations.all()
product_variation.append(list(variation))
# Get the cart items from the user to access his product variations
cart_item = CartItem.objects.filter(user=user)
ex_var_list = []
id = []
for item in cart_item:
existing_variation = item.variations.all()
ex_var_list.append(list(existing_variation))
id.append(item.id)
# product_variation = [1, 2, 3, 4, 6]
# ex_var_list = [4, 6, 3, 5]
for pr in product_variation:
if pr in ex_var_list:
index = ex_var_list.index(pr)
item_id = id[index]
item = CartItem.objects.get(id=item_id)
item.quantity += 1
item.user = user
item.save()
else:
cart_item = CartItem.objects.filter(cart=cart)
for item in cart_item:
item.user = user
item.save()
except:
pass
auth.login(request, user)
messages.success(request, 'You are now logged in.')
url = request.META.get('HTTP_REFERER')
try:
query = requests.utils.urlparse(url).query
# next=/cart/checkout/
params = dict(x.split('=') for x in query.split('&'))
if 'next' in params:
nextPage = params['next']
return redirect(nextPage)
except:
return redirect('dashboard')
else:
messages.error(request, 'Invalid login credentials')
return redirect('login')
return render(request, 'accounts/login.html')
def view_results(request, pk):
quiz = get_object_or_404(Quiz, pk=pk)
student = request.user.student
user = request.user
answered_questions_lev = student.quiz_answers \
.filter(answer__question__quiz=quiz) \
.values_list('answer__question__level', flat=True)
correct_question_lev = list(
student.quiz_answers.filter(answer__question__quiz=quiz,
answer__is_correct=True).values_list(
'answer__question__level', flat=True))
answer_questions_lev = list(student.quiz_answers \
.filter(answer__question__quiz=quiz) \
.values_list('answer__question__level', flat=True))
answerss = list(
student.quiz_answers.filter(answer__question__quiz=quiz).values_list(
'answer__id', flat=True))
correct_answers = list(
student.quiz_answers.filter(answer__question__quiz=quiz,
answer__is_correct=True).values_list(
'answer__id', flat=True))
answered_questions = student.quiz_answers.filter(
answer__question__quiz=quiz).values_list('answer__question__text',
flat=True)
correct_ques = student.quiz_answers.filter(
answer__question__quiz=quiz,
answer__is_correct=True).values_list('answer__question__text',
flat=True)
answers = student.quiz_answers.filter(
answer__question__quiz=quiz).values_list('answer__text', flat=True)
score = 0
for i in correct_question_lev:
if i == 1:
score = score + 1
if i == 2:
score = score + 2
if i == 3:
score = score + 3
if i == 4:
score = score + 6
if i == 5:
score = score + 9
total_score = 0
for i in answer_questions_lev:
if i == 1:
total_score = total_score + 1
if i == 2:
total_score = total_score + 2
if i == 3:
total_score = total_score + 3
if i == 4:
total_score = total_score + 6
if i == 5:
total_score = total_score + 9
print(answerss)
print(correct_answers)
check = list(set(answerss).intersection(correct_answers))
print(check)
Marks = []
marks_graph = []
for x, y in zip(answerss, answer_questions_lev):
if x in check:
if y == 1:
Marks.append('+1')
elif y == 2:
Marks.append('+2')
elif y == 3:
Marks.append('+3')
elif y == 4:
Marks.append('+6')
elif y == 5:
Marks.append('+9')
elif x not in check:
Marks.append('+0')
fname = user.first_name
lname = user.last_name
username = user.username
quiz = quiz.name
print(quiz)
total_ques = len(answers)
percentage = round((score / total_score * 100), 2)
print(Marks)
if percentage <= 32.0:
messages.warning(
request, 'Your obtained marks in %s was %s out of %s marks.' %
(quiz, score, total_score))
elif percentage <= 60 and percentage > 32:
messages.success(
request,
'You completed the quiz %s with second division! You obtained marks was %s out of %s marks.'
% (quiz, score, total_score))
elif percentage <= 80 and percentage > 60:
messages.success(
request,
'You completed the quiz %s with first division! You obtained marks was %s out of %s marks.'
% (quiz, score, total_score))
elif percentage > 80:
messages.success(
request,
'You completed the quiz %s with distinction! You obtained marks was %s out of %s marks.'
% (quiz, score, total_score))
zippedList = zip(answered_questions, answer_questions_lev, answers, Marks)
return render(
request, 'classroom/students/results.html', {
'zippedList': zippedList,
'pk': pk,
'score': score,
'total_score': total_score,
'percentage': percentage,
'fname': fname,
'lname': lname,
'username': username,
'quiz': quiz,
'total_ques': total_ques,
})
def activate_account(request, key):
"""
When link in activation e-mail is clicked
"""
# If request is in Studio call the appropriate view
if theming_helpers.get_project_root_name().lower() == u'cms':
monitoring_utils.set_custom_attribute('student_activate_account',
'cms')
return activate_account_studio(request, key)
# TODO: Use custom attribute to determine if there are any `activate_account` calls for cms in Production.
# If not, the templates wouldn't be needed for cms, but we still need a way to activate for cms tests.
monitoring_utils.set_custom_attribute('student_activate_account', 'lms')
activation_message_type = None
try:
registration = Registration.objects.get(activation_key=key)
except (Registration.DoesNotExist, Registration.MultipleObjectsReturned):
activation_message_type = 'error'
messages.error(
request,
HTML(
_('{html_start}Your account could not be activated{html_end}'
'Something went wrong, please <a href="{support_url}">contact support</a> to resolve this issue.'
)).format(
support_url=configuration_helpers.get_value(
'ACTIVATION_EMAIL_SUPPORT_LINK',
settings.ACTIVATION_EMAIL_SUPPORT_LINK)
or settings.SUPPORT_SITE_LINK,
html_start=HTML('<p class="message-title">'),
html_end=HTML('</p>'),
),
extra_tags='account-activation aa-icon')
else:
if registration.user.is_active:
activation_message_type = 'info'
messages.info(
request,
HTML(
_('{html_start}This account has already been activated.{html_end}'
)).format(
html_start=HTML('<p class="message-title">'),
html_end=HTML('</p>'),
),
extra_tags='account-activation aa-icon',
)
else:
registration.activate()
# Success message for logged in users.
message = _(
'{html_start}Success{html_end} You have activated your account.'
)
if not request.user.is_authenticated:
# Success message for logged out users
message = _(
'{html_start}Success! You have activated your account.{html_end}'
'You will now receive email updates and alerts from us related to'
' the courses you are enrolled in. Sign In to continue.')
# Add message for later use.
activation_message_type = 'success'
messages.success(
request,
HTML(message).format(
html_start=HTML('<p class="message-title">'),
html_end=HTML('</p>'),
),
extra_tags='account-activation aa-icon',
)
if should_redirect_to_authn_microfrontend(
) and not request.user.is_authenticated:
url_path = '/login?account_activation_status={}'.format(
activation_message_type)
return redirect(settings.AUTHN_MICROFRONTEND_URL + url_path)
return redirect('dashboard')
def form_valid(self, form):
"""If the form is valid, redirect to the supplied URL."""
if 'uidb64' in self.kwargs and 'token' in self.kwargs:
uidb64 = self.kwargs['uidb64']
token = self.kwargs['token']
uid = force_text(urlsafe_base64_decode(uidb64))
try:
user = PyUser.objects.get(pk=uid)
except (TypeError, ValueError, OverflowError, PyUser.DoesNotExist):
user = None
token_valid = PASSWORD_RECOVERY_TOKEN.check_token(user, token)
if user is not None and token_valid and uid != 1:
user.set_password(form.cleaned_data['password1'])
user.is_active = True
user.save()
messages.success(
self.request,
_('Welcome back, your password has been successfully modified. Please log in using your credentials.'
))
else:
messages.error(
self.request,
_('The password recovery link is invalid or has already been used.'
))
return HttpResponseRedirect(reverse_lazy(self.get_success_url()))
else:
email = form.cleaned_data['email']
try:
user = PyUser.objects.get(email=email)
except (TypeError, ValueError, OverflowError, PyUser.DoesNotExist):
user = None
if user is not None:
current_site = get_current_site(self.request)
subject = _('%(app_name)s password recovery') % {
'app_name': settings.APP_NAME
}
url = reverse_lazy('PyUser:password-set',
kwargs={
'uidb64':
urlsafe_base64_encode(
force_bytes(user.pk)),
'token':
PASSWORD_RECOVERY_TOKEN.make_token(user)
})
message_body = _(
'You received this email because you requested that your password be reset to "%(app_name)s".\n\nPlease go to the following link to recover your password:\n\nhttp://%(domain)s%(url)s\n\nThe credentials of this link last for one (1) day.\n\nBest regards.\n\nThe %(app_name)s team.'
) % {
'app_name': settings.APP_NAME,
'user': user.email,
'domain': current_site.domain,
'url': url
}
message_body = message_body.replace(" ", "")
user.email_user(subject, message_body)
messages.success(
self.request,
_('Instructions to recover your password in %(app_name)s were sent to the email account %(email)s'
) % {
'app_name': settings.APP_NAME,
'email': email
})
return HttpResponseRedirect(
reverse_lazy(self.get_success_url()))
else:
messages.error(
self.request,
_('The email provided is not registered in %(app_name)s') %
{'app_name': settings.APP_NAME})
return HttpResponseRedirect(
reverse_lazy('PyUser:password-recovery'))
def form_valid(self, form):
user = form.save()
messages.success(
self.request,
'Contact your teacher to activate your account before logging in')
return redirect('login')
