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')