def download_documentversion(request, id):
documentversion = get_object_or_404(DocumentVersion, id=id)
if not default_storage.exists(default_storage.generate_filename(documentversion.uploaded_file.name)):
raise Http404()
return HttpResponseRedirect(documentversion.uploaded_file.url)
def detail(request, question_id):
try:
question = Question.objects.get(pk=question_id)
except Question.DoesNotExist:
raise Http404("Question does not exist")
return render(request, 'polls/detail.html', {'question': question})
def check_object_type(self):
"""Some views only apply to blobs, other to trees."""
logger.debug("check_object_type object=%s type=%s", self.object.hex,
self.object.type)
if self.object.type not in self.allowed_types:
raise Http404()
def edit_question(request, qid):
error = False
question = get_object_or_404(Question, id=qid)
survey = Engagement_Survey.objects.filter(questions__in=[question])
reverted = False
answered = []
if survey:
answered = Answered_Survey.objects.filter(survey__in=survey)
if answered.count() > 0:
messages.add_message(
request,
messages.ERROR,
'This question is part of an already answered survey. If you change it, the responses '
'may no longer be valid.',
extra_tags='alert-info')
type = str(ContentType.objects.get_for_model(question))
if type == 'dojo | text question':
form = EditTextQuestionForm(instance=question)
elif type == 'dojo | choice question':
form = EditChoiceQuestionForm(instance=question)
else:
raise Http404()
if request.method == 'POST':
if type == 'dojo | text question':
form = EditTextQuestionForm(request.POST, instance=question)
elif type == 'dojo | choice question':
form = EditChoiceQuestionForm(request.POST, instance=question)
else:
raise Http404()
if form.is_valid():
form.save()
for answered_survey in answered:
answered_survey.completed = False
answered_survey.answered_on = None
answered_survey.save()
reverted = True
if reverted:
messages.add_message(
request,
messages.SUCCESS,
'Answered surveys associated with this survey have been set to uncompleted.',
extra_tags='alert-warning')
messages.add_message(request,
messages.SUCCESS,
'Question updated successfully.',
extra_tags='alert-success')
return HttpResponseRedirect(reverse('questions'))
add_breadcrumb(title="Edit Question", top_level=False, request=request)
return render(request, 'defectDojo-engagement-survey/edit_question.html', {
'name': 'Edit Question',
'question': question,
'form': form
})
def wrapper(request, *args, **kwargs):
if request.journal is not None:
return func(request, *args, **kwargs)
else:
raise Http404()
def latest(self, request, *args, **kwargs):
meta_entries = self.get_queryset().order_by('-datetime')
if len(meta_entries) == 0:
raise Http404('There are no meta entries.')
latest_temperature = meta_entries[0]
return Response(self.get_serializer(latest_temperature).data)
def dispatch(self, request, *args, **kwargs):
try:
self.project = Project.objects.get(pk=self.kwargs['pk_project'])
return super().dispatch(request, *args, **kwargs)
except Project.DoesNotExist:
raise Http404("The project doesn't exists")
from django.conf.urls import include, url
from django.contrib import admin
from django.contrib.staticfiles.views import serve as staticfiles_serve
from django.http.response import Http404
from django.shortcuts import redirect
from django.views.defaults import page_not_found
urlpatterns = [
url('^admin/', include(admin.site.urls)),
url('^business-logic/', include('business_logic.urls')),
url('^business-logic/', lambda request: page_not_found(request, Http404())),
url('^books/', include('sites.dev.books.urls')),
# url('^(?P<path>static/.*)$', staticfiles_serve),
url('', lambda x: redirect('/books/book')),
]
def _check_player(self, request):
if self.get_object().account != request.user.account:
raise Http404(_('You can\'t delete this character.'))
def post(self, request, *args, **kwargs):
if not can_create_character(request.user):
raise Http404()
try:
world_id = kwargs['world_id']
world = World.objects.get(id=world_id)
except World.DoesNotExist:
messages.add_message(request, request.ERROR, "Invalid World")
return redirect('world:create_character')
try:
state_id = request.POST.get('state_id')
state = Organization.objects.get(id=state_id)
except Organization.DoesNotExist:
return self.fail_post_with_error(
request, world_id, "Select a valid state"
)
name = request.POST.get('name')
surname = request.POST.get('surname')
if name not in get_names() or surname not in get_surnames():
return self.fail_post_with_error(
request, world_id, "Select a valid name/surname"
)
profile = request.POST.get('profile')
if profile not in (choice[0] for choice in Character.PROFILE_CHOICES):
return self.fail_post_with_error(
request, world_id, "Select a valid profile"
)
character = Character.objects.create(
name=name + ' ' + surname,
world=world,
location=random.choice(
Settlement.objects.filter(
tile__in=state.get_all_controlled_tiles()
)
),
oath_sworn_to=state if state.leader is None else state.leader,
owner_user=request.user,
cash=100,
profile=profile
)
if character.profile == Character.TRADER:
InventoryItem.objects.create(
type=InventoryItem.CART,
quantity=5,
owner_character=character,
)
character.add_notification(
'welcome',
'<h4>Welcome, {char_name}!</h4>'
'<p>You are starting as a member of {state_link}, a realm in '
'<a href="{world_url}">{world_name}</a>.</p>'
'<p>A good way to start your journey is to write a message '
'to the other members of {state_link} asking for orders '
'or guidance on how you can be useful.</p>'
''.format(
char_name=character.name,
state_link=state.get_html_link(),
world_url=world.get_absolute_url(),
world_name=world.name
),
safe=True
)
state.character_members.add(character)
return redirect(character.activation_url)
def post(self, request, *args, **kwargs):
recruitment_type = request.POST.get('recruitment_type')
if recruitment_type in ('conscription', 'professional'):
if recruitment_type == 'conscription':
prefix = 'conscript_'
elif recruitment_type == 'professional':
prefix = 'professional_'
else:
raise Http404()
if not request.hero.can_conscript():
return RecruitmentView.fail_post_with_error(
request,
"You can't conscript units here."
)
# get soldier count
target_soldier_count = \
int(request.POST.get('{}count'.format(prefix)))
if not target_soldier_count > 0:
return RecruitmentView.fail_post_with_error(
request, "Invalid number of soldiers."
)
# check cash
if request.hero.cash < unit_cost(target_soldier_count):
return RecruitmentView.fail_post_with_error(
request,
"You need {} silver coins to recruit a unit of {} "
"and you don't have that much.".format(
target_soldier_count,
target_soldier_count
)
)
# calculate time
conscription_time = request.hero.location.conscription_time(
target_soldier_count
)
if request.hero.hours_in_turn_left < conscription_time:
return RecruitmentView.fail_post_with_error(
request,
"You need {} to recruit a unit of {}, but you don't have "
"that much time left in this turn.".format(
nice_hours(conscription_time),
target_soldier_count
)
)
# check unit type
unit_type = request.POST.get('{}unit_type'.format(prefix))
if unit_type not in WorldUnit.get_unit_types(nice=True):
return RecruitmentView.fail_post_with_error(
request, "Invalid unit type."
)
# check payment
"""
pay = int(request.POST.get('{}pay'.format(prefix)))
if pay not in range(1, 7):
return RecruitmentView.fail_post_with_error(
request, "Invalid payment."
)
if (
request.hero.worldunit_set.count() + 1 >
request.hero.max_units()
):
return RecruitmentView.fail_post_with_error(
request, "You can't recruit any more units."
)
"""
already_recruited_soldier_count = sum(
unit.soldier.count()
for unit in request.hero.worldunit_set.all()
)
if (
already_recruited_soldier_count + target_soldier_count >
request.hero.max_soldiers()
):
return RecruitmentView.fail_post_with_error(
request, "You can't recruit that many soldiers."
)
# get candidates
try:
candidates = build_population_query_from_request(
request, prefix, request.hero.location
)
except BadPopulation as e:
return RecruitmentView.fail_post_with_error(request, e)
if candidates.count() == 0:
return RecruitmentView.fail_post_with_error(
request,
"You seem unable to find anyone in {} matching the profile"
" you want".format(request.hero.location)
)
soldiers = sample_candidates(candidates, target_soldier_count)
unit = recruit_unit(
"{}'s new unit".format(request.hero),
request.hero,
request.hero.location,
soldiers,
recruitment_type,
unit_type
)
unit.mobilize()
request.hero.hours_in_turn_left -= conscription_time
request.hero.cash -= unit.monthly_cost()
request.hero.save()
messages.success(
request,
"You formed a new unit of {} called {}".format(
len(soldiers), unit.name
),
"success"
)
return redirect(unit.get_absolute_url())
else:
pass
def get_data(self):
config_list = self.config_list
if not config_list:
raise Http404()
if len(config_list) == 1:
config = config_list[0]
else:
config = {
'title': 'All',
'sections': self._get_collected_sections(config_list)
}
needed_data_sources = self._get_needed_data_sources(config)
data_sources = list()
months = [
dt.strftime("%b %Y")
for dt in rrule(MONTHLY,
dtstart=self.config['two_before'],
until=self.config['month'])
]
for data_source_name in needed_data_sources:
data_row = list()
for month in months:
selected_month = parse(month).date().replace(day=1)
month_config = self.config.copy()
month_config['month'] = selected_month
data_source = FACT_SHEET_DATASOURCES_NAMES[data_source_name](
config=month_config,
loc_level=self.loc_level,
show_test=self.show_test,
beta=self.beta)
data_row += data_source.get_data()
data_sources.append(data_row)
all_data = self._get_all_data(data_sources)
sql_location = self.config.get('sql_location')
for month in months:
data_for_month = False
active_location = True
month_data = {}
for row_data in all_data:
m = row_data['month'].strftime("%b %Y")
if sql_location is not None:
activation_date = sql_location.metadata.get(
'deprecates_at')
if activation_date:
activation_date = parse(activation_date).date()
if row_data['month'] < activation_date:
active_location = False
if month == m:
month_data = row_data
data_for_month = True
for section in config['sections']:
section['months'] = months
for row in section['rows_config']:
if 'data' not in row:
row['data'] = [{'html': row['header']}]
if data_for_month:
row['data'].append((month_data[row['slug']] or {
'html': 0
}))
elif not active_location:
row['data'].append({'html': '---'})
else:
row['data'].append({'html': 0})
if 'average' in row:
data = get_data_for_national_aggregatation(
self.config['domain'],
self.config['previous_month'].strftime('%Y-%m-%d'),
row['data_source'], self.loc_level, self.show_test,
self.beta)
row['average'] = data[0][row['slug']] if data else ''
return {'config': config}
def dummy_view(request):
raise Http404()
def get_redirect_url(self, *args, **kwargs):
school = self.get_object()
url = school.picture
if url:
return url
raise Http404()
def daq_controller(request, daq_host, parent_namespace, controller_namespace):
daq_controller = None
controllers = DAQController.objects.filter(name=controller_namespace)
# controllers = get_object_or_404(DAQController, name=controller_namespace)
# get_object_or_404(controllers)
for controller in controllers:
ns = controller.get_namespace()
parent_sig = ns.get_namespace_sig(section="PARENT")
if (
parent_sig["host"] == daq_host
and parent_sig["namespace"] == parent_namespace
):
daq_controller = controller
controller_ns = ns
break
if not daq_controller:
raise Http404(f"DAQController {controller_namespace} not found")
measurements = daq_controller.measurement_sets
# server_sig = controller_ns.get_namespace_comp_sig()
plotserver_sig = PlotManager.get_server(server_id=ns).get_sig()
plotserver_host = plotserver_sig["host"]
plotserver_port = plotserver_sig["port"]
print(f"plotserver_sig: {plotserver_sig}")
plotserver_ui_host = plotserver_host
if 'ui_host' in settings.PLOT_SERVER:
plotserver_ui_host = settings.PLOT_SERVER['ui_host']
request_host = request.get_host().split(":")[0]
if request_host != plotserver_ui_host:
plotserver_ui_host = request_host
# host = 'localhost'
# port = 5001
# if 'server_id' in settings.PLOT_SERVER:
# host = settings.PLOT_SERVER['server_id'][0]
# port = settings.PLOT_SERVER['server_id'][1]
# if 'hostname' in settings.PLOT_SERVER:
# host = settings.PLOT_SERVER['hostname']
# test_host = request.get_host()
print(f"++++ hosts: {plotserver_host}:{plotserver_port}, {plotserver_ui_host}:{plotserver_port}")
plots = dict()
# plots["host"] = host
# plots["port"] = port
plots["host"] = plotserver_ui_host
plots["port"] = plotserver_port
plots["name"] = "/controller_"+daq_controller.name
# print(f"views plots: {plots}, {host}, {port}, {plotserver_host}, {plotserver_port}")
# print(f'{PlotManager.get_app_list(ctr.alias_name)}')
plots["app_list"] = PlotManager.get_app_list(daq_controller.name)
plot_scripts = []
for app in plots['app_list']:
plot_scripts.append(
# server_document(f"http://{host}:{port}"+app)
server_document(f"http://{plotserver_ui_host}:{plotserver_port}"+app)
)
# plot_script = server_document("http://localhost:5001"+plots["name"])
# print(f'plot_script: {plot_script}')
# print(f'565656 plot_scripts: {plot_scripts}')
# print(f'controller_name: {mark_safe(json.dumps(ctr.name))}')
context = {
'daq_host': mark_safe(daq_host),
'parent_namespace': mark_safe(parent_namespace),
# 'daq_namespace': mark_safe(json.dumps(daq_namespace)),
'controller_namespace': mark_safe(controller_namespace),
'controller_display_name': mark_safe(daq_controller.name),
'controller_name': mark_safe(json.dumps(daq_controller.name)),
'controller_label': mark_safe(json.dumps(daq_controller.name)),
'controller_measurements': mark_safe(
json.dumps(measurements)
),
'plot_app': mark_safe(json.dumps(plots)),
# 'plot_scriocat': plot_script,
'plot_scripts': plot_scripts,
}
return render(request, 'envdaq/controller.html', context=context)
def image(request, path, token, autogen=False):
is_admin = False
if ("is_admin=true" in token and request
and request.user.has_perm('admin')) or autogen:
parameters = token
is_admin = True
if autogen:
token = image_create_token(parameters)
else:
parameters = request.session.get(token, token)
cached_image_file = os.path.join(path, token)
now = timezone.now()
expire_offset = timezone.timedelta(seconds=IMAGE_CACHE_HTTP_EXPIRATION)
response = HttpResponse()
response['Content-type'] = 'image/jpeg'
response['Expires'] = (now + expire_offset).strftime("%a, %d %b %Y %T GMT")
response['Last-Modified'] = now.strftime("%a, %d %b %Y %T GMT")
response['Cache-Control'] = 'max-age=3600, must-revalidate'
response.status_code = 200
# If we already have the cache we send it instead of recreating it
if IMAGE_CACHE_STORAGE.exists(cached_image_file):
if autogen:
return 'Already generated'
try:
f = IMAGE_CACHE_STORAGE.open(cached_image_file, "r")
except IOError:
raise Http404()
response.write(f.read())
f.close()
response['Last-Modified'] = IMAGE_CACHE_STORAGE.modified_time(
cached_image_file).strftime("%a, %d %b %Y %T GMT")
return response
if parameters == token and not is_admin:
return HttpResponse("Forbidden", status=403)
qs = QueryDict(parameters)
file_storage = MEDIA_STORAGE
if qs.get('static', '') == "true":
file_storage = STATIC_STORAGE
format = qs.get('format', IMAGE_DEFAULT_FORMAT)
quality = int(qs.get('quality', IMAGE_DEFAULT_QUALITY))
mask = qs.get('mask', None)
mask_source = qs.get('mask_source', None)
if mask is not None:
format = "PNG"
fill = qs.get('fill', None)
background = qs.get('background', None)
tint = qs.get('tint', None)
center = qs.get('center', ".5,.5")
mode = qs.get('mode', "crop")
enlarge = qs.get('enlarge', "true")
overlays = qs.getlist('overlay')
overlay_sources = qs.getlist('overlay_source')
overlay_tints = qs.getlist('overlay_tint')
overlay_sizes = qs.getlist('overlay_size')
overlay_positions = qs.getlist('overlay_position')
width = qs.get('width', None)
if width:
width = int(width)
height = qs.get('height', None)
if height:
height = int(height)
pre_rotation = qs.get('pre_rotation', None)
post_rotation = qs.get('post_rotation', None)
try:
padding = float(qs.get('padding', None))
except TypeError:
padding = 0.0
grayscale = bool(qs.get('grayscale', False))
if "video" in qs:
data, http_response = generate_thumb(file_storage, smart_unicode(path))
response.status_code = http_response
else:
try:
try:
f = urllib.urlopen(qs['url'])
data = f.read()
f.close()
except KeyError:
f = file_storage.open(path)
data = f.read()
f.close()
except IOError:
response.status_code = 404
data = ""
if data:
try:
crop = (mode != "scale")
force = (enlarge == "true")
print force
output_data = render(data,
width,
height,
force=force,
padding=padding,
overlays=overlays,
overlay_sources=overlay_sources,
overlay_tints=overlay_tints,
overlay_positions=overlay_positions,
overlay_sizes=overlay_sizes,
mask=mask,
mask_source=mask_source,
center=center,
format=format,
quality=quality,
fill=fill,
background=background,
tint=tint,
pre_rotation=pre_rotation,
post_rotation=post_rotation,
crop=crop,
grayscale=grayscale)
except IOError:
traceback.print_exc()
response.status_code = 500
output_data = ""
else:
output_data = data
if response.status_code == 200:
IMAGE_CACHE_STORAGE.save(cached_image_file, ContentFile(output_data))
if autogen:
return 'Generated ' + str(response.status_code)
else:
if autogen:
return 'Failed ' + cached_image_file
response.write(output_data)
return response
def teams(request,code):
itr_temp = 0
for team in td.TEAMS:
if(team == code):
return render(request,'CPL/teams.html',{'team':td.TEAMS[team],'name':team,'letter':int(team,2)})
raise Http404('Invalid Team ID')
def dispatch(self, request, *args, **kwargs):
if not self.request.couch_user.is_web_user():
raise Http404()
return super(SupervisionDocumentView,
self).dispatch(request, *args, **kwargs)
def get_queryset(self):
try:
self.project = Project.objects.get(pk=self.kwargs['pk_project'])
return Module.objects.filter(project=self.project)
except Project.DoesNotExist:
raise Http404("The project doen't exists")
def dispatch(self, request, *args, **kwargs):
if not self.request.couch_user.is_domain_admin():
raise Http404()
return super(PendingRecalculationsListView,
self).dispatch(request, *args, **kwargs)
def detalhes(request, contato_id):
#contato = Contato.objects.get(id=contato_id)
contato = get_object_or_404(Contato, id=contato_id)
if not contato.mostrar:
raise Http404()
return render(request, 'contatos/detalhes.html', {'contato': contato})
def dispatch(self, request, *args, **kwargs):
if not self.request.couch_user.is_domain_admin():
raise Http404()
return super(ReportRunDeleteView,
self).dispatch(request, *args, **kwargs)
def show_404(request):
raise Http404()
def get_form_class(self):
policy_cls = GRADING_POLICY_NAME_TO_CLS.get(
self.request.GET.get('grading_policy'), None)
if policy_cls is None:
raise Http404("No such grading policy")
return policy_cls.get_form_class()
def notfound_view(request, *args, **kwargs):
raise Http404("Ops!")
def page_title(self):
if not self.static_toggle:
raise Http404()
return self.static_toggle.label
def get_object(self, queryset=None):
try:
obj = DeveloperSkill.objects.get(id=self.kwargs['skill_id'])
return obj
except ObjectDoesNotExist:
raise Http404("No object found matching this query")
def daq_instrument(request, daq_host, parent_namespace, instrument_namespace):
daq_instrument = None
instruments = DAQInstrument.objects.filter(name=instrument_namespace)
# controllers = get_object_or_404(DAQController, name=controller_namespace)
# get_object_or_404(instruments)
for instrument in instruments:
ns = instrument.get_namespace()
parent_sig = ns.get_namespace_sig(section="PARENT")
if (
parent_sig["host"] == daq_host
and parent_sig["namespace"] == parent_namespace
):
daq_instrument = instrument
break
if not daq_instrument:
raise Http404(f"DAQInstrument {instrument_namespace} not found")
measurements = daq_instrument.measurement_sets
# server_sig = controller_ns.get_namespace_comp_sig()
plotserver_sig = PlotManager.get_server(server_id=ns).get_sig()
plotserver_host = plotserver_sig["host"]
plotserver_port = plotserver_sig["port"]
print(f"plotserver_sig: {plotserver_sig}")
plotserver_ui_host = plotserver_host
if 'ui_host' in settings.PLOT_SERVER:
plotserver_ui_host = settings.PLOT_SERVER['ui_host']
request_host = request.get_host().split(":")[0]
if request_host != plotserver_ui_host:
plotserver_ui_host = request_host
# host = 'localhost'
# port = 5001
# if 'server_id' in settings.PLOT_SERVER:
# host = settings.PLOT_SERVER['server_id'][0]
# port = settings.PLOT_SERVER['server_id'][1]
# if 'hostname' in settings.PLOT_SERVER:
# host = settings.PLOT_SERVER['hostname']
print(f"++++ hosts: {plotserver_host}:{plotserver_port}, {plotserver_ui_host}:{plotserver_port}")
plots = dict()
# plots["host"] = host
# plots["port"] = port
plots["host"] = plotserver_ui_host
plots["port"] = plotserver_port
plots["name"] = "/instrument_"+daq_instrument.name
# TODO: these values need to got into database as runtime
# data?
# print(f'{PlotManager.get_app_list(alias.name)}')
plots["app_list"] = PlotManager.get_app_list(daq_instrument.name)
# print(f'{plots["app_list"]}')
plot_scripts = []
for app in plots['app_list']:
plot_scripts.append(
# server_document(f"http://{host}:{port}"+app)
server_document(f"http://{plotserver_ui_host}:{plotserver_port}"+app)
)
# TODO: get plot name dynamically
# plot_script = server_document(f"http://{host}:{port}"+plots["name"])
plot_script = server_document(f"http://{plotserver_ui_host}:{plotserver_port}"+plots["name"])
print(f'plot_scripts: {plot_scripts}')
context = {
# 'daq_namespace': mark_safe(json.dumps(daq_namespace)),
# 'controller_namespace': mark_safe(json.dumps(controller_namespace)),
'daq_host': mark_safe(daq_host),
'parent_namespace': mark_safe(parent_namespace),
'instrument_namespace': mark_safe(instrument_namespace),
'instrument_instance': mark_safe(
json.dumps(f"{instrument.instrument}")
),
'instrument_name': mark_safe(json.dumps(instrument_namespace)),
'instrument_label': mark_safe(json.dumps(daq_instrument.name)),
'instrument_prefix': mark_safe(json.dumps(daq_instrument.name)),
'instrument_measurements': mark_safe(
json.dumps(measurements)
),
'plot_app': mark_safe(json.dumps(plots)),
'plot_script': plot_script,
'plot_scripts': plot_scripts,
}
# print(f'context: {context}')
return render(request, 'envdaq/instrument.html', context=context)
def inbox_detail(request, id):
if not inbox_models.InboxMessage.objects.filter(id=id).exists():
return Http404()
inbox_message = inbox_models.InboxMessage.objects.get(id=id)
return render(request, "userinfo/inbox.html",
{"inbox_message": inbox_message})
def get_object(self, queryset=None):
obj = super(DetailView, self).get_object()
if self.model.objects.vireficate_art(self.request.user,
obj.pk) == None:
raise Http404('Вы не принадлижите этой группе;)')
return obj
