def _download_file(self, local_filename):
headers = {'User-Agent': 'DEQAR File Downloader'}
r = requests.get(self.url,
headers=headers,
stream=True,
allow_redirects=True)
if r.status_code == requests.codes.ok:
rf = ReportFile.objects.get(pk=self.report_file_id)
file_path = os.path.join(settings.MEDIA_ROOT, self.agency_acronym,
local_filename)
os.makedirs(os.path.dirname(file_path), exist_ok=True)
with open(file_path, 'wb') as f:
for chunk in r.iter_content(chunk_size=1024):
if chunk:
f.write(chunk)
self.saved_file_path = file_path
if rf.file_display_name == "":
rf.file_display_name = local_filename
rf.file.name = os.path.join(self.agency_acronym, local_filename)
rf.save()
flagger = ReportFlagger(rf.report)
flagger.check_and_set_flags()
def post(self, request):
# Save the highest institution id
try:
max_inst = Institution.objects.latest('id').id
except ObjectDoesNotExist:
max_inst = 0
submitted_reports = []
accepted_reports = []
response_contains_valid = False
csv_object = io.StringIO(request.data, newline=None)
csv_handler = CSVHandler(csvfile=csv_object)
csv_handler.handle()
# Tracking
client_ip, is_routable = get_client_ip(request)
tracker = SubmissionTracker(original_data=request.data,
origin='csv',
user_profile=request.user.deqarprofile,
ip_address=client_ip)
tracker.log_package()
if csv_handler.error:
pass
for data in csv_handler.submission_data:
serializer = SubmissionPackageSerializer(
data=data, context={'request': request})
if serializer.is_valid():
populator = Populator(data=serializer.validated_data,
user=request.user)
populator.populate()
flagger = ReportFlagger(report=populator.report)
flagger.check_and_set_flags()
tracker.log_report(populator, flagger)
submitted_reports.append(
self.make_success_response(populator, flagger))
accepted_reports.append(
self.make_success_response(populator, flagger))
response_contains_valid = True
else:
report_id = data.get('report_id', None)
submitted_reports.append(
self.make_error_response(serializer,
original_data={},
report_id=report_id))
if response_contains_valid:
send_submission_email.delay(
response=accepted_reports,
institution_id_max=max_inst,
total_submission=len(submitted_reports),
agency_email=request.user.email)
return Response(submitted_reports, status=status.HTTP_200_OK)
def perform_create(self, serializer):
report = serializer.save(created_by=self.request.user)
report.name = report.agency_esg_activity.activity + ' (by ' + report.agency.acronym_primary + ')'
report.save()
flagger = ReportFlagger(report=report)
flagger.check_and_set_flags()
client_ip, is_routable = get_client_ip(self.request)
tracker = SubmissionTracker(
original_data=self.request.data,
origin='form',
user_profile=self.request.user.deqarprofile,
ip_address=client_ip)
tracker.log_package()
def perform_update(self, serializer):
report = serializer.save()
flagger = ReportFlagger(report=report)
flagger.check_and_set_flags()
submit_comment = self.request.data.get('submit_comment', None)
if submit_comment:
ReportUpdateLog.objects.create(report=report,
note=submit_comment,
updated_by=self.request.user)
else:
ReportUpdateLog.objects.create(report=report,
note='Report updated',
updated_by=self.request.user)
def delete(self, request, *args, **kwargs):
report = Report.objects.get(id=kwargs.get('pk'))
flag = Flag.objects.get(flag='high level')
report_flag, created = ReportFlag.objects.get_or_create(
report=report,
flag=flag,
flag_message='Deletion was requested.',
)
if created or report_flag.active is False:
ReportUpdateLog.objects.create(report=report,
note='Deletion flag was assigned.',
updated_by=request.user)
report_flag.active = True
report_flag.removed_by_eqar = False
report_flag.save()
report_flagger = ReportFlagger(report=report)
report_flagger.set_flag()
index_delete_report.delay(report.id)
return Response(data={'OK'}, status=200)
def put(self, request, filename, pk, format=None):
file_obj = request.data['file']
filename = "%s_%s" % ((datetime.datetime.now().strftime("%Y%m%d_%H%M")), filename)
try:
report_file = ReportFile.objects.get(pk=pk)
agency_acronym = report_file.report.agency.acronym_primary
file_path = os.path.join(settings.MEDIA_ROOT, agency_acronym, filename)
os.makedirs(os.path.dirname(file_path), exist_ok=True)
with open(file_path, 'wb') as f:
for chunk in file_obj.chunks():
f.write(chunk)
report_file.file.name = os.path.join(agency_acronym, filename)
report_file.save()
# Recheck flags
flagger = ReportFlagger(report=report_file.report)
flagger.check_and_set_flags()
return Response(status=204)
except ObjectDoesNotExist:
return Response(status=404)
def test_check_programme_qf_ehea_level(self):
report = Report.objects.get(pk=1)
flagger = ReportFlagger(report=report)
flagger.check_programme_qf_ehea_level()
flagger.set_flag()
self.assertEqual(report.flag.flag, 'none', report.flag.flag)
prg = flagger.report.programme_set.first()
prg.qf_ehea_level = QFEHEALevel.objects.get(pk=4)
prg.save()
flagger.check_programme_qf_ehea_level()
report_flags = ReportFlag.objects.filter(report=report)
self.assertEqual(report_flags.first().flag.flag, 'high level',
report_flags.first().flag.flag)
msg = "QF-EHEA Level [third cycle] for programme [Verwaltung (B.A.)] " \
"should be in the institutions QF-EHEA level list."
self.assertEqual(report_flags.first().flag_message, msg,
report_flags.first().flag_message)
def test_check_ehea_is_member(self):
report = Report.objects.get(pk=1)
flagger = ReportFlagger(report=Report.objects.get(pk=1))
inst = flagger.report.institutions.first()
inst.set_primary_name()
inst.save()
ic = inst.institutioncountry_set.first()
ic.country.ehea_is_member = True
ic.country.save()
inst.institutionqfehealevel_set.all().delete()
flagger.check_ehea_is_member()
flagger.set_flag()
report_flags = ReportFlag.objects.filter(report=report)
self.assertEqual(report_flags.first().flag.flag, 'low level',
report_flags.first().flag.flag)
msg = "A record was created/identified for an institution " \
"(University of applied sciences for Public Administration Rhineland-Palatinate) in an " \
"EHEA member country (Germany) without including QF-EHEA levels."
self.assertEqual(report_flags.first().flag_message, msg,
report_flags.first().flag_message)
def test_check_countries(self):
report = Report.objects.get(pk=1)
flagger = ReportFlagger(report=Report.objects.get(pk=1))
inst = flagger.report.institutions.create(
website_link="https://www.kcl.ac.uk/")
inst.institutioncountry_set.create(country=Country.objects.get(
iso_3166_alpha2='GB'))
programme = flagger.report.programme_set.create(
name_primary="Programme", )
programme.countries.add(Country.objects.get(iso_3166_alpha2='BG'))
flagger.check_countries()
flagger.set_flag()
self.assertEqual(flagger.report.agency.agencyfocuscountry_set.count(),
15)
self.assertEqual(flagger.report.flag.flag, 'high level')
report_flags = ReportFlag.objects.filter(report=report)
self.assertEqual(report_flags.count(), 5, report_flags.count())
msg = "Institution country [United Kingdom] was not on a list as an Agency Focus country for [ACQUIN]."
self.assertEqual(report_flags.first().flag_message, msg,
report_flags.first().flag_message)
def post(self, request):
# Save the highest institution id
try:
max_inst = Institution.objects.latest('id').id
except ObjectDoesNotExist:
max_inst = 0
# Tracking
http_origin = request.META.get('HTTP_ORIGIN', None)
if http_origin:
if 'deqar.eu' in http_origin:
origin = 'form'
else:
origin = 'api'
else:
origin = 'api'
client_ip, is_routable = get_client_ip(request)
tracker = SubmissionTracker(original_data=request.data,
origin=origin,
user_profile=request.user.deqarprofile,
ip_address=client_ip)
tracker.log_package()
# Check if request is a list:
if isinstance(request.data, list):
submitted_reports = []
accepted_reports = []
response_contains_success = False
response_contains_error = False
for data in request.data:
serializer = SubmissionPackageSerializer(
data=data, context={'request': request})
if serializer.is_valid():
populator = Populator(data=serializer.validated_data,
user=request.user)
populator.populate()
flagger = ReportFlagger(report=populator.report)
flagger.check_and_set_flags()
tracker.log_report(populator, flagger)
submitted_reports.append(
self.make_success_response(populator, flagger))
accepted_reports.append(
self.make_success_response(populator, flagger))
response_contains_success = True
else:
submitted_reports.append(
self.make_error_response(serializer, data))
response_contains_error = True
if response_contains_success:
send_submission_email.delay(
response=accepted_reports,
institution_id_max=max_inst,
total_submission=len(submitted_reports),
agency_email=request.user.email)
if response_contains_error:
return Response(submitted_reports,
status=status.HTTP_400_BAD_REQUEST)
else:
return Response(submitted_reports, status=status.HTTP_200_OK)
# If request is not a list
else:
serializer = SubmissionPackageSerializer(
data=request.data, context={'request': request})
if serializer.is_valid():
populator = Populator(data=serializer.validated_data,
user=request.user)
populator.populate()
flagger = ReportFlagger(report=populator.report)
flagger.check_and_set_flags()
tracker.log_report(populator, flagger)
send_submission_email.delay(
response=[self.make_success_response(populator, flagger)],
institution_id_max=max_inst,
total_submission=1,
agency_email=request.user.email)
return Response(self.make_success_response(populator, flagger),
status=status.HTTP_200_OK)
else:
return Response(self.make_error_response(
serializer, request.data),
status=status.HTTP_400_BAD_REQUEST)
def recheck_flag(report):
report_flagger = ReportFlagger(report=report)
report_flagger.check_and_set_flags()
def test_check_report_file(self):
flagger = ReportFlagger(report=Report.objects.get(pk=1))
flagger.report.reportfile_set.create(file_display_name="Test File")
flagger.check_report_file()
flagger.set_flag()
self.assertEqual(flagger.report.flag.flag, 'low level')
def test_init(self):
flagger = ReportFlagger(report=Report.objects.get(pk=1))
self.assertEqual(flagger.report.agency.acronym_primary, "ACQUIN")