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)
