def put(self, request, uuid): try: data = request.data data = self.parse_data(data) facility = Locality.objects.get(uuid=uuid) try: facility.update_data(data, request.user) return Response('OK') except KeyError as e: return HttpResponseBadRequest('%s is required' % e) except ValueError as e: return HttpResponseBadRequest('%s' % e) except TypeError as e: return HttpResponseBadRequest('%s' % e) except Locality.DoesNotExist: raise Http404()
def post(self, request, *args, **kwargs): if request.version != 'v5': raise Http404() file_name = None file_content = None # Check whether AJAX or a standard encoded form was used if request.is_ajax(): # File name must be provided by an HTTP header if 'HTTP_X_FILE_NAME' not in request.META: return Response('Missing HTTP header for file name.', status=status.HTTP_400_BAD_REQUEST) file_name = request.META['HTTP_X_FILE_NAME'] file_content = request else: # File content must be already processed by the request if len(request.data) != 1: return Response('Missing embedded file content.', status=status.HTTP_400_BAD_REQUEST) file_handle = request.data.values()[0] file_name = file_handle.name file_content = file_handle # Make sure the file type is supported if not file_name or not file_content: return Response('Missing file attachment.', status=status.HTTP_400_BAD_REQUEST) if os.path.splitext(file_name)[1] not in ['.json']: return Response('Unsupported file type.', status=status.HTTP_400_BAD_REQUEST) # Attempt to parse the file content # TODO: Add buffer overflow protection import_dict = json.loads(file_content.read()) # Attempt to apply the configuration try: warnings = importer.import_config(import_dict) except InvalidConfiguration as ex: logger.exception('Unable to import configuration.') raise BadParameter(unicode(ex)) results = [{'id': w.key, 'details': w.details} for w in warnings] return Response({'warnings': results})
def __workflowObject(request): _site_url = get_site_url_id(request) _p = PortalCatalog.objects.filter(site__url=_site_url) _url = reescrever_url(request) _workflow = request.GET['workflow_action'] if _workflow in WORKFLOW_ACTION: _p = _p.get(path_url=_url) if _p.tipo == 'ATPagina': paginas.workflow(request, _p, WORKFLOW[_workflow]) if _p.tipo == 'ATLink': links.workflow(request, _p, WORKFLOW[_workflow]) if _p.tipo == 'ATImagem': imagens.workflow(request, _p, WORKFLOW[_workflow]) if _p.tipo == 'ATPasta': pastas.workflow(request, _p, WORKFLOW[_workflow]) if _p.tipo == 'ATBanner': banners.workflow(request, _p, WORKFLOW[_workflow]) if _p.tipo == 'ATNoticia': noticias.workflow(request, _p, WORKFLOW[_workflow]) if _p.tipo == 'ATArquivo': arquivos.workflow(request, _p, WORKFLOW[_workflow]) if _p.tipo == 'ATEvento': eventos.workflow(request, _p, WORKFLOW[_workflow]) if _p.tipo == 'ATAgenda': agendas.workflow(request, _p, WORKFLOW[_workflow]) if _p.tipo == 'ATInforme': informes.workflow(request, _p, WORKFLOW[_workflow]) if _p.tipo == 'ATServico': servicos.workflow(request, _p, WORKFLOW[_workflow]) else: raise Http404('Operação não permitida.') return redirect(_url)
def apply(request, jid): if request.method == "POST": form = Application_form(request.POST) job = Job.objects.get(id=jid) seekerProfile = SeekerProfile.objects.get(seeker=request.user) if form.is_valid(): cv = form.cleaned_data['cv'] cover_letter = form.cleaned_data['cover_letter'] score = macthing_score(request, job, seekerProfile) application_id = Application.objects.create( cv=cv, cover_letter=cover_letter, status='A', seeker=seekerProfile, matching_score=score, job=job, seeker_name=seekerProfile.first_name) application_id.save() job_application = Application.objects.get(id=application_id.id) Message.objects.create( application=job_application, recruiter=job.recruiter, seeker=seekerProfile, message_type='A', ).save() messages.success(request, "You have sucessfully applied for this position") args = {'form': form, 'job': job} return render(request, 'ojss_app/job_details.html', args) else: messages.warning( request, "Your application form had errors in it. Please re submit application" ) args = {'form': form, 'job': job, 'status': "T"} return render(request, 'ojss_app/job_details.html', args) else: raise Http404("This is an invalid request")
def detail(request, tracker_id): # Count of applications(similar to getting count of one report per application) reports_number = Application.objects.distinct('handle').count() try: tracker = Tracker.objects.get(pk=tracker_id) # Add spaces aroung pipes for better rendering of signatures tracker.network_signature = tracker.network_signature.replace("|", " | ") tracker.code_signature = tracker.code_signature.replace("|", " | ") # Returns reports in reverse chronological order app_tuples = Application.objects.values('handle').annotate(recent_id=Max('id')) application_ids = [i['recent_id'] for i in app_tuples] report_ids = Application.objects.filter(id__in=application_ids).values_list('report_id', flat=True) # List of only latest report for an application reports_list = Report.objects.filter(id__in=report_ids, found_trackers=tracker_id) except Tracker.DoesNotExist: raise Http404(_("Tracker does not exist")) paginator = Paginator(reports_list, settings.EX_PAGINATOR_COUNT) page = request.GET.get('page') try: reports = paginator.page(page) except PageNotAnInteger: reports = paginator.page(1) except EmptyPage: reports = paginator.page(paginator.num_pages) count = len(reports_list) score = int(100. * count / reports_number) if score >= 50: tracker_class = "danger" elif score >= 33: tracker_class = "warning" else: tracker_class = "info" data_to_render = { 'tracker': tracker, 'reports': reports, 'count': count, 'score': score, 'tracker_class': tracker_class } return render(request, 'tracker_details.html', data_to_render)
def deleteUnit(request, unit_id=None): # STEP1.0.0: Set template and create an empty context object. t = 'systemAdmin/extensions/mono_page.html' context = {} # STEP1.1: Test for session, to determine currently logged in user. try: if request.session['user_admin']: # if user is logged in, build the required page. # create new user instance user = request.session['user_admin'] # Set session data for the new user set_session_data(request, user) unit = get_object_or_404(ServiceUnit, unit_id=unit_id) # Set admin panel options context.update( {'options': admin_panel_options(active='dashboard')}) if unit: unit.delete() # Turn on flags to enable loading unit update form unit_delete_success = True context.update({'unit_delete_success': True}) if unit_delete_success: # Create a unit object to be sent to the client together with the form context.update({'unit': unit}) return redirect('systemAdmin:serviceUnits', deleted='deleted') #return render(request, t, context) else: return HttpResponse( "<font color = 'red'><b>Error Encountered while Deleting the Service Unit</b></font>" ) else: # If no Service unit matches the given query, # Just Load the standard HTTP 404 page. return Http404() return render(request, t, context) else: # if no user is logged in, try Logging in. return redirect('systemAdmin:login') # End of if request.session['user_admin']: except KeyError: # Just try logging in. return redirect('systemAdmin:login')
def index(request): try: # TODO: Use a Django Form instead ? filter_name = request.GET.get('tracker_name', '') only_collisions = request.GET.get('only_collisions', False) approve_select = request.GET.get('approve_select', '') trackers_select = request.GET.get('trackers_select', '') if filter_name: trackers = Tracker.objects.filter(name__startswith=filter_name) else: trackers = Tracker.objects trackers = trackers.order_by('name') if trackers_select == "exodus": trackers = trackers.filter(is_in_exodus=True) elif trackers_select == "etip": trackers = trackers.filter(is_in_exodus=False) if only_collisions: trackers = list(t for t in trackers if t.has_any_signature_collision()) if approve_select == "approved": trackers = list(t for t in trackers if t.approvals.count() >= 2) elif approve_select == "need_review": trackers = list(t for t in trackers if t.approvals.count() == 1) elif approve_select == "no_approvals": trackers = list(t for t in trackers if t.approvals.count() == 0) count = len(trackers) paginator = Paginator(trackers, 20) page = request.GET.get('page', 1) trackers = paginator.get_page(page) except Tracker.DoesNotExist: raise Http404("trackers does not exist") return render( request, 'tracker_list.html', { 'trackers': trackers, 'count': count, 'filter_name': filter_name, 'only_collisions': 'checked' if only_collisions else '', 'approve_select': approve_select, 'trackers_select': trackers_select })
def post(self, request, scan_id=None): """Launches a scan to ingest from an existing scan model instance :param request: the HTTP POST request :type request: :class:`rest_framework.request.Request` :param scan_id: ID for Scan record to pull configuration from :type scan_id: int :rtype: :class:`rest_framework.response.Response` :returns: the HTTP response to send back to the user """ if request.version == 'v6': return self._post_v6(request, scan_id) elif request.version == 'v7': return self._post_v6(request, scan_id) raise Http404()
def create(self, request): """Determine api version and call specific method :param request: the HTTP POST request :type request: :class:`rest_framework.request.Request` :rtype: :class:`rest_framework.response.Response` :returns: the HTTP response to send back to the user """ if request.version == 'v4': return self.create_impl(request) elif request.version == 'v5': return self.create_impl(request) elif request.version == 'v6': return self.create_impl_v6(request) raise Http404()
def retrieve(self, request, batch_id): """Retrieves the details for a batch and returns them in JSON form :param request: the HTTP GET request :type request: :class:`rest_framework.request.Request` :param batch_id: The batch ID :type batch_id: int :rtype: :class:`rest_framework.response.Response` :returns: the HTTP response to send back to the user """ if request.version == 'v6': return self._retrieve_v6(batch_id) elif request.version == 'v7': return self._retrieve_v6(batch_id) raise Http404()
def get(self, request, root_batch_id): """Validates a new batch :param request: the HTTP GET request :type request: :class:`rest_framework.request.Request` :param root_batch_id: The root batch ID :type root_batch_id: int :rtype: :class:`rest_framework.response.Response` :returns: the HTTP response to send back to the user """ if request.version == 'v6': return self._get_v6(request, root_batch_id) elif request.version == 'v7': return self._get_v6(request, root_batch_id) raise Http404()
def retrieve(self, request, recipe_id): """Retrieves the details for a recipe and returns it in JSON form :param request: the HTTP GET request :type request: :class:`rest_framework.request.Request` :param recipe_id: The id of the recipe :type recipe_id: int encoded as a str :rtype: :class:`rest_framework.response.Response` :returns: the HTTP response to send back to the user """ if request.version == 'v6': return self._retrieve_v6(request, recipe_id) elif request.version == 'v7': return self._retrieve_v6(request, recipe_id) raise Http404()
def post(self, request, recipe_id): """Schedules a recipe for reprocessing and returns it in JSON form :param request: the HTTP GET request :type request: :class:`rest_framework.request.Request` :param recipe_id: The id of the recipe :type recipe_id: int encoded as a str :rtype: :class:`rest_framework.response.Response` :returns: the HTTP response to send back to the user """ if request.version == 'v6': return self._post_v6(request, recipe_id) elif request.version == 'v7': return self._post_v6(request, recipe_id) raise Http404()
def registeruer(request, dealer_code=None): customer_factory = CustomerServicesFactory() cuser = customer_factory.get_instance("user") if request.GET.get("profile_id"): profile = cuser.get_user_profile(request.GET.get("profile_id")) if profile: initial_user_form = {"profile": profile.id} usercreateform = CreateUserForm(initial=initial_user_form) return render( request, "customer/registeruser.html", { "usercreationform": usercreateform, "profile": profile, "done_disable": True, "request": request }) else: raise Http404("Profile not found")
def get_resource_objects(self): super().get_resource_objects() MANAGERS = { "category": CategoryManager, "module": ModuleManager, "exercise": ExerciseManager, } self.model = self._get_kwarg(self.model_kw) if not self.model in MANAGERS: raise Http404() self.manager = MANAGERS[self.model]() self.model_name = self.manager.name # FIXME: model is passed from kwargs in View.dispatch and from # BaseMixin/BaseTemplateMixin to template context. As the value is # same, this should break anything, but is still a problematic thing. # Should be fixed one day. self.note("model", "model_name")
def retrieve(self, request, ingest_id=None, file_name=None): """Determine api version and call specific method :param request: the HTTP GET request :type request: :class:`rest_framework.request.Request` :param ingest_id: The id of the ingest :type ingest_id: int encoded as a str :param file_name: The name of the ingest :type file_name: string :rtype: :class:`rest_framework.response.Response` :returns: the HTTP response to send back to the user """ if request.version == 'v6' or request.version == 'v7': return self.retrieve_v6(request, ingest_id) raise Http404()
def retrieve(self, request, file_id): """Determine api version and call specific method :param request: the HTTP POST request :type request: :class:`rest_framework.request.Request` :param file_id: The id of the file :type file_id: int encoded as a string :rtype: :class:`rest_framework.response.Response` :returns: the HTTP response to send back to the user """ if request.version == 'v6': return self.retrieve_impl(request, file_id) elif request.version == 'v7': return self.retrieve_impl(request, file_id) raise Http404()
def finance(request, id=None): if id is None: ad_list = Advertisement.objects.filter(Q(location='0') | Q(location='4'), is_hidden=False)[0:8] strategy_list = Press.objects.filter(type='2')[0:10] context = {'ad_list': ad_list, 'strategy_list': strategy_list} rank_users = MyUser.objects.order_by('-accu_income')[0:6] for i in range(len(rank_users)): key = 'rank' + str(i + 1) username = rank_users[i].username if len(username) > 4: username = username[0:4] + '****' else: username = username + '****' income = rank_users[i].accu_income context.update( {key: { 'username': username, 'income': str(income) }}) return render(request, 'finance.html', context) else: id = int(id) news = None try: news = Finance.objects.get(id=id) except Finance.DoesNotExist: raise Http404(u"该页面不存在") update_view_count(news) scheme = news.scheme table = [] str_rows = scheme.split('|') for str_row in str_rows: row = str_row.split('#') table.append(row) other_wel_list = Finance.objects.filter( state='1', level__in=['normal', 'all']).order_by('-view_count')[0:10] context = { 'news': news, 'type': 'Finance', 'other_wel_list': other_wel_list, 'table': table, } return render(request, 'detail-finance.html', context)
def handle_instance_action(request, action): form = request.form.clean() if action not in actions_for_instance: raise Http404() instance_id = form.get('instance_id') if action == 'start': return start_pipeline(instance_id, request.user.username) try: result = actions_for_instance[action](instance_id) except Exception as e: logger.exception(traceback.format_exc(e)) return action_result(False, 'An error occurred, please contact developer.', status=500) return action_result(result.result, result.message)
def get(self, request, scan_id): """Retrieves the details for a Scan process and return them in JSON form :param request: the HTTP GET request :type request: :class:`rest_framework.request.Request` :param scan_id: The ID of the Scan process :type scan_id: int encoded as a str :rtype: :class:`rest_framework.response.Response` :returns: the HTTP response to send back to the user """ if request.version == 'v6': return self._get_v6(request, scan_id) elif request.version == 'v7': return self._get_v6(request, scan_id) raise Http404()
def wrap(request, *args, **kwargs): appservice = appointmentservices.AppointmentService() appointment_id = None if request.method =="POST": appointment_id = request.POST.get("appointment_id") if appointment_id == None: appointment_id =request.GET.get("appointment_id") appointment = appservice.get_valid_appointment(appointment_id) #this check the session if userid key exist, if not it will redirect to login page if appointment == None: raise Http404("Appointment does not exist") else: request.session["appointment_id"] = appointment_id return f(request, appointment,*args, **kwargs)
def patch(self, request, scan_id): """Edits an existing Scan process and returns the updated details :param request: the HTTP GET request :type request: :class:`rest_framework.request.Request` :param scan_id: The ID of the Scan process :type scan_id: int encoded as a str :rtype: :class:`rest_framework.response.Response` :returns: the HTTP response to send back to the user """ if request.version == 'v6': return self._patch_v6(request, scan_id) elif request.version == 'v7': return self._patch_v6(request, scan_id) raise Http404()
def get(self, request, recipe_id): """Retrieve detailed information about the input files for a recipe :param request: the HTTP GET request :type request: :class:`rest_framework.request.Request` :param recipe_id: The ID for the recipe. :type recipe_id: int encoded as a str :rtype: :class:`rest_framework.response.Response` :returns: the HTTP response to send back to the user """ if request.version == 'v6': return self._get_v6(request, recipe_id) elif request.version == 'v7': return self._get_v6(request, recipe_id) raise Http404()
def patch(self, request, strike_id): """Determine api version and call specific method :param request: the HTTP POST request :type request: :class:`rest_framework.request.Request` :param strike_id: The ID of the Strike process :type strike_id: int encoded as a str :rtype: :class:`rest_framework.response.Response` :returns: the HTTP response to send back to the user """ if request.version == 'v6': return self.patch_impl_v6(request, strike_id) elif request.version == 'v7': return self.patch_impl_v6(request, strike_id) raise Http404()
def like_post(request, post_id): post = Post.objects.get(pk=post_id) is_liked = False user = request.user.profile try: profile = Profile.objects.get(user=user.user) print(profile) except Profile.DoesNotExist: raise Http404() if post.likes.filter(id=user.user.id).exists(): post.likes.remove(user.user) is_liked = False else: post.likes.add(user.user) is_liked = True return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
def create(self, request): """Creates a new Workspace and returns it in JSON form :param request: the HTTP POST request :type request: :class:`rest_framework.request.Request` :rtype: :class:`rest_framework.response.Response` :returns: the HTTP response to send back to the user """ if request.version == 'v6': return self._create_v6(request) elif request.version == 'v5': return self._create_v5(request) elif request.version == 'v4': return self._create_v5(request) raise Http404()
def update(self, request, batch_id, **kwargs): """Updates the given batch :param request: the HTTP PATCH request :type request: :class:`rest_framework.request.Request` :param batch_id: the batch id :type batch_id: int :rtype: :class:`rest_framework.response.Response` :returns: the HTTP response to send back to the user """ if request.version == 'v6': return self._update_v6(request, batch_id) elif request.version == 'v7': return self._update_v6(request, batch_id) raise Http404()
def list(self, request): """Retrieves the batches and returns them in JSON form :param request: the HTTP GET request :type request: :class:`rest_framework.request.Request` :rtype: :class:`rest_framework.response.Response` :returns: the HTTP response to send back to the user """ if request.version == 'v6': return self._list_v6(request) elif request.version == 'v5': return self._list_v5(request) elif request.version == 'v4': return self._list_v5(request) raise Http404()
def create_result_response(self, service, result, service_path): for nested in service_path: result = result.get(nested, None) if result is None: break if result is None: raise Http404() if result in (True, False): status_code = 200 if result else _get_err_status_code() return HttpResponse(str(result).lower(), status=status_code) elif isinstance(result, six.string_types) or isinstance(result, bytes): return HttpResponse(result) else: # Django requires safe=False for non-dict values. return JsonResponse(result, safe=False)
def post(self, request): """Validates a new workspace and returns any warnings discovered :param request: the HTTP POST request :type request: :class:`rest_framework.request.Request` :rtype: :class:`rest_framework.response.Response` :returns: the HTTP response to send back to the user """ if request.version == 'v6': return self._post_v6(request) elif request.version == 'v5': return self._post_v5(request) elif request.version == 'v4': return self._post_v5(request) raise Http404()