def forms_valid(self, form, inlines):
if self.duplicate:
return self.form_invalid(form)
user = self.request.user
form.instance.joboffer_added_by = user
form.instance.joboffer_modified_by = user
form.instance.joboffer_position = remove_unnecessary_tags_from_title(
form.instance.joboffer_position)
form.instance.joboffer_position_text = strip_tags(
form.instance.joboffer_position)
form.instance.joboffer_position_slug = slugify_text_title(
form.instance.joboffer_position_text)
response = super(JobOfferCreateView, self).forms_valid(form, inlines)
modification = JobOfferModification.objects.create(
joboffer=self.object, user=user, date_time=timezone.now())
profile = UserProfile.objects.get(user=user)
for institution in profile.user_institution.all():
JobOfferAuthorized.objects.create(joboffer=self.object,
authorized=institution)
profile.user_last_edit_date_time = modification.date_time
profile.save()
change_message = self.construct_change_message(form, inlines, True)
reversion.set_comment(change_message)
return response
def get_or_create_institution_object(self, institution_name, parent=None):
institution = None
dict_key = institution_name
if parent is not None:
dict_key = dict_key + parent.institution_shortname
institution_key = ImportHelper.create_dict_key(dict_key)
if (institution_key not in self.institutions_dict):
# truncator add tree dots at the end and do smth else
inst_shortname = Truncator(
ImportHelper.create_shortname(institution_name)).chars(32)
inst_slug = slugify_text_title(inst_shortname)
if parent:
institution = Institution.objects.create(
institution_shortname=inst_shortname,
institution_fullname=institution_name,
institution_slug=inst_slug,
institution_parent=parent)
else:
institution = Institution.objects.create(
institution_shortname=inst_shortname,
institution_fullname=institution_name,
institution_slug=inst_slug)
self.institutions_dict[institution_key] = institution
logger.info(self.LOG_MSG_SUCC_DATABASE_CREATE_INST +
'get_or_create_institution_object institution_name=' +
institution_name + ' institution_id=' +
str(institution.institution_id))
import_report.info(';'.join((self.REPORT_INSTITUTION_CREATED,
str(institution.institution_id), '',
'', '', institution_name)))
else:
institution = self.institutions_dict[institution_key]
return institution
def save_model(self, request, obj, form, change):
obj.journal_title = remove_unnecessary_tags_from_title(
obj.journal_title)
obj.journal_title_text = strip_tags(obj.journal_title)
obj.journal_title_slug = slugify_text_title(obj.journal_title_text)
super(VersionAdmin, self).save_model(request, obj, form, change)
def before_import_row(self, row, **kwargs):
# get scientific title instance
row_person_title = row.get(self.COLUMN_PERSON_TITLE, '')
row[self.
COLUMN_PERSON_TITLE] = self.person_import_helper.get_scientific_title(
row_person_title)
# get person_id using opi_id
row_person_opi_id = row.get(self.COLUMN_PERSON_OPI_ID, '')
person_id = self.person_import_helper.get_person_id(row_person_opi_id)
row[self.COLUMN_PERSON_ID] = person_id
# get person_institutions
row_person_institutions = row.get(self.COLUMN_PERSON_INSTITUTIONS, '')
self.institutions = self.person_import_helper.get_institutions(
row_person_institutions)
row[self.
COLUMN_PERSON_INSTITUTIONS] = None # it will be set in after_save_instance method
# get person_disciplines
row_person_disciplines = row.get(self.COLUMN_PERSON_KBN, '')
self.disciplines = self.person_import_helper.get_disciplines(
row_person_disciplines)
row[self.
COLUMN_PERSON_KBN] = None # it will be set in after_save_instance method
# get person_slug
fname = row.get(self.COLUMN_PERSON_FIRST_NAME, '')
lname = row.get(self.COLUMN_PERSON_LAST_NAME, '')
row[self.COLUMN_PERSON_SLUG] = slugify_text_title(fname + ' ' + lname)
[person_key_exist, person_duplicate_id
] = self.person_import_helper.check_person_name(fname, lname)
if person_key_exist:
if person_id == person_duplicate_id:
logger.warning(
'Person update. Found person with the same id: person_name='
+ fname + ' ' + lname + ' person_id=' + str(person_id))
import_report.warning(';'.join(
(self.REPORT_PERSON_UPDATE, str(person_id), fname, lname,
row_person_opi_id)))
else:
import_report.warning(';'.join(
(self.REPORT_PERSON_NEW_EXIST_DUPLICATES, str(person_id),
fname, lname, row_person_opi_id)))
import_report.warning(';'.join(
(self.REPORT_PERSON_DUPLICATE, str(person_duplicate_id))))
logger.warning(self.LOG_MSG_DUPLICATE_OBJECT)
logger.warning('Existing object: person_fist_name=' + fname +
' person_last_name=' + lname + ' person_id=' +
str(person_id))
logger.warning('Duplicate object: ' + ' person_id=' +
str(person_duplicate_id))
else:
import_report.info(';'.join(
(self.REPORT_PERSON_NEW, str(person_id), fname, lname,
row_person_opi_id)))
return super(PersonResource, self).before_import_row(row, **kwargs)
def forms_valid(self, form, inlines):
if self.duplicate:
return self.forms_invalid(form, inlines)
if self.is_popup():
self.success_url = '/'
form.instance.person_slug = slugify_text_title(form.instance.person_first_name + ' ' + form.instance.person_last_name)
response = super(PersonCreateView, self).forms_valid(form, inlines)
change_message = self.construct_change_message(form, inlines, True)
reversion.set_comment(change_message)
if self.is_popup():
return self.respond_script(self.object)
else:
return response
def forms_valid(self, form, inlines):
user = self.request.user
form.instance.new_modified_by = user
form.instance.new_date_edit = timezone.now()
form.instance.new_title = remove_unnecessary_tags_from_title(form.instance.new_title)
form.instance.new_title_text = strip_tags(form.instance.new_title)
form.instance.new_title_slug = slugify_text_title(form.instance.new_title_text)
response = super(NewUpdateView, self).forms_valid(form, inlines)
modification = NewModification.objects.create(new=self.object, user=user, date_time=timezone.now())
profile = UserProfile.objects.get(user=user)
profile.user_last_edit_date_time = modification.date_time
profile.save()
change_message = self.construct_change_message(form, inlines, False)
reversion.set_comment(change_message)
return response
def get_dissertation_data(self, row):
# get dissertation_institutions
row_dissertation_institutions = row.get(self.COLUMN_DISSERTATION_INSTITUTION, '')
if not isinstance(row_dissertation_institutions, int):
institutions = self.dissertation_import_helper.get_institutions(row_dissertation_institutions)
row[self.COLUMN_DISSERTATION_INSTITUTION] = institutions[0].institution_id if institutions is not None and len(institutions) > 0 else None
# get dissertation_title ant title_slug
row_dissertation_opi_id = row.get(self.COLUMN_DISSERTATION_OPI_ID, '')
row_dissertation_title = row.get(self.COLUMN_DISSERTATION_TITLE, '')
text_title = strip_tags(row_dissertation_title)
row[self.COLUMN_DISSERTATION_TITLE_TEXT] = text_title
row[self.COLUMN_DISSERTATION_TITLE_SLUG] = slugify_text_title(text_title)
row[self.COLUMN_DISSERTATION_TITLE] = row_dissertation_title
# get date
date_start = row[self.COLUMN_DISSERTATION_DATE_START]
row[self.COLUMN_DISSERTATION_DATE_START] = ImportHelper.create_date_isoformat(date_start)
date_end = row[self.COLUMN_DISSERTATION_DATE_END]
row[self.COLUMN_DISSERTATION_DATE_END] = ImportHelper.create_date_isoformat(date_end)
# get type
row_dissertation_type = row[self.COLUMN_DISSERTATION_TYPE]
dissertation_type = self.dissertation_import_helper.get_dissertation_type(row_dissertation_type)
row[self.COLUMN_DISSERTATION_TYPE] = dissertation_type
# check for duplicates
[dissertation_key_exist, dissertation_duplicate_id] = self.dissertation_import_helper.check_dissertation_title(text_title)
dissertation_id = row[self.COLUMN_DISSERTATION_ID]
if dissertation_key_exist:
if dissertation_id == dissertation_duplicate_id:
logger.warning('Dissertation update. Found dissertation with the same id: dissertation_title=' + text_title + ' dissertation_id=' + str(dissertation_id))
import_report.warning(';'.join((self.REPORT_DISSERTATION_UPDATE, str(dissertation_id), text_title, row_dissertation_opi_id)))
elif dissertation_id is not None:
import_report.warning(';'.join((self.REPORT_DISSERTATION_NEW_EXIST_DUPLICATES, str(dissertation_id), text_title, row_dissertation_opi_id)))
import_report.warning(';'.join((self.REPORT_DISSERTATION_DUPLICATE, str(dissertation_duplicate_id))))
logger.warning(self.LOG_MSG_DUPLICATE_OBJECT)
logger.warning('Existing object: dissertation_title=' + text_title + ' dissertation_id=' + str(dissertation_id))
logger.warning('Duplicate object: ' + ' dissertation_id=' + str(dissertation_duplicate_id))
else:
import_report.info(';'.join((self.REPORT_DISSERTATION_NEW, str(dissertation_id), text_title, row_dissertation_opi_id)))
return row
def save_model(self, request, obj, form, change):
if obj.dissertation_added_by is None:
obj.dissertation_added_by = request.user
obj.dissertation_modified_by = request.user
obj.dissertation_title = remove_unnecessary_tags_from_title(obj.dissertation_title)
obj.dissertation_title_text = strip_tags(obj.dissertation_title)
obj.dissertation_title_slug = slugify_text_title(obj.dissertation_title_text)
super(VersionAdmin, self).save_model(request, obj, form, change)
modification = DissertationModification.objects.create(dissertation=obj, user=request.user, date_time=timezone.now())
profile = UserProfile.objects.get(user=request.user)
authorized = DissertationAuthorized.objects.filter(dissertation=obj);
if not authorized.exists() :
institutions = profile.user_institution.all()
for institution in institutions:
DissertationAuthorized.objects.create(dissertation=obj, authorized=institution)
profile.user_last_edit_date_time = modification.date_time
profile.save()
def get_project_data(self, row):
# get project_institutions
row_project_institutions = row.get(self.COLUMN_PROJECT_INSTITUTIONS,
'')
if isinstance(row_project_institutions, str):
self.institutions = self.project_import_helper.get_institutions(
row_project_institutions)
else:
self.institutions = row_project_institutions
row[self.
COLUMN_PROJECT_INSTITUTIONS] = None # it will be rewrite after save instance
# get project_title ant title_slug
row_project_opi_id = row.get(self.COLUMN_PROJECT_OPI_ID, '')
row_project_title = row.get(self.COLUMN_PROJECT_TITLE, '')
text_title = strip_tags(row_project_title)
row[self.COLUMN_PROJECT_TITLE_TEXT] = text_title
row[self.COLUMN_PROJECT_TITLE_SLUG] = slugify_text_title(text_title)
row[self.COLUMN_PROJECT_TITLE] = row_project_title
# get date
date_start = row[self.COLUMN_PROJECT_DATE_START]
row[self.
COLUMN_PROJECT_DATE_START] = ImportHelper.create_date_isoformat(
date_start)
date_end = row[self.COLUMN_PROJECT_DATE_END]
row[self.COLUMN_PROJECT_DATE_END] = ImportHelper.create_date_isoformat(
date_end)
# check for duplicates
[project_key_exist, project_duplicate_id
] = self.project_import_helper.check_project_title(text_title)
project_id = row[self.COLUMN_PROJECT_ID]
if project_key_exist:
if project_id == project_duplicate_id:
logger.warning(
'Project update. Found project with the same id: project_title='
+ text_title + ' project_id=' + str(project_id))
import_report.warning(';'.join(
(self.REPORT_PROJECT_UPDATE, str(project_id), text_title,
str(row_project_opi_id))))
elif project_id is not None:
logger.warning(self.LOG_MSG_DUPLICATE_OBJECT)
logger.warning('Existing object: project_title=' + text_title +
' project_id=' + str(project_id))
logger.warning('Duplicate object: ' + ' project_id=' +
str(project_duplicate_id))
import_report.warning(';'.join(
(self.REPORT_PROJECT_NEW_EXIST_DUPLICATES, str(project_id),
text_title, str(row_project_opi_id))))
import_report.warning(';'.join((self.REPORT_PROJECT_DUPLICATE,
str(project_duplicate_id))))
else:
import_report.info(';'.join(
(self.REPORT_PROJECT_NEW, str(project_id), text_title)))
# ##get project type TODO: check if it will be used?
# row_project_type = row[self.COLUMN_PROJECT_TYPE]
# project_type = self.project_import_helper.get_project_type(row_project_type)
# row[self.COLUMN_PROJECT_TYPE] = project_type
return row
def save_model(self, request, obj, form, change):
obj.person_slug = slugify_text_title(obj.person_first_name + ' ' + obj.person_last_name)
super(ImportExportModelAdmin, self).save_model(request, obj, form, change)
def dehydrate_person_slug(self, person):
return '%s' % slugify_text_title(person.person_first_name + ' ' +
person.person_last_name)
def save_model(self, request, obj, form, change):
obj.institution_slug = slugify_text_title(obj.institution_shortname)
super(VersionAdmin, self).save_model(request, obj, form, change)
