def updateDataset(request): # Get the dataset to update ds = request.session["dataset_name"] if request.method == 'POST': if 'updatedataset' in request.POST: ds_update = get_object_or_404(Dataset,dataset_name=ds) if ds_update.user_id == request.user.id or request.user.is_superuser: form = DatasetForm(data=request.POST or None,instance=ds_update) if form.is_valid(): form.save() messages.success(request, 'Sucessfully updated dataset') del request.session["dataset_name"] return HttpResponseRedirect(get_script_prefix()+'ocpuser/datasets') else: #Invalid form context = {'form': form} print form.errors return render_to_response('updatedataset.html',context,context_instance=RequestContext(request)) else: messages.error(request,"Cannot update. You are not owner of this dataset or not superuser.") return HttpResponseRedirect(get_script_prefix()+'ocpuser/datasets') elif 'backtodatasets' in request.POST: return HttpResponseRedirect(get_script_prefix()+'ocpuser/datasets') else: #unrecognized option return HttpResponseRedirect(get_script_prefix()+'ocpuser/datasets') else: print "Getting the update form" if "dataset_name" in request.session: ds = request.session["dataset_name"] else: ds = "" ds_to_update = Dataset.objects.filter(dataset_name=ds) data = { 'dataset_name': ds_to_update[0].dataset_name, 'ximagesize':ds_to_update[0].ximagesize, 'yimagesize':ds_to_update[0].yimagesize, 'zimagesize':ds_to_update[0].zimagesize, 'xoffset':ds_to_update[0].xoffset, 'yoffset':ds_to_update[0].yoffset, 'zoffset':ds_to_update[0].zoffset, 'public':ds_to_update[0].public, 'xvoxelres':ds_to_update[0].xvoxelres, 'yvoxelres':ds_to_update[0].yvoxelres, 'zvoxelres':ds_to_update[0].zvoxelres, 'scalinglevels':ds_to_update[0].scalinglevels, 'scalingoption':ds_to_update[0].scalingoption, 'starttime':ds_to_update[0].starttime, 'endtime':ds_to_update[0].endtime, 'dataset_description':ds_to_update[0].dataset_description, } form = DatasetForm(initial=data) context = {'form': form} return render_to_response('updatedataset.html',context,context_instance=RequestContext(request))
def strip_script_prefix(url): """ Strips the SCRIPT_PREFIX from the URL. Because this function is meant for use in templates, it assumes the URL starts with the prefix. """ assert url.startswith(urlresolvers.get_script_prefix()), \ "URL must start with SCRIPT_PREFIX: %s" % url pos = len(urlresolvers.get_script_prefix()) - 1 return url[:pos], url[pos:]
def processInputData(request): ''' Extract File name & determine what file corresponds to what for gengraph @param request: the request object ''' filesInUploadDir = os.listdir(request.session['derivatives']) roi_xml_fn, fiber_fn, roi_raw_fn = filesorter.checkFileExtGengraph(filesInUploadDir) # Check & sort files for fileName in [roi_xml_fn, fiber_fn, roi_raw_fn]: if fileName == "": # Means a file is missing from i/p return render_to_response('pipelineUpload.html', context_instance=RequestContext(request)) # Missing file for processing Gengraph baseName = fiber_fn[:-9] # MAY HAVE TO CHANGE ''' Fully qualify file names ''' fiber_fn = os.path.join(request.session['derivatives'], fiber_fn) roi_raw_fn = os.path.join(request.session['derivatives'], roi_raw_fn) roi_xml_fn = os.path.join(request.session['derivatives'], roi_xml_fn) try: request.session['smGrfn'], request.session['bgGrfn'], request.session['lccfn']\ ,request.session['SVDfn'] = processData(fiber_fn, roi_xml_fn, roi_raw_fn, \ request.session['graphs'], request.session['graphInvariants'],\ request.session['graphsize'], True) except: if request.session['graphsize'] == 'big': msg = "Hello,\n\nYour most recent job failed either because your fiber streamline file or ROI mask was incorrectly formatted." msg += " Please check both and try again.%s\n\n" % (" "*randint(0,10)) sendJobFailureEmail(request.session['email'], msg) return HttpResponseRedirect(get_script_prefix()+"jobfailure") # Run ivariants here if len(request.session['invariants']) > 0: print "Computing invariants" if (request.session['graphsize'] == 'big'): graph_fn = request.session['bgGrfn'] lcc_fn = request.session['lccfn'] elif (request.session['graphsize'] == 'small'): graph_fn = request.session['smGrfn'] lcc_fn = None request.session['invariant_fns'] = runInvariants(request.session['invariants'],\ graph_fn, request.session['graphInvariants'],\ lcc_fn, request.session['graphsize']) if request.session['graphsize'] == 'big': sendJobCompleteEmail(request.session['email'], 'http://mrbrain.cs.jhu.edu' + request.session['usrDefProjDir'].replace(' ','%20')) return HttpResponseRedirect(get_script_prefix()+'confirmdownload')
def updateProject(request): proj_name = request.session["project_name"] if request.method == 'POST': if 'UpdateProject' in request.POST: proj_update = get_object_or_404(Project,project_name=proj_name) form = ProjectForm(data= request.POST or None,instance=proj_update) if form.is_valid(): newproj = form.save(commit=False) if newproj.user_id == request.user.id or request.user.is_superuser: if newproj.project_name != proj_name: messages.error ("Cannot change the project name. MySQL cannot rename databases.") else: newproj.save() messages.success(request, 'Sucessfully updated project ' + proj_name) else: messages.error(request,"Cannot update. You are not owner of this project or not superuser.") del request.session["project_name"] return HttpResponseRedirect(get_script_prefix()+'ocpuser/projects') else: #Invalid form context = {'form': form} return render_to_response('updateproject.html',context,context_instance=RequestContext(request)) elif 'backtoprojects' in request.POST: return HttpResponseRedirect(get_script_prefix()+'ocpuser/projects') else: #unrecognized option messages.error(request,"Unrecognized Post") return HttpResponseRedirect(get_script_prefix()+'ocpuser/pojects') else: #Get: Retrieve project and display update project form. if "project_name" in request.session: proj = request.session["project_name"] else: proj = "" project_to_update = Project.objects.filter(project_name=proj) data = { 'project_name': project_to_update[0].project_name, 'project_description':project_to_update[0].project_description, 'dataset':project_to_update[0].dataset_id, 'public':project_to_update[0].public, 'host':project_to_update[0].host, 'kvengine':project_to_update[0].kvengine, 'kvserver':project_to_update[0].kvserver, } form = ProjectForm(initial=data) context = {'form': form} return render_to_response('updateproject.html',context,context_instance=RequestContext(request))
def render(self, context): requestPath = context['request'].path if len(get_script_prefix()) > 0: requestPath = requestPath[len(get_script_prefix()) - 1:] try: resolverMatch = resolve(requestPath) except Resolver404: print >> sys.stderr, 'CurrentNavNode: failed to resolve path %s' % requestPath return '' for pat in self.urlGlobs: if fnmatch(resolverMatch.url_name, pat): return ' class="currentnav"' return ''
def updateToken(request): # Get the dataset to update token = request.session["token_name"] if request.method == 'POST': if 'updatetoken' in request.POST: token_update = get_object_or_404(Token,token_name=token) form = TokenForm(data=request.POST or None, instance=token_update) if form.is_valid(): newtoken = form.save( commit=False ) if newtoken.user_id == request.user.id or request.user.is_superuser: # if you changed the token name, delete old token newtoken.save() if newtoken.token_name != token: deltoken = Token.objects.filter(token_name=token) deltoken.delete() messages.success(request, 'Sucessfully updated Token') del request.session["token_name"] else: messages.error(request,"Cannot update. You are not owner of this token or not superuser.") return HttpResponseRedirect(get_script_prefix()+'ocpuser/token') else: #Invalid form context = {'form': form} print form.errors return render_to_response('updatetoken.html',context,context_instance=RequestContext(request)) elif 'backtotokens' in request.POST: #unrecognized option return HttpResponseRedirect(get_script_prefix()+'ocpuser/token') else: #unrecognized option return HttpResponseRedirect(get_script_prefix()+'ocpuser/token') else: print "Getting the update form" if "token_name" in request.session: token = request.session["token_name"] else: token = "" token_to_update = Token.objects.filter(token_name=token) data = { 'token_name': token_to_update[0].token_name, 'token_description':token_to_update[0].token_description, 'project':token_to_update[0].project_id, 'public':token_to_update[0].public, } form = TokenForm(initial=data) context = {'form': form} return render_to_response('updatetoken.html',context,context_instance=RequestContext(request))
def reverse(viewname, urlconf=None, args=[], kwargs={}, prefix=None): locale = kwargs.pop("locale", translation.get_language()) path = django_reverse(viewname, urlconf, args, kwargs, prefix) script_prefix = urlresolvers.get_script_prefix() if settings.USE_I18N: path = script_prefix + locale + "/" + path.partition(script_prefix)[2] return path
def createDataset(request): if request.method == 'POST': if 'createdataset' in request.POST: form = DatasetForm(request.POST) if form.is_valid(): new_dataset=form.save(commit=False) new_dataset.user_id=request.user.id new_dataset.save() return HttpResponseRedirect(get_script_prefix()+'ocpuser/datasets') else: context = {'form': form} print form.errors return render_to_response('createdataset.html',context,context_instance=RequestContext(request)) elif 'backtodatasets' in request.POST: return redirect(getDatasets) else: #default messages.error(request,"Unkown POST request.") return redirect(getDatasets) else: '''Show the Create datasets form''' form = DatasetForm() context = {'form': form} return render_to_response('createdataset.html',context,context_instance=RequestContext(request))
def locale_url(path, locale=''): """ Generate the localeurl-enabled URL from a path without locale prefix. If the locale is empty settings.LANGUAGE_CODE is used. """ path = locale_path(path, locale) return ''.join([urlresolvers.get_script_prefix(), path[1:]])
def contextprocessor(request): """ Adds data to all template contexts """ try: url = resolve(request.path_info) except Resolver404: return {} if not request.path.startswith(get_script_prefix() + 'control'): return {} ctx = { 'url_name': url.url_name, 'settings': settings, } _html_head = [] if hasattr(request, 'event'): for receiver, response in html_head.send(request.event, request=request): _html_head.append(response) ctx['html_head'] = "".join(_html_head) _nav_event = [] if hasattr(request, 'event'): for receiver, response in nav_event.send(request.event, request=request): _nav_event += response ctx['nav_event'] = _nav_event ctx['js_datetime_format'] = get_javascript_format('DATETIME_INPUT_FORMATS') ctx['js_locale'] = get_moment_locale() return ctx
def from_native(self, value): # Convert URL -> model instance pk # TODO: Use values_list queryset = self.queryset if queryset is None: raise Exception("Writable related fields must include a `queryset` argument") try: http_prefix = value.startswith(("http:", "https:")) except AttributeError: msg = self.error_messages["incorrect_type"] raise ValidationError(msg % type(value).__name__) if http_prefix: # If needed convert absolute URLs to relative path value = urlparse.urlparse(value).path prefix = get_script_prefix() if value.startswith(prefix): value = "/" + value[len(prefix):] try: match = resolve(value) except Exception: raise ValidationError(self.error_messages["no_match"]) if match.view_name != self.view_name: raise ValidationError(self.error_messages["incorrect_match"]) try: return self.get_object(queryset, match.view_name, match.args, match.kwargs) except (ObjectDoesNotExist, TypeError, ValueError): raise ValidationError(self.error_messages["does_not_exist"])
def get_via_uri(self, uri, request=None): """ This pulls apart the salient bits of the URI and populates the resource via a ``obj_get``. Optionally accepts a ``request``. If you need custom behavior based on other portions of the URI, simply override this method. """ prefix = get_script_prefix() chomped_uri = uri if prefix and chomped_uri.startswith(prefix): chomped_uri = chomped_uri[len(prefix)-1:] try: view, args, kwargs = resolve(chomped_uri) resource_name = kwargs['resource_name'] resource_class = self.resource_mapping[resource_name] except (Resolver404, KeyError): raise NotFound("The URL provided '%s' was not a link to a valid resource." % uri) parent_resource = resource_class(api_name=self._meta.api_name) kwargs = parent_resource.remove_api_resource_names(kwargs) return parent_resource.obj_get(**kwargs)
def resolve_uri(self, uri): """ Resolve a full URL This is a wrapper around ``django.core.urlresolvers.reverse()`` that first strips the non-path URL parts. Returns a ``ResolverMatch`` object or None if there is no match """ prefix = get_script_prefix() parsed = urlparse.urlparse(uri) path = parsed.path chomped_path = path if prefix and chomped_path.startswith(prefix): chomped_path = chomped_path[len(prefix)-1:] if chomped_path[-1] != '/': chomped_path += '/' # If the language isn't in the path, add it, otherwise resolve() will # fail if not LANG_PREFIX_RE.match(chomped_path): chomped_path = "/%s%s" % (settings.LANGUAGE_CODE, chomped_path) try: match = resolve(chomped_path) except Http404: return None if match.url_name not in self.url_name_lookup: return None return match
def language_free_path(request): script_prefix = get_script_prefix() path_prefix = script_prefix + request.LANGUAGE_CODE + '/' path = request.path if path.startswith(path_prefix): path = path.replace(path_prefix, script_prefix, 1) return path
def get_pk(self, pk=None, model=None, *args, **kwargs): logging.debug('** get_pk') script_prefix = get_script_prefix() logging.debug(' script_prefix: %s' % script_prefix) logging.debug(' pk: %s' % pk) logging.debug(' model: %s' % model) if pk and model and (script_prefix in settings.REDIRECT_MAP): data_dir = settings.REDIRECT_MAP[script_prefix] logging.debug(' data_dir: %s' % data_dir) else: return None if not (script_prefix in self.model_pk_map): self.model_pk_map[script_prefix] = {} if not (model in self.model_pk_map[script_prefix]): try: data_file = os.path.join(data_dir, '%s.map.json' % model) fp = open(data_file) self.model_pk_map[script_prefix][model] = json.load(fp) fp.close() except IOError: # The pk map file doesn't exist, or is unreadable logging.debug(' IOError') self.model_pk_map[script_prefix][model] = {} return self.model_pk_map[script_prefix][model].get(pk)
def post_context_data(self, **kwargs): path = self.request.POST.get('path') script_prefix = get_script_prefix() if not path.startswith(script_prefix): path = os.path.join(script_prefix, path) share_url = self.request.build_absolute_uri(path) return { 'share_url': share_url }
def get_dataset_from_kwargs(self, bundle, **kwargs): """ Extract a dataset from one of the variety of places it might be hiding. """ kwargs_slug = kwargs["dataset_slug"] bundle_uri = None bundle_slug = None if bundle: bundle_uri = bundle.data.pop("dataset", None) if bundle_uri: prefix = get_script_prefix() if prefix and bundle_uri.startswith(prefix): bundle_uri = bundle_uri[len(prefix) - 1 :] view, args, kwargs = resolve(bundle_uri) bundle_slug = kwargs["slug"] if bundle_slug and bundle_slug != kwargs_slug: raise BadRequest("Dataset specified in request body does not agree with dataset API endpoint used.") return Dataset.objects.get(slug=kwargs_slug)
def to_internal_value(self, data): """ TODO - I've had to copy this method from HyperlinkedRelatedField purely so that it can deal with polymorphic models. This probably is not ideal. """ try: http_prefix = data.startswith(('http:', 'https:')) except AttributeError: self.fail('incorrect_type', data_type=type(data).__name__) if http_prefix: # If needed convert absolute URLs to relative path data = urlparse.urlparse(data).path prefix = get_script_prefix() if data.startswith(prefix): data = '/' + data[len(prefix):] try: match = resolve(data) except Resolver404: self.fail('no_match') if self._serializer_is_polymorphic: # TODO - This is not really what we want. Need to make sure # that match.view_name points to a view which uses a subtype # serializer for this polymorphic serializer self.view_name = match.view_name if match.view_name != self.view_name: self.fail('incorrect_match') try: return self.get_object(match.view_name, match.args, match.kwargs) except (ObjectDoesNotExist, TypeError, ValueError): self.fail('does_not_exist')
def process_request(self, request: HttpRequest): language = get_language_from_request(request) # Normally, this middleware runs *before* the event is set. However, on event frontend pages it # might be run a second time by pretix.presale.EventMiddleware and in this case the event is already # set and can be taken into account for the decision. if hasattr(request, 'event') and not request.path.startswith(get_script_prefix() + 'control'): if language not in request.event.settings.locales: firstpart = language.split('-')[0] if firstpart in request.event.settings.locales: language = firstpart else: language = request.event.settings.locale for lang in request.event.settings.locales: if lang.startswith(firstpart + '-'): language = lang break translation.activate(language) request.LANGUAGE_CODE = translation.get_language() tzname = None if request.user.is_authenticated(): tzname = request.user.timezone if hasattr(request, 'event'): tzname = request.event.settings.timezone if tzname: try: timezone.activate(pytz.timezone(tzname)) request.timezone = tzname except pytz.UnknownTimeZoneError: pass else: timezone.deactivate()
def _page_not_found(self): # Since this view acts as a catch-all, give better error messages # when mistyping an admin URL. Don't mention anything about CMS pages in /admin. try: full_path = get_script_prefix() + self.path.lstrip('/') if full_path.startswith(reverse('admin:index')): raise Http404(u"No admin page found at '{0}'\n(raised by fluent_pages catch-all).".format(self.path)) except NoReverseMatch: # Admin might not be loaded. pass if settings.DEBUG and self.model.objects.published().count() == 0 and self.path == '/': # No pages in the database, present nice homepage. return self._intro_page() else: fallback = _get_fallback_language(self.language_code) if fallback: languages = (self.language_code, fallback) tried_msg = u" (language '{0}', fallback: '{1}')".format(*languages) else: tried_msg = u", language '{0}'".format(self.language_code) if self.path == '/': raise Http404(u"No published '{0}' found for the path '{1}'{2}. Use the 'Override URL' field to make sure a page can be found at the root of the site.".format(self.model.__name__, self.path, tried_msg)) else: raise Http404(u"No published '{0}' found for the path '{1}'{2}.".format(self.model.__name__, self.path, tried_msg))
def createToken(request): if request.method == 'POST': if 'createtoken' in request.POST: form = TokenForm(request.POST) # restrict projects to user visible fields form.fields['project'].queryset = Project.objects.filter(user_id=request.user.id) | Project.objects.filter(public=1) if form.is_valid(): new_token=form.save(commit=False) new_token.user_id=request.user.id new_token.save() return HttpResponseRedirect(get_script_prefix()+'ocpuser/projects') else: context = {'form': form} print form.errors return render_to_response('createtoken.html',context,context_instance=RequestContext(request)) elif 'backtotokens' in request.POST: return redirect(getTokens) else: messages.error(request,"Unrecognized Post") redirect(getTokens) else: '''Show the Create datasets form''' form = TokenForm() # restrict projects to user visible fields form.fields['project'].queryset = Project.objects.filter(user_id=request.user.id) | Project.objects.filter(public=1) context = {'form': form} return render_to_response('createtoken.html',context,context_instance=RequestContext(request))
def to_internal_value(self, data): request = self.context.get('request', None) try: http_prefix = data.startswith(('http:', 'https:')) except AttributeError: self.fail('incorrect_type', data_type=type(data).__name__) if http_prefix: # If needed convert absolute URLs to relative path data = urlparse.urlparse(data).path prefix = get_script_prefix() if data.startswith(prefix): data = '/' + data[len(prefix):] try: match = resolve(data) except Resolver404: self.fail('no_match') try: expected_viewname = request.versioning_scheme.get_versioned_viewname( self.view_name, request ) except AttributeError: expected_viewname = self.view_name if match.view_name != expected_viewname: self.fail('incorrect_match') try: return self.get_object(match.view_name, match.args, match.kwargs) except (ObjectDoesNotExist, TypeError, ValueError): self.fail('does_not_exist')
def process_request(self, request): language = get_language_from_request(request) if hasattr(request, 'event') and not request.path.startswith(get_script_prefix() + 'control'): if language not in request.event.settings.locales: firstpart = language.split('-')[0] if firstpart in request.event.settings.locales: language = firstpart else: language = request.event.settings.locale for lang in request.event.settings.locales: if lang == firstpart or lang.startswith(firstpart + '-'): language = lang break translation.activate(language) request.LANGUAGE_CODE = translation.get_language() tzname = None if request.user.is_authenticated(): tzname = request.user.timezone if hasattr(request, 'event'): tzname = request.event.settings.timezone if tzname: try: timezone.activate(pytz.timezone(tzname)) request.timezone = tzname except pytz.UnknownTimeZoneError: pass else: timezone.deactivate()
def get_breadcrumbs(url): """Given a url returns a list of breadcrumbs, which are each a tuple of (name, url).""" from rest_framework.views import APIView def breadcrumbs_recursive(url, breadcrumbs_list, prefix, seen): """Add tuples of (name, url) to the breadcrumbs list, progressively chomping off parts of the url.""" try: (view, unused_args, unused_kwargs) = resolve(url) except Exception: pass else: # Check if this is a REST framework view, and if so add it to the breadcrumbs if isinstance(getattr(view, 'cls_instance', None), APIView): # Don't list the same view twice in a row. # Probably an optional trailing slash. if not seen or seen[-1] != view: breadcrumbs_list.insert(0, (view.cls_instance.get_name(), prefix + url)) seen.append(view) if url == '': # All done return breadcrumbs_list elif url.endswith('/'): # Drop trailing slash off the end and continue to try to resolve more breadcrumbs return breadcrumbs_recursive(url.rstrip('/'), breadcrumbs_list, prefix, seen) # Drop trailing non-slash off the end and continue to try to resolve more breadcrumbs return breadcrumbs_recursive(url[:url.rfind('/') + 1], breadcrumbs_list, prefix, seen) prefix = get_script_prefix().rstrip('/') url = url[len(prefix):] return breadcrumbs_recursive(url, [], prefix, [])
def logout(request): """ Log the user out. """ auth_logout(request) info(request, _("Successfully logged out")) return redirect(next_url(request) or get_script_prefix())
def process_response(self, request, response): language = translation.get_language() language_from_path = translation.get_language_from_path(request.path_info) if (response.status_code == 404 and not language_from_path and self.is_language_prefix_patterns_used()): urlconf = getattr(request, 'urlconf', None) language_path = '/%s%s' % (language, request.path_info) path_valid = is_valid_path(language_path, urlconf) if (not path_valid and settings.APPEND_SLASH and not language_path.endswith('/')): path_valid = is_valid_path("%s/" % language_path, urlconf) if path_valid: script_prefix = get_script_prefix() language_url = "%s://%s%s" % ( request.scheme, request.get_host(), # insert language after the script prefix and before the # rest of the URL request.get_full_path().replace( script_prefix, '%s%s/' % (script_prefix, language), 1 ) ) return self.response_redirect_class(language_url) if not (self.is_language_prefix_patterns_used() and language_from_path): patch_vary_headers(response, ('Accept-Language',)) if 'Content-Language' not in response: response['Content-Language'] = language return response
def to_internal_value(self, data): try: http_prefix = data.startswith(("http:", "https:")) except AttributeError: self.fail("incorrect_type", data_type=type(data).__name__) if http_prefix: # If needed convert absolute URLs to relative path data = urlparse.urlparse(data).path prefix = get_script_prefix() if data.startswith(prefix): data = "/" + data[len(prefix) :] try: match = self.resolve(data) except Resolver404: self.fail("no_match") if match.view_name != self.view_name: self.fail("incorrect_match") try: return self.get_object(match.view_name, match.args, match.kwargs) except (ObjectDoesNotExist, TypeError, ValueError): self.fail("does_not_exist")
def logout_view(request, template_name='logout.html', next_page=None): """ Display the logout and handles the logout action. """ if request.method == 'POST': username = request.user.username # Since we know the user is logged in, we can now just log them out. logout(request) logger.info(_("OSCM User \'{0:s}\' is logged out.").format( str(username))) # Set the user's language if necessary current_language = translation.get_language() default_language = get_attr('LANGUAGE_CODE') if current_language != default_language: logger.debug( _( "Change the current language \'%(current_language)s\' " "to \'%(default_language)s\'."), { "current_language": current_language, "default_language": default_language}) # "activate()"" works only for the current view translation.activate(default_language) # Set the session variable request.session[ translation.LANGUAGE_SESSION_KEY] = default_language # messages.success(request, _("You have been logged out.")) return HttpResponseRedirect(next_url(request) or get_script_prefix()) else: context = {"title": _("Log out"), "next": next_page} context.update(csrf(request)) return render(request, template_name, context)
def add_preserved_filters(context, url, popup=False, to_field=None): opts = context.get('opts') preserved_filters = context.get('preserved_filters') parsed_url = list(urlparse(url)) parsed_qs = dict(parse_qsl(parsed_url[4])) merged_qs = dict() if opts and preserved_filters: preserved_filters = dict(parse_qsl(preserved_filters)) match_url = '/%s' % url.partition(get_script_prefix())[2] try: match = resolve(match_url) except Resolver404: pass else: current_url = '%s:%s' % (match.app_name, match.url_name) changelist_url = 'admin:%s_%s_changelist' % (opts.app_label, opts.model_name) if changelist_url == current_url and '_changelist_filters' in preserved_filters: preserved_filters = dict(parse_qsl(preserved_filters['_changelist_filters'])) merged_qs.update(preserved_filters) if popup: from myrobogals.admin.options import IS_POPUP_VAR merged_qs[IS_POPUP_VAR] = 1 if to_field: from myrobogals.admin.options import TO_FIELD_VAR merged_qs[TO_FIELD_VAR] = to_field merged_qs.update(parsed_qs) parsed_url[4] = urlencode(merged_qs) return urlunparse(parsed_url)
def getScriptPrefix(tailurl): ''' Custom filter used to get the script prefix of a certain url @param tailurl: the tail of the url @return str: the fully built url ''' return get_script_prefix() + tailurl
from django.conf.urls import patterns, url from django.core.urlresolvers import get_script_prefix from django.views.generic import RedirectView urlpatterns = patterns( 'wafer.pages.views', url('^index(?:\.html)?$', RedirectView.as_view(url=get_script_prefix(), query_string=True)), url(r'^(.*)$', 'slug', name='wafer_page'), )
def _convert(template, params=[]): """URI template converter""" paths = template % dict([p, "{%s}" % p] for p in params) return u"%s%s" % (get_script_prefix(), paths)
def get_absolute_url(self): root_relative_url = self.get_profile_url() relative_url = root_relative_url[len(get_script_prefix()):] return '%s/%s' % (django_settings.APP_URL, relative_url)
def view_events(request): if request.method == "GET": context = {'events': fetch(request), 'slash': get_script_prefix()} return render_to_response("events.html", context) else: return post_event(request)
def base_url(request): return {'base_url': get_script_prefix()}
def __init__(self, newpath): self.newpath = newpath self.oldprefix = get_script_prefix()
def get_context_data(self, **kwargs): context = super(ShareView, self).get_context_data(**kwargs) context['script_prefix'] = get_script_prefix() return context
def get_absolute_url(self): if self.urlname: return "/%s/%s/" % (self.directory, self.urlname) else: return iri_to_uri(get_script_prefix().rstrip('/') + self.url)
def obj_update(self, bundle, **kwargs): """ Update an object in CRITs. Should be overridden by each individual top-level resource. :returns: NotImplementedError if the resource doesn't override. """ import crits.actors.handlers as ah import crits.core.handlers as coreh import crits.objects.handlers as objh import crits.relationships.handlers as relh import crits.services.handlers as servh import crits.signatures.handlers as sigh import crits.indicators.handlers as indh actions = { 'Common': { 'add_object': objh.add_object, 'add_releasability': coreh.add_releasability, 'forge_relationship': relh.forge_relationship, 'run_service': servh.run_service, 'status_update': coreh.status_update, 'ticket_add': coreh.ticket_add, 'ticket_update': coreh.ticket_update, 'ticket_remove': coreh.ticket_remove, 'source_add_update': coreh.source_add_update, 'source_remove': coreh.source_remove, 'action_add': coreh.action_add, 'action_update': coreh.action_update, 'action_remove': coreh.action_remove, 'description_update': coreh.description_update, }, 'Actor': { 'update_actor_tags': ah.update_actor_tags, 'attribute_actor_identifier': ah.attribute_actor_identifier, 'set_identifier_confidence': ah.set_identifier_confidence, 'remove_attribution': ah.remove_attribution, 'set_actor_name': ah.set_actor_name, 'update_actor_aliases': ah.update_actor_aliases, }, 'Backdoor': {}, 'Campaign': {}, 'Certificate': {}, 'Domain': {}, 'Email': {}, 'Event': {}, 'Exploit': {}, 'Indicator': { 'set_indicator_attack_type': indh.set_indicator_attack_type, 'set_indicator_threat_type': indh.set_indicator_threat_type, 'activity_add': indh.activity_add, 'activity_update': indh.activity_update, 'activity_remove': indh.activity_remove, 'ci_update': indh.ci_update }, 'IP': {}, 'PCAP': {}, 'RawData': {}, 'Sample': {}, 'Signature': { 'update_dependency': sigh.update_dependency, 'update_min_version': sigh.update_min_version, 'update_max_version': sigh.update_max_version, 'update_signature_data': sigh.update_signature_data, 'update_signature_type': sigh.update_signature_type, 'update_title': sigh.update_title }, 'Target': {}, } prefix = get_script_prefix() uri = bundle.request.path if prefix and uri.startswith(prefix): uri = uri[len(prefix) - 1:] view, args, kwargs = resolve(uri) type_ = kwargs['resource_name'].title() if type_ == "Raw_Data": type_ = "RawData" if type_[-1] == 's': type_ = type_[:-1] if type_ in ("Pcap", "Ip"): type_ = type_.upper() id_ = kwargs['pk'] content = {'return_code': 0, 'type': type_, 'message': '', 'id': id_} # Make sure we have an appropriate action. action = bundle.data.get("action", None) atype = actions.get(type_, None) if atype is None: content['return_code'] = 1 content['message'] = "'%s' is not a valid resource." % type_ self.crits_response(content) action_type = atype.get(action, None) if action_type is None: atype = actions.get('Common') action_type = atype.get(action, None) if action_type: data = bundle.data # Requests don't need to have an id_ as we will derive it from # the request URL. Override id_ if the request provided one. data['id_'] = id_ # Override type (if provided) data['type_'] = type_ # Override user (if provided) with the one who made the request. data['user'] = bundle.request.user.username try: results = action_type(**data) if not results.get('success', False): content['return_code'] = 1 # TODO: Some messages contain HTML and other such content # that we shouldn't be returning here. message = results.get('message', None) content['message'] = message else: content['message'] = "success!" except Exception, e: content['return_code'] = 1 content['message'] = str(e)
def app_reverse(viewname, urlconf=None, args=None, kwargs=None, *vargs, **vkwargs): """ Reverse URLs from application contents Works almost like Django's own reverse() method except that it resolves URLs from application contents. The second argument, ``urlconf``, has to correspond to the URLconf parameter passed in the ``APPLICATIONS`` list to ``Page.create_content_type``:: app_reverse('mymodel-detail', 'myapp.urls', args=...) or app_reverse('mymodel-detail', 'myapp.urls', kwargs=...) The second argument may also be a request object if you want to reverse an URL belonging to the current application content. """ # First parameter might be a request instead of an urlconf path, so # we'll try to be helpful and extract the current urlconf from it extra_context = getattr(urlconf, '_feincms_extra_context', {}) appconfig = extra_context.get('app_config', {}) urlconf = appconfig.get('urlconf_path', urlconf) appcontent_class = ApplicationContent._feincms_content_models[0] cache_key = appcontent_class.app_reverse_cache_key(urlconf) url_prefix = cache.get(cache_key) if url_prefix is None: content = appcontent_class.closest_match(urlconf) if content is not None: if urlconf in appcontent_class.ALL_APPS_CONFIG: # We have an overridden URLconf app_config = appcontent_class.ALL_APPS_CONFIG[urlconf] urlconf = app_config['config'].get('urls', urlconf) prefix = content.parent.get_absolute_url() prefix += '/' if prefix[-1] != '/' else '' url_prefix = (urlconf, prefix) cache.set(cache_key, url_prefix, timeout=APP_REVERSE_CACHE_TIMEOUT) if url_prefix: # vargs and vkwargs are used to send through additional parameters # which are uninteresting to us (such as current_app) prefix = get_script_prefix() try: set_script_prefix(url_prefix[1]) return reverse(viewname, url_prefix[0], args=args, kwargs=kwargs, *vargs, **vkwargs) finally: set_script_prefix(prefix) raise NoReverseMatch("Unable to find ApplicationContent for %r" % urlconf)
def add_script_prefix(path): """ Prepends the SCRIPT_PREFIX to a path. """ return ''.join([urlresolvers.get_script_prefix(), path[1:]])
def __init__(self, prefix): self.prefix = prefix self.old_prefix = get_script_prefix()
def get_absolute_url(self): # Handle script prefix manually because we bypass reverse() return iri_to_uri(get_script_prefix().rstrip('/') + self.url)
def reverse(viewname, urlconf=None, args=None, kwargs=None, current_app=None): """monkey patched reverse path supports easy patching 3rd party urls if 3rd party app has namespace for example ``catalogue`` and you create FeinCMS plugin with same name as this namespace reverse returns url from ApplicationContent ! """ if not urlconf: urlconf = get_urlconf() resolver = get_resolver(urlconf) args = args or [] kwargs = kwargs or {} prefix = get_script_prefix() if not isinstance(viewname, six.string_types): view = viewname else: parts = viewname.split(':') parts.reverse() view = parts[0] path = parts[1:] resolved_path = [] ns_pattern = '' while path: ns = path.pop() # Lookup the name to see if it could be an app identifier try: app_list = resolver.app_dict[ns] # Yes! Path part matches an app in the current Resolver if current_app and current_app in app_list: # If we are reversing for a particular app, # use that namespace ns = current_app elif ns not in app_list: # The name isn't shared by one of the instances # (i.e., the default) so just pick the first instance # as the default. ns = app_list[0] except KeyError: pass try: extra, resolver = resolver.namespace_dict[ns] resolved_path.append(ns) ns_pattern = ns_pattern + extra except KeyError as key: for urlconf, config in six.iteritems( ApplicationWidget._feincms_content_models[0]. ALL_APPS_CONFIG): partials = viewname.split(':') app = partials[0] partials = partials[1:] # check if namespace is same as app name and try resolve if urlconf.split(".")[-1] == app: try: return app_reverse(':'.join(partials), urlconf, args=args, kwargs=kwargs, current_app=current_app) except NoReverseMatch: pass if resolved_path: raise NoReverseMatch( "%s is not a registered namespace inside '%s'" % (key, ':'.join(resolved_path))) else: raise NoReverseMatch("%s is not a registered namespace" % key) if ns_pattern: resolver = get_ns_resolver(ns_pattern, resolver) return iri_to_uri( resolver._reverse_with_prefix(view, prefix, *args, **kwargs))
def contextprocessor(request): """ Adds data to all template contexts """ try: url = resolve(request.path_info) except Resolver404: return {} if not request.path.startswith(get_script_prefix() + 'control'): return {} ctx = { 'url_name': url.url_name, 'settings': settings, 'DEBUG': settings.DEBUG, } _html_head = [] if hasattr(request, 'event'): for receiver, response in html_head.send(request.event, request=request): _html_head.append(response) ctx['html_head'] = "".join(_html_head) _js_payment_weekdays_disabled = '[]' _nav_event = [] if getattr(request, 'event', None) and hasattr(request, 'organizer'): for receiver, response in nav_event.send(request.event, request=request): _nav_event += response if request.event.settings.get('payment_term_weekdays'): _js_payment_weekdays_disabled = '[0,6]' ctx['nav_event'] = _nav_event ctx['js_payment_weekdays_disabled'] = _js_payment_weekdays_disabled _nav_global = [] if not hasattr(request, 'event'): for receiver, response in nav_global.send(request, request=request): _nav_global += response ctx['nav_global'] = sorted(_nav_global, key=lambda n: n['label']) _nav_topbar = [] for receiver, response in nav_topbar.send(request, request=request): _nav_topbar += response ctx['nav_topbar'] = sorted(_nav_topbar, key=lambda n: n['label']) ctx['js_datetime_format'] = get_javascript_format('DATETIME_INPUT_FORMATS') ctx['js_date_format'] = get_javascript_format('DATE_INPUT_FORMATS') ctx['js_locale'] = get_moment_locale() if settings.DEBUG and 'runserver' not in sys.argv: ctx['debug_warning'] = True elif 'runserver' in sys.argv: ctx['development_warning'] = True ctx['warning_update_available'] = False ctx['warning_update_check_active'] = False if request.user.is_superuser: gs = GlobalSettingsObject() if gs.settings.update_check_result_warning: ctx['warning_update_available'] = True if not gs.settings.update_check_ack and 'runserver' not in sys.argv: ctx['warning_update_check_active'] = True return ctx
def buildGraph(request): error_msg = '' if request.method == 'POST': form = BuildGraphForm(request.POST, request.FILES) # instantiating form if form.is_valid(): # Acquire proj names userDefProjectName = form.cleaned_data['UserDefprojectName'] site = form.cleaned_data['site'] subject = form.cleaned_data['subject'] session = form.cleaned_data['session'] scanId = form.cleaned_data['scanId'] # Private project error checking if (form.cleaned_data['Project_Type'] == 'private'): if not request.user.is_authenticated(): error_msg = "You must be logged in to make/alter a private project! Please Login or make/alter a public project." ''' # Untested TODO: Add join to ensure it a private project elif BuildGraphModel.objects.filter(owner=request.user, project_name=userDefProjectName, \ site=site, subject=subject, session=session, scanId=scanId).exists(): error_msg = "The scanID you requested to create already exists in this project path. Please change any of the form values." ''' # TODO DM: Many unaccounted for scenarios here! if error_msg: return render_to_response( 'buildgraph.html', { 'buildGraphform': form, 'error_msg': error_msg }, context_instance=RequestContext(request)) print "Uploading files..." # If a user is logged in associate the project with thier directory if form.cleaned_data['Project_Type'] == 'private': userDefProjectName = os.path.join(request.user.username, userDefProjectName) else: userDefProjectName = os.path.join('public', userDefProjectName) # Adapt project name if necesary on disk userDefProjectName = adaptProjNameIfReq( os.path.join(settings.MEDIA_ROOT, userDefProjectName) ) # Fully qualify AND handle identical projects request.session['usrDefProjDir'] = os.path.join( userDefProjectName, site, subject, session, scanId) request.session['scanId'] = scanId ''' Define data directory paths ''' request.session['derivatives'], request.session['rawdata'], request.session['graphs'],\ request.session['graphInvariants'],request.session['images']= defDataDirs(request.session['usrDefProjDir']) # Create a model object to save data to DB grModObj = BuildGraphModel( project_name=form.cleaned_data['UserDefprojectName']) grModObj.location = request.session[ 'usrDefProjDir'] # Where the particular scan location is grModObj.site = form.cleaned_data['site'] # set the site grModObj.subject = form.cleaned_data['subject'] # set the subject grModObj.session = form.cleaned_data['session'] # set the session grModObj.scanId = form.cleaned_data['scanId'] # set the scanId if request.user.is_authenticated(): grModObj.owner = request.user # Who created the project request.session['invariants'] = form.cleaned_data[ 'Select_Invariants_you_want_computed'] request.session['graphsize'] = form.cleaned_data[ 'Select_graph_size'] ''' Acquire fileNames ''' fiber_fn = form.cleaned_data[ 'fiber_file'].name # get the name of the file input by user roi_raw_fn = form.cleaned_data['roi_raw_file'].name roi_xml_fn = form.cleaned_data['roi_xml_file'].name print "Uploading files..." ''' Save files in appropriate location ''' saveFileToDisk( form.cleaned_data['fiber_file'], os.path.join(request.session['derivatives'], fiber_fn)) saveFileToDisk( form.cleaned_data['roi_raw_file'], os.path.join(request.session['derivatives'], roi_raw_fn)) saveFileToDisk( form.cleaned_data['roi_xml_file'], os.path.join(request.session['derivatives'], roi_xml_fn)) grModObj.save() # Save project data to DB after file upload # add entry to owned project if request.user.is_authenticated(): ownedProjModObj = OwnedProjects(project_name=grModObj.project_name, \ owner=grModObj.owner, is_private=form.cleaned_data['Project_Type'] == 'private') ownedProjModObj.save() print '\nSaving all files complete...' ''' Make appropriate dirs if they dont already exist ''' createDirStruct.createDirStruct([request.session['derivatives'], request.session['rawdata'],\ request.session['graphs'], request.session['graphInvariants'], request.session['images']]) # Redirect to Processing page return HttpResponseRedirect(get_script_prefix() + 'processinput') else: form = BuildGraphForm() # An empty, unbound form # Render the form return render_to_response( 'buildgraph.html', {'buildGraphform': form}, context_instance=RequestContext( request ) # Some failure to input data & returns a key signaling what is requested )
def urls_by_namespace(namespace, urlconf=None, args=None, kwargs=None, prefix=None, current_app=None): """ Return a dictionary containing the name together with the URL of all configured URLs specified for this namespace. """ if urlconf is None: urlconf = get_urlconf() resolver = get_resolver(urlconf) args = args or [] kwargs = kwargs or {} if prefix is None: prefix = get_script_prefix() if not namespace or not isinstance(namespace, six.string_types): raise AttributeError('Attribute namespace must be of type string') path = namespace.split(':') path.reverse() resolved_path = [] ns_pattern = '' while path: ns = path.pop() # Lookup the name to see if it could be an app identifier try: app_list = resolver.app_dict[ns] # Yes! Path part matches an app in the current Resolver if current_app and current_app in app_list: # If we are reversing for a particular app, # use that namespace ns = current_app elif ns not in app_list: # The name isn't shared by one of the instances # (i.e., the default) so just pick the first instance # as the default. ns = app_list[0] except KeyError: pass try: extra, resolver = resolver.namespace_dict[ns] resolved_path.append(ns) ns_pattern = ns_pattern + extra except KeyError as key: if resolved_path: raise NoReverseMatch( "%s is not a registered namespace inside '%s'" % (key, ':'.join(resolved_path))) else: raise NoReverseMatch("%s is not a registered namespace" % key) resolver = get_ns_resolver(ns_pattern, resolver) return dict( (name, iri_to_uri( resolver._reverse_with_prefix(name, prefix, *args, **kwargs))) for name in resolver.reverse_dict.keys() if (isinstance(name, six.string_types) and 'datasets-detail' not in name and 'swagger' not in name and 'organizations-detail' not in name and 'simple_api_test' not in name and 'data_files-mapping-suggestions' not in name))
# jquery url (defaults to pki/jquery-1.3.2.min.js) JQUERY_URL = getattr(settings, 'JQUERY_URL', 'pki/js/jquery-1.8.2.min.js') # logging (TODO: syslog, handlers and formatters) PKI_LOG = getattr(settings, 'PKI_LOG', os.path.join(PKI_DIR, 'pki.log')) PKI_LOGLEVEL = getattr(settings, 'PKI_LOGLEVEL', 'debug') # get other settings directly from settings.py: #ADMIN_MEDIA_PREFIX = getattr(settings, 'ADMIN_MEDIA_PREFIX') # media url STATIC_URL = getattr(settings, 'STATIC_URL') # base url: Automatically determined PKI_BASE_URL = getattr(settings, 'PKI_BASE_URL', get_script_prefix()) # self_signed_serial; The serial a self signed CA starts with. # Set to 0 or 0x0 for a random number PKI_SELF_SIGNED_SERIAL = getattr(settings, 'PKI_SELF_SIGNED_SERIAL', 0x0) # default key length: The pre-selected key length PKI_DEFAULT_KEY_LENGTH = getattr(settings, 'PKI_DEFAULT_KEY_LENGTH', 1024) # default_country: The default country selected (2-letter country code) PKI_DEFAULT_COUNTRY = getattr(settings, 'PKI_DEFAULT_COUNTRY', 'DE') # passphrase_min_length: The minimum passphrase length PKI_PASSPHRASE_MIN_LENGTH = getattr(settings, 'PKI_PASSPHRASE_MIN_LENGTH', 8) # enable graphviz_support: When True django-pki will render
def detail(request, event_id): e = get_object_or_404(models.Event, pk=event_id) context = {'event': e, 'slash': get_script_prefix()} return render_to_response("event.html", context)
def _convert(template, params=None): """URI template converter""" if params is None: params = [] paths = template % dict([p, "{{{0!s}}}".format(p)] for p in params) return u'/api{0!s}{1!s}'.format(get_script_prefix(), paths)
def build_url_template(viewname, kwargs=[], urlconf=None, prefix=None, current_app=None): resolver = get_resolver(urlconf) if prefix is None: prefix = get_script_prefix() kwargs = list(kwargs) parts = viewname.split(':') parts.reverse() view = parts[0] path = parts[1:] resolved_path = [] ns_pattern = '' while path: ns = path.pop() # Lookup the name to see if it could be an app identifier try: app_list = resolver.app_dict[ns] # Yes! Path part matches an app in the current Resolver if current_app and current_app in app_list: # If we are reversing for a particular app, # use that namespace ns = current_app elif ns not in app_list: # The name isn't shared by one of the instances # (i.e., the default) so just pick the first instance # as the default. ns = app_list[0] except KeyError: pass try: extra, resolver = resolver.namespace_dict[ns] resolved_path.append(ns) ns_pattern = ns_pattern + extra except KeyError as key: if resolved_path: raise NoReverseMatch( "%s is not a registered namespace inside '%s'" % (key, ':'.join(resolved_path))) else: raise NoReverseMatch("%s is not a registered namespace" % key) if ns_pattern: resolver = get_ns_resolver(ns_pattern, resolver) possibilities = resolver.reverse_dict.getlist(view) prefix_norm, prefix_args = normalize(prefix)[0] for entry in possibilities: if len(entry) == 3: possibility, pattern, defaults = entry else: possibility, pattern = entry defaults = {} for result, params in possibility: if set(kwargs + list(defaults)) != set(params + list(defaults) + prefix_args): continue unicode_kwargs = dict([(k, '%(' + force_text(k) + ')s') for k in kwargs]) unicode_kwargs.update(defaults) return (prefix_norm + result) % unicode_kwargs raise NoReverseMatch( "Reverse for '%s' with keyword arguments '%s' not found." % (viewname, kwargs))
def _get_urls_for_pattern(pattern, prefix='', namespace=None): urls = {} if prefix is '': prefix = get_script_prefix() if issubclass(pattern.__class__, RegexURLPattern): if settings.JS_URLS_UNNAMED: mod_name, obj_name = pattern.callback.__module__, pattern.callback.__name__ try: module = __import__(mod_name, fromlist=[obj_name]) obj = getattr(module, obj_name) func_name = "{0}.{1}".format(mod_name, obj_name) if isinstance( obj, types.FunctionType) else None pattern_name = pattern.name or func_name except: pattern_name = pattern.name else: pattern_name = pattern.name if pattern_name: if settings.JS_URLS and pattern_name not in settings.JS_URLS: return {} if settings.JS_URLS_EXCLUDE and pattern_name in settings.JS_URLS_EXCLUDE: return {} if namespace: pattern_name = ':'.join((namespace, pattern_name)) full_url = prefix + pattern.regex.pattern for char in ['^', '$']: full_url = full_url.replace(char, '') # remove optionnal non capturing groups opt_grp_matches = RE_OPT_GRP.findall(full_url) if opt_grp_matches: for match in opt_grp_matches: full_url = full_url.replace(match, '') # remove optionnal characters opt_matches = RE_OPT.findall(full_url) if opt_matches: for match in opt_matches: full_url = full_url.replace(match, '') # handle kwargs, args kwarg_matches = RE_KWARG.findall(full_url) if kwarg_matches: for el in kwarg_matches: # prepare the output for JS resolver full_url = full_url.replace(el[0], "<%s>" % el[1]) # after processing all kwargs try args args_matches = RE_ARG.findall(full_url) if args_matches: for el in args_matches: full_url = full_url.replace( el, "<>") # replace by a empty parameter name # Unescape charaters full_url = RE_ESCAPE.sub(r'\1', full_url) urls[pattern_name] = full_url elif (CMS_APP_RESOLVER) and (issubclass( pattern.__class__, AppRegexURLResolver)): # hack for django-cms for p in pattern.url_patterns: urls.update( _get_urls_for_pattern(p, prefix=prefix, namespace=namespace)) elif issubclass(pattern.__class__, RegexURLResolver): if pattern.urlconf_name: if pattern.namespace and not pattern.app_name: # Namespace without app_name nss = [pattern.namespace] else: # Add urls twice: for app and instance namespace nss = set((pattern.namespace, pattern.app_name)) for ns in nss: namespaces = [nsp for nsp in (namespace, ns) if nsp] namespaces = ':'.join(namespaces) if settings.JS_URLS_NAMESPACES and namespaces and namespaces not in settings.JS_URLS_NAMESPACES: continue if settings.JS_URLS_NAMESPACES_EXCLUDE and namespaces in settings.JS_URLS_NAMESPACES_EXCLUDE: continue new_prefix = '%s%s' % (prefix, pattern.regex.pattern) urls.update( _get_urls(pattern.urlconf_name, new_prefix, namespaces)) return urls
def contextprocessor(request): """ Adds data to all template contexts """ try: url = resolve(request.path_info) except Resolver404: return {} if not request.path.startswith(get_script_prefix() + 'control'): return {} ctx = { 'url_name': url.url_name, 'settings': settings, 'DEBUG': settings.DEBUG, } _html_head = [] if hasattr(request, 'event') and request.user.is_authenticated: for receiver, response in html_head.send(request.event, request=request): _html_head.append(response) ctx['html_head'] = "".join(_html_head) _js_payment_weekdays_disabled = '[]' _nav_event = [] if getattr(request, 'event', None) and hasattr( request, 'organizer') and request.user.is_authenticated: for receiver, response in nav_event.send(request.event, request=request): _nav_event += response if request.event.settings.get('payment_term_weekdays'): _js_payment_weekdays_disabled = '[0,6]' ctx['has_domain'] = request.event.organizer.domains.exists() if not request.event.live and ctx['has_domain']: child_sess = request.session.get('child_session_{}'.format( request.event.pk)) s = SessionStore() if not child_sess or not s.exists(child_sess): s['pretix_event_access_{}'.format( request.event.pk)] = request.session.session_key s.create() ctx['new_session'] = s.session_key request.session['child_session_{}'.format( request.event.pk)] = s.session_key request.session['event_access'] = True else: ctx['new_session'] = child_sess request.session['event_access'] = True if request.GET.get('subevent', ''): # Do not use .get() for lazy evaluation ctx['selected_subevents'] = request.event.subevents.filter( pk=request.GET.get('subevent')) ctx['nav_event'] = _nav_event ctx['js_payment_weekdays_disabled'] = _js_payment_weekdays_disabled _nav_global = [] if not hasattr(request, 'event') and request.user.is_authenticated: for receiver, response in nav_global.send(request, request=request): _nav_global += response ctx['nav_global'] = sorted(_nav_global, key=lambda n: n['label']) _nav_topbar = [] if request.user.is_authenticated: for receiver, response in nav_topbar.send(request, request=request): _nav_topbar += response ctx['nav_topbar'] = sorted(_nav_topbar, key=lambda n: n['label']) ctx['js_datetime_format'] = get_javascript_format('DATETIME_INPUT_FORMATS') ctx['js_date_format'] = get_javascript_format('DATE_INPUT_FORMATS') ctx['js_long_date_format'] = get_javascript_output_format('DATE_FORMAT') ctx['js_time_format'] = get_javascript_format('TIME_INPUT_FORMATS') ctx['js_locale'] = get_moment_locale() ctx['select2locale'] = get_language()[:2] if settings.DEBUG and 'runserver' not in sys.argv: ctx['debug_warning'] = True elif 'runserver' in sys.argv: ctx['development_warning'] = True ctx['warning_update_available'] = False ctx['warning_update_check_active'] = False gs = GlobalSettingsObject() ctx['global_settings'] = gs.settings if request.user.is_staff: if gs.settings.update_check_result_warning: ctx['warning_update_available'] = True if not gs.settings.update_check_ack and 'runserver' not in sys.argv: ctx['warning_update_check_active'] = True if request.user.is_authenticated: ctx['staff_session'] = request.user.has_active_staff_session( request.session.session_key) ctx['staff_need_to_explain'] = ( StaffSession.objects.filter( user=request.user, date_end__isnull=False).filter( Q(comment__isnull=True) | Q(comment="")) if request.user.is_staff and settings.PRETIX_ADMIN_AUDIT_COMMENTS else StaffSession.objects.none()) return ctx
def script_prefix(request): return { 'SCRIPT_PREFIX': get_script_prefix(), }
def process_request(self, request): url = resolve(request.path_info) url_name = url.url_name if not request.path.startswith(get_script_prefix() + 'control'): # This middleware should only touch the /control subpath return if hasattr(request, 'organizer'): # If the user is on a organizer's subdomain, he should be redirected to pretix return redirect(urljoin(settings.SITE_URL, request.get_full_path())) if url_name in self.EXCEPTIONS: return if not request.user.is_authenticated: # Taken from django/contrib/auth/decorators.py path = request.build_absolute_uri() # urlparse chokes on lazy objects in Python 3, force to str resolved_login_url = force_str( resolve_url(settings.LOGIN_URL_CONTROL)) # If the login url is the same scheme and net location then just # use the path as the "next" url. login_scheme, login_netloc = urlparse(resolved_login_url)[:2] current_scheme, current_netloc = urlparse(path)[:2] if ((not login_scheme or login_scheme == current_scheme) and (not login_netloc or login_netloc == current_netloc)): path = request.get_full_path() from django.contrib.auth.views import redirect_to_login return redirect_to_login(path, resolved_login_url, REDIRECT_FIELD_NAME) events = Event.objects.all( ) if request.user.is_superuser else request.user.events request.user.events_cache = events.order_by( "organizer", "date_from").prefetch_related("organizer") if 'event' in url.kwargs and 'organizer' in url.kwargs: try: if request.user.is_superuser: request.event = Event.objects.filter( slug=url.kwargs['event'], organizer__slug=url.kwargs['organizer'], ).select_related('organizer')[0] request.eventperm = EventPermission(event=request.event, user=request.user) else: request.event = Event.objects.filter( slug=url.kwargs['event'], permitted__id__exact=request.user.id, organizer__slug=url.kwargs['organizer'], ).select_related('organizer')[0] request.eventperm = EventPermission.objects.get( event=request.event, user=request.user) request.organizer = request.event.organizer except IndexError: raise Http404( _("The selected event was not found or you " "have no permission to administrate it.")) elif 'organizer' in url.kwargs: try: if request.user.is_superuser: request.organizer = Organizer.objects.filter( slug=url.kwargs['organizer'], )[0] request.orgaperm = OrganizerPermission( organizer=request.organizer, user=request.user) else: request.organizer = Organizer.objects.filter( slug=url.kwargs['organizer'], permitted__id__exact=request.user.id, )[0] request.orgaperm = OrganizerPermission.objects.get( organizer=request.organizer, user=request.user) except IndexError: raise Http404( _("The selected organizer was not found or you " "have no permission to administrate it."))
def default(request): return redirect(get_script_prefix() + 'welcome', {"user": request.user})
def fuzzy_reverse(viewname, urlconf=None, args=None, kwargs=None, prefix=None, current_app=None): """ from django/core/urlresolvers.py Unmodified reverse (just need to use our modified version of get_resolver) With the modified BRegexURLResolver retrieved through get_resolver this will not error when you pass in extra args (it assumes proper order and ignores trailing "extra" args) OR kwargs (it assumes you are passing at least the required keyworded arguments) It will still error if you pass both args AND kwargs at the same time. """ if urlconf is None: urlconf = get_urlconf() resolver = get_resolver(urlconf) args = args or [] kwargs = kwargs or {} if prefix is None: prefix = get_script_prefix() if not isinstance(viewname, basestring): view = viewname else: parts = viewname.split(':') parts.reverse() view = parts[0] path = parts[1:] resolved_path = [] ns_pattern = '' while path: ns = path.pop() # Lookup the name to see if it could be an app identifier try: app_list = resolver.app_dict[ns] # Yes! Path part matches an app in the current Resolver if current_app and current_app in app_list: # If we are reversing for a particular app, # use that namespace ns = current_app elif ns not in app_list: # The name isn't shared by one of the instances # (i.e., the default) so just pick the first instance # as the default. ns = app_list[0] except KeyError: pass try: extra, resolver = resolver.namespace_dict[ns] resolved_path.append(ns) ns_pattern = ns_pattern + extra except KeyError, e: if resolved_path: raise NoReverseMatch( "%s is not a registered namespace inside '%s'" % (e, ':'.join(resolved_path))) else: raise NoReverseMatch("%s is not a registered namespace" % e) if ns_pattern: resolver = get_ns_resolver(ns_pattern, resolver)
def obj_update(self, bundle, **kwargs): """ Update an object in CRITs. Should be overridden by each individual top-level resource. :returns: NotImplementedError if the resource doesn't override. """ import crits.actors.handlers as ah import crits.services.handlers as servh actions = { 'Common': { 'run_service': servh.run_service, }, 'Actor': { 'update_actor_tags': ah.update_actor_tags, 'attribute_actor_identifier': ah.attribute_actor_identifier, 'set_identifier_confidence': ah.set_identifier_confidence, 'remove_attribution': ah.remove_attribution, 'set_actor_name': ah.set_actor_name, 'update_actor_aliases': ah.update_actor_aliases, }, } prefix = get_script_prefix() uri = bundle.request.path if prefix and uri.startswith(prefix): uri = uri[len(prefix) - 1:] view, args, kwargs = resolve(uri) type_ = kwargs['resource_name'].title() if type_ == "Raw_data": type_ = "RawData" id_ = kwargs['pk'] content = {'return_code': 0, 'type': type_, 'message': '', 'id': id_} # Make sure we have an appropriate action. action = bundle.data.get("action", None) atype = actions.get(type_, None) if not atype: atype = actions.get('Common') action_type = atype.get(action, None) if action_type: data = bundle.data # Requests don't need to have an id_ as we will derive it from # the request URL. Override id_ if the request provided one. data['id_'] = id_ # Override type (if provided) data['type_'] = type_ # Override user (if provided) with the one who made the request. data['user'] = bundle.request.user.username try: results = action_type(**data) if not results.get('success', False): content['return_code'] = 1 # TODO: Some messages contain HTML and other such content # that we shouldn't be returning here. message = results.get('message', None) content['message'] = message else: content['message'] = "success!" except Exception, e: content['return_code'] = 1 content['message'] = str(e)
def shibboleth_session_auth(request): """Authenticate a session using Shibboleth. This allows Shibboleth to be one of many options for authenticating to the site. Instead of protecting the whole site via Shibboleth, we protect a single view (this view). The view will authenticate the user using the attributes passed in via request.META to authenticate the user. """ idp_attr = settings.SHIBBOLETH_SESSION_AUTH['IDP_ATTRIBUTE'] idp = request.META.get(idp_attr) if not idp: logger.error("IdP header missing (%s)", idp_attr) return HttpResponseBadRequest("Invalid response from IdP") if idp not in settings.SHIBBOLETH_SESSION_AUTH['AUTHORIZED_IDPS']: logger.info("Unauthorized IdP: %s", idp) return HttpResponseForbidden("unauthorized IdP: {}".format(idp)) user_attrs = {} for http_attr, user_attr, required in settings.SHIBBOLETH_SESSION_AUTH[ 'USER_ATTRIBUTES']: user_attrs[user_attr] = request.META.get(http_attr, None) if required and user_attrs[user_attr] is None: logger.error("SSO missing attribute: %s", user_attr) return HttpResponseBadRequest("Invalid response from IdP") try: user = User.objects.get(username=user_attrs['username']) except User.DoesNotExist: user = User(**user_attrs) user.set_unusable_password() user.save() idp_provided_group_names = [] if idp in settings.SHIBBOLETH_SESSION_AUTH['GROUPS_BY_IDP']: for group_name in settings.SHIBBOLETH_SESSION_AUTH['GROUPS_BY_IDP'][ idp]: idp_provided_group_names.append(group_name) try: group = Group.objects.get(name=group_name) except Group.DoesNotExist: logger.info( "creating group %s (locally configured for IdP %s)", group_name, idp) continue if group not in user.groups.all(): user.groups.add(group) logger.info("adding user %s to group %s", user.username, group.name) group_attr = settings.SHIBBOLETH_SESSION_AUTH['GROUP_ATTRIBUTE'] if group_attr in request.META: idp_group_names = request.META[group_attr].split(";") idp_provided_group_names.extend(idp_group_names) for group_name in idp_group_names: group, created = Group.objects.get_or_create(name=group_name) if created: logging.info("creating group %s (remotely provided by IdP %s)", group_name, idp) if group not in user.groups.all(): group.user_set.add(user) logger.info("adding user %s to group %s", user.username, group.name) user_groups = user.groups.all() for group in user_groups: if group.name not in idp_provided_group_names: group.user_set.remove(user) staff_group_name = settings.SHIBBOLETH_SESSION_AUTH['DJANGO_STAFF_GROUP'] if staff_group_name: is_staff_group_member = user.groups.filter( name=staff_group_name).count() > 0 if user.is_staff != is_staff_group_member: user.is_staff = is_staff_group_member user.save() user = authenticate(remote_user=user.username) login(request, user) if "next" in request.GET: redirect_target = request.GET['next'] else: redirect_target = get_script_prefix() return HttpResponseRedirect(redirect_target)
def get_redirect_from_path(self, path): # Remove our script_prefix from the path path = re.sub('^%s' % get_script_prefix(), '', path) # Append path to the redirect base return os.path.join(settings.REDIRECT_BASE, path)