def get_context_data(self, **kwargs):
# Get decisions
try:
decision1 = Decision.objects.select_related('job').get(
identifier=self.kwargs['decision1'])
decision2 = Decision.objects.select_related('job').get(
identifier=self.kwargs['decision2'])
except Decision.DoesNotExist:
raise BridgeException(
_("One of the selected decisions wasn't found"))
# Check jobs access
if not JobAccess(self.request.user, job=decision1.job).can_view\
or not JobAccess(self.request.user, job=decision2.job).can_view:
raise BridgeException(code=401)
# Get or create comparison cache
try:
comparison_info = CompareDecisionsInfo.objects.get(
decision1=decision1, decision2=decision2)
except CompareDecisionsInfo.DoesNotExist:
obj = FillComparisonCache(self.request.user, decision1, decision2)
comparison_info = obj.info
return {
'decision1':
decision1,
'decision2':
decision2,
'data':
ComparisonTableData(decision1,
decision2,
comparison_info=comparison_info)
}
def save(self, data):
if self._copy:
if not JobAccess(self._user).can_create():
raise BridgeException(_("You don't have an access to create new jobs"))
self.__create_job(data)
else:
if not JobAccess(self._user, self._job).can_edit():
raise BridgeException(_("You don't have an access to edit this job"))
self.__update_job(data)
return self._job
def get_context_data(self, **kwargs):
if not JobAccess(self.request.user,
self.object).can_clear_verifications():
raise BridgeException(
_("You can't remove verification files of this job"))
reports.utils.remove_verification_files(self.object)
return {}
def get_context_data(self, **kwargs):
if not JobAccess(self.request.user, self.object).klever_core_access():
raise BridgeException(
"User '%s' don't have access to upload report for job '%s'" %
(self.request.user.username, self.object.identifier))
if self.object.status != JOB_STATUS[2][0]:
raise BridgeException(
'Reports can be uploaded only for processing jobs')
archives = {}
for f in self.request.FILES.getlist('file'):
archives[f.name] = f
if 'report' in self.request.POST:
data = json.loads(self.request.POST['report'])
err = UploadReport(self.object, data, archives).error
if err is not None:
raise BridgeException(err)
elif 'reports' in self.request.POST:
data = json.loads(self.request.POST['reports'])
if not isinstance(data, list):
raise BridgeException('Wrong format of reports data')
for d in data:
err = UploadReport(self.object, d, archives).error
if err is not None:
raise BridgeException(err)
else:
raise BridgeException('Report json data is required')
return {}
def get_context_data(self, **kwargs):
if not JobAccess(self.request.user, self.object.root.job).can_view():
raise BridgeException(code=400)
try:
etv = GetETV(
ArchiveFileContent(self.object, 'error_trace',
ERROR_TRACE_FILE).content.decode('utf8'),
self.request.user)
except Exception as e:
logger.exception(e, stack_info=True)
etv = None
return {
'report':
self.object,
'report_type':
'unsafe',
'parents':
reports.utils.get_parents(self.object),
'SelfAttrsData':
reports.utils.report_attibutes(self.object),
'MarkTable':
ReportMarkTable(self.request.user, self.object,
self.get_view(VIEW_TYPES[10])),
'etv':
etv,
'include_assumptions':
self.request.user.extended.assumptions,
'include_jquery_ui':
True,
'resources':
reports.utils.get_leaf_resources(self.request.user, self.object)
}
def get_context_data(self, **kwargs):
if not JobAccess(self.request.user, self.object.root.job).can_view():
raise BridgeException(code=400)
proof_content = None
if self.object.proof:
proof_content = ArchiveFileContent(
self.object, 'proof', PROOF_FILE).content.decode('utf8')
return {
'report':
self.object,
'report_type':
'safe',
'parents':
reports.utils.get_parents(self.object),
'resources':
reports.utils.get_leaf_resources(self.request.user, self.object),
'SelfAttrsData':
reports.utils.report_attibutes(self.object),
'main_content':
proof_content,
'MarkTable':
ReportMarkTable(self.request.user, self.object,
self.get_view(VIEW_TYPES[11]))
}
def __accessed_changes(self, user):
reports_to_del = []
for report in self.changes:
if not JobAccess(user, report.root.job).can_view():
reports_to_del.append(report)
for report in reports_to_del:
del self.changes[report]
def get_context_data(self, **kwargs):
if not JobAccess(self.request.user, self.object.job).can_decide:
raise BridgeException(
_("You don't have an access to create job version"))
context = super(DecisionCopyFormPage, self).get_context_data(**kwargs)
decision_files = json.dumps(JSTreeConverter().make_tree(
list(
FileSystem.objects.filter(decision=self.object).values_list(
'name', 'file__hash_sum'))),
ensure_ascii=False)
other_decisions = Decision.objects.filter(job=self.object.job).order_by('id')\
.exclude(status=DECISION_STATUS[0][0]).only('id', 'title', 'start_date')
context.update({
'job':
self.object.job,
'unique_name':
get_unique_decision_name(self.object.job),
'base_decision':
self.object,
'cancel_url':
reverse('jobs:decision', args=[self.object.id]),
'files_data':
decision_files,
'start_data':
StartDecisionData(self.request.user, base_decision=self.object),
'other_decisions':
other_decisions
})
return context
def get_context_data(self, **kwargs):
if not JobAccess(self.request.user, self.object.decision.job).can_view:
raise BridgeException(code=400)
context = super().get_context_data(**kwargs)
if self.object.decision.weight == DECISION_WEIGHT[0][0]:
context['parents'] = get_parents(self.object)
context.update({
'report':
self.object,
'resources':
report_resources(self.request.user, self.object),
'SelfAttrsData':
self.object.attrs.order_by('id').values_list(
'id', 'name', 'value', 'data'),
'MarkTable':
SafeReportMarksTable(self.request.user, self.object,
self.get_view(VIEW_TYPES[11]))
})
# Get parent coverage if exists
cov_obj = CoverageArchive.objects.filter(
report_id=self.object.parent_id).first()
if cov_obj:
context['coverage'] = LeafCoverageStatistics(cov_obj)
return context
def get_context_data(self, **kwargs):
if not JobAccess(self.request.user, self.object.decision.job).can_view:
raise BridgeException(code=400)
context = super().get_context_data(**kwargs)
context.update({
'report':
self.object,
'resources':
report_resources(self.request.user, self.object),
'SelfAttrsData':
self.object.attrs.order_by('id').values_list(
'id', 'name', 'value', 'data'),
'main_content':
ArchiveFileContent(self.object, 'problem_description',
PROBLEM_DESC_FILE).content.decode('utf8'),
'MarkTable':
UnknownReportMarksTable(self.request.user, self.object,
self.get_view(VIEW_TYPES[12]))
})
# Get parent coverage if exists and parent is verification report
cov_obj = CoverageArchive.objects.filter(
report_id=self.object.parent_id,
report__verification=True).first()
if cov_obj:
context['coverage'] = LeafCoverageStatistics(cov_obj)
if self.object.decision.weight == DECISION_WEIGHT[0][0]:
context['parents'] = get_parents(self.object)
return context
def get_context_data(self, **kwargs):
job = self.object.root.job
if not JobAccess(self.request.user, job).can_view():
raise BridgeException(code=400)
return {
'report':
self.object,
'status':
reports.utils.ReportStatus(self.object),
'data':
reports.utils.ReportData(self.object),
'resources':
reports.utils.report_resources(self.object, self.request.user),
'computer':
reports.utils.computer_description(
self.object.computer.description),
'SelfAttrsData':
reports.utils.ReportAttrsTable(self.object).table_data,
'parents':
reports.utils.get_parents(self.object),
'reportdata':
ViewJobData(self.request.user, self.get_view(VIEW_TYPES[2]),
self.object),
'TableData':
reports.utils.ReportChildrenTable(self.request.user,
self.object,
self.get_view(VIEW_TYPES[3]),
page=self.request.GET.get(
'page', 1))
}
def get_context_data(self, **kwargs):
try:
decision1 = Decision.objects.select_related('job').get(
id=self.kwargs['decision1'])
decision2 = Decision.objects.select_related('job').get(
id=self.kwargs['decision2'])
except Decision.DoesNotExist:
raise BridgeException(
_("One of the selected decisions wasn't found"))
if not JobAccess(self.request.user, job=decision1.job).can_view\
or not JobAccess(self.request.user, job=decision2.job).can_view:
raise BridgeException(code=401)
return {
'decision1': decision1,
'decision2': decision2,
'data': ComparisonTableData(decision1, decision2)
}
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
if not JobAccess(self.request.user, self.object.root.job).can_view():
raise BridgeException(code=400)
tbl = reports.utils.UnknownsTable(self.request.user, self.object,
self.get_view(VIEW_TYPES[6]),
self.request.GET)
context.update({'report': self.object, 'TableData': tbl})
return context
def to_representation(self, instance):
if not isinstance(instance, JobHistory):
raise exceptions.APIException('Wrong serializer usage')
value = super().to_representation(instance)
if JobAccess(self.context['request'].user, instance.job).can_view:
value['href'] = reverse('jobs:job', args=[instance.job_id])
if len(value['comment']) > 50:
value['display_comment'] = value['comment'][:47] + '...'
return value
def get_generator(self):
self.object = self.get_object()
if not JobAccess(self.request.user, self.object.root.job).can_view():
return BridgeErrorResponse(400)
if not self.object.log:
raise BridgeException(_("The component doesn't have log"))
content = ArchiveFileContent(self.object, 'log', LOG_FILE).content
self.file_size = len(content)
return FileWrapper(BytesIO(content), 8192)
def has_object_permission(self, request, view, obj):
if isinstance(obj, Job):
job = obj
elif isinstance(obj, Decision):
job = obj.job
elif isinstance(obj, ReportComponent):
job = obj.decision.job
else:
return False
return JobAccess(request.user, job).can_view
def post(self, request, decision1, decision2):
try:
d1 = Decision.objects.select_related('job').get(id=decision1)
d2 = Decision.objects.select_related('job').get(id=decision2)
except Decision.DoesNotExist:
raise exceptions.APIException(
_('One of the decisions was not found'))
if not JobAccess(self.request.user, job=d1.job).can_view \
or not JobAccess(self.request.user, job=d2.job).can_view:
raise exceptions.PermissionDenied(
_("You don't have an access to one of the selected jobs"))
try:
CompareDecisionsInfo.objects.get(user=self.request.user,
decision1=d1,
decision2=d2)
except CompareDecisionsInfo.DoesNotExist:
FillComparisonCache(self.request.user, d1, d2)
return Response(
{'url': reverse('reports:comparison', args=[d1.id, d2.id])})
def __get_jobs_tree(self):
# Job order parameter
jobs_order = 'id'
if 'order' in self.view and len(self.view['order']) == 2:
if self.view['order'][1] == 'title':
jobs_order = 'name'
elif self.view['order'][1] == 'date':
jobs_order = 'change_date'
elif self.view['order'][1] == 'start':
jobs_order = 'solvingprogress__start_date'
elif self.view['order'][1] == 'finish':
jobs_order = 'solvingprogress__finish_date'
if self.view['order'][0] == 'up':
jobs_order = '-' + jobs_order
# Jobs tree structure
tree_struct = {}
for job in Job.objects.only('id', 'parent_id'):
tree_struct[job.id] = job.parent_id
# Filters for jobs
filters, unfilters = self.__view_filters()
filters = Q(**filters)
for unf_v in unfilters:
filters &= ~Q(**{unf_v: unfilters[unf_v]})
# Jobs' ids with view access
accessed = JobAccess(self._user).can_view_jobs(filters)
# Add parents without access to show the tree structure
jobs_in_tree = set(accessed)
for j_id in accessed:
parent = tree_struct[j_id]
while parent is not None:
jobs_in_tree.add(parent)
parent = tree_struct[parent]
# Get ordered list of jobs
jobs_list = list(j.id for j in Job.objects.filter(id__in=jobs_in_tree).order_by(jobs_order).only('id'))
# Function collects children tree for specified job id (p_id)
def get_job_children(p_id):
children = []
for oj_id in jobs_list:
if tree_struct[oj_id] == p_id:
children.append({'id': oj_id, 'parent': p_id})
children.extend(get_job_children(oj_id))
return children
# Get roots' ids for DB reqeusts optimizations
roots = dict((r_id, j_id) for r_id, j_id in ReportRoot.objects.filter(job_id__in=accessed)
.values_list('id', 'job_id'))
return get_job_children(None), accessed, roots
def get_generator(self):
self.object = self.get_object()
if not JobAccess(self.request.user,
self.object.report.root.job).can_view():
raise BridgeException(code=400)
if not self.object.data:
raise BridgeException(_("The attribute doesn't have data"))
content = self.object.data.file.read()
self.file_size = len(content)
return FileWrapper(BytesIO(content), 8192)
def has_object_permission(self, request, view, obj):
if request.user.is_manager or request.user.is_service:
return True
if isinstance(obj, Job):
job = obj
elif isinstance(obj, Decision):
job = obj.job
elif isinstance(obj, ReportComponent):
job = obj.decision.job
else:
return False
return JobAccess(request.user, job).is_author
def get_context_data(self, **kwargs):
if not JobAccess(self.request.user, self.object.decision.job).can_view:
raise BridgeException(code=400)
return {
'report':
self.object,
'include_jquery_ui':
True,
'etv':
GetETV(
ArchiveFileContent(self.object, 'error_trace',
ERROR_TRACE_FILE).content.decode('utf8'),
self.request.user)
}
def get_context_data(self, **kwargs):
if not JobAccess(self.request.user, self.object.root.job).can_view():
raise BridgeException(code=400)
if not self.object.log:
raise BridgeException(_("The component doesn't have log"))
content = ArchiveFileContent(self.object, 'log', LOG_FILE).content
if len(content) > 10**5:
content = str(
_('The component log is huge and can not be shown but you can download it'
))
else:
content = content.decode('utf8')
return {'content': content}
def get_context_data(self, **kwargs):
if not JobAccess(self.request.user, self.object.root.job).can_view():
raise BridgeException(code=400)
return {
'report':
self.object,
'include_assumptions':
self.request.user.extended.assumptions,
'etv':
GetETV(
ArchiveFileContent(self.object, 'error_trace',
ERROR_TRACE_FILE).content.decode('utf8'),
self.request.user)
}
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
# Check view access
context['job_access'] = JobAccess(self.request.user, self.object)
if not context['job_access'].can_view:
raise PermissionDenied(ERRORS[400])
context['parents'] = self.object.preset.get_ancestors(
include_self=True).only('id', 'name', 'type')
context['user_roles'] = UserRole.objects.filter(job=self.object).select_related('user')\
.order_by('user__first_name', 'user__last_name', 'user__username')
context['preset_changed'] = is_preset_changed(self.object)
context['decisions'] = Decision.objects.filter(job=self.object).exclude(status=DECISION_STATUS[0][0])\
.select_related('configuration').order_by('-start_date')
return context
def get_context_data(self, **kwargs):
if not JobAccess(self.request.user,
self.object.report.root.job).can_view():
raise BridgeException(code=400)
if not self.object.data:
raise BridgeException(_("The attribute doesn't have data"))
content = self.object.data.file.read()
if len(content) > 10**5:
content = str(
_('The attribute data is huge and can not be shown but you can download it'
))
else:
content = content.decode('utf8')
return {'content': content}
def get_generator(self):
instance = self.get_object()
decisions_ids = self.request.GET.getlist('decision')
if decisions_ids:
for decision in Decision.objects.filter(
job=instance, id__in=decisions_ids).select_related('job'):
if not DecisionAccess(self.request.user,
decision).can_download:
raise BridgeException(code=408,
back=reverse('jobs:job',
args=[instance.id]))
return JobArchiveGenerator(instance, decisions_ids)
if not JobAccess(self.request.user, instance).can_download:
raise BridgeException(code=400,
back=reverse('jobs:job', args=[instance.id]))
return JobArchiveGenerator(instance)
def get(self, request, pk):
assert pk
instance = self.get_object()
if not JobAccess(self.request.user,
instance.report.decision.job).can_view:
raise exceptions.PermissionDenied(
_("You don't have an access to the job"))
if not instance.data:
raise BridgeException(_("The attribute doesn't have data"))
content = instance.data.file.read()
if len(content) > 10**5:
content = str(
_('The attribute data is huge and can not be shown but you can download it'
))
else:
content = content.decode('utf8')
return HttpResponse(content)
def get_context_data(self, **kwargs):
if not JobAccess(self.request.user, self.object).can_decide:
raise BridgeException(
_("You don't have an access to create job version"))
context = super(DecisionFormPage, self).get_context_data(**kwargs)
preset_job = self.object.preset.get_ancestors(
include_self=True).filter(type=PRESET_JOB_TYPE[1][0]).first()
other_decisions = Decision.objects.filter(job=self.object).order_by('id')\
.exclude(status=DECISION_STATUS[0][0]).only('id', 'title', 'start_date')
context.update({
'job': self.object,
'unique_name': get_unique_decision_name(self.object),
'cancel_url': reverse('jobs:job', args=[self.object.id]),
'files_data': preset_job_files_tree_json(preset_job),
'current_conf': settings.DEF_KLEVER_CORE_MODE,
'start_data': StartDecisionData(self.request.user),
'other_decisions': other_decisions
})
return context
def get(self, request, *args, **kwargs):
self.object = self.get_object()
# Check job access
if not JobAccess(self.request.user, self.object.decision.job).can_view:
raise BridgeException(code=400)
# Get safes data
safes_data = SafesTable(self.request.user, self.object,
self.get_view(VIEW_TYPES[5]), self.request.GET)
# Get context
context = self.get_context_data(report=self.object)
# Redirect if needed
if hasattr(safes_data, 'redirect'):
return HttpResponseRedirect(safes_data.redirect)
context['TableData'] = safes_data
return self.render_to_response(context)
def get_jobs_to_download(user, job_ids, decision_ids):
jobs_qs_filter = Q()
if job_ids:
jobs_qs_filter |= Q(id__in=job_ids)
if decision_ids:
jobs_qs_filter |= Q(decision__id__in=decision_ids)
if not jobs_qs_filter:
raise BridgeException(
_("Please select jobs or/and decisions you want to download"),
back=reverse('jobs:tree'))
# Collect selected jobs
jobs_to_download = {}
for job in Job.objects.filter(jobs_qs_filter):
jobs_to_download[job.id] = {'instance': job, 'decisions': []}
if not jobs_to_download:
raise BridgeException(_("Jobs were not found"),
back=reverse('jobs:tree'))
# Collect selected decisions
for decision in Decision.objects.filter(
pk__in=decision_ids).select_related('job'):
if decision.job_id not in jobs_to_download:
# Unexpected behavior
continue
jobs_to_download[decision.job_id]['decisions'].append(decision.id)
if not DecisionAccess(user, decision).can_download:
raise BridgeException(
_("You don't have an access to one of the selected decisions"),
back=reverse('jobs:tree'))
# Check access to jobs without any selected decision (all decisions will be downloaded)
for job_id in jobs_to_download:
if not jobs_to_download[job_id]['decisions']:
if not JobAccess(
user, jobs_to_download[job_id]['instance']).can_download:
raise BridgeException(
_("You don't have an access to one of the selected jobs"),
back=reverse('jobs:tree'))
return jobs_to_download
