def _assign(fld, val, rel_field=None):
field = fields[fld]
# quit early for null values
if val is None and field.null:
values[fld] = None
return
if not field.is_relation:
# direct assignment?
if isinstance(field, EnumField):
# we replaced model_utils.choices with enumfields.EnumField,
# so below doesn't really apply
# TODO: this is pretty. pretty ugly.
try:
val = getattr(type(field.choices[0][0]),
utils.str_to_constant_name(val))
except AttributeError:
logger.error("Invalid value %s for field %s", val,
field)
raise
elif field.choices:
# this logic is based on the assumption that the choices are
# a `model_utils.Choices` instance, and on the convention
# that the choices' "constant name" is derived from the data
val = getattr(field.choices,
utils.str_to_constant_name(val))
else:
# avoid writing nulls in fields that don't support it
if val is None and not field.null and isinstance(
field, (models.CharField, models.TextField)):
val = ''
values[fld] = val
return
# else...
relobjs = field.related_model.objects
if field.many_to_one:
# this is a foreign key
if rel_field:
values[fld] = relobjs.get(**{rel_field: val})
else:
values[fld] = relobjs.get_by_natural_key(val)
elif field.many_to_many:
# input data must be an iterable
if rel_field:
lookup = "%s__in" % rel_field
values[fld] = relobjs.filter(**{lookup: val})
else:
values[fld] = relobjs.filter_by_natural_keys(val)
else:
raise NotImplementedError(
"Can't handle relation type for field", field)
def _test_programmes(self):
data = self.DATA[Programme.IMPORT_SOURCE]
programme = Programme.from_data(data)
programme.save()
programme = Programme.objects.get()
self.assertEqual(programme.state,
State.objects.get(name=data['BeneficiaryState']))
# pa_code = data['PAListWithShortName'].split()[0]
# self.assertEqual(programme.programme_area,
# ProgrammeArea.objects.get_by_natural_key(pa_code))
self.assertEqual(programme.code,
data['ProgrammeCode'])
self.assertEqual(programme.name,
data['Programme'])
status_attr = utils.str_to_constant_name(data['ProgrammeStatus'])
self.assertEqual(programme.status,
getattr(Programme.STATUS, status_attr))
self.assertEqual(programme.summary,
data['ProgrammeSummary'])
self.assertEqual(programme.allocation,
data['AllocatedProgrammeGrant'])
self.assertEqual(programme.co_financing,
data['ProgrammeCoFinancing'])
def _test_projects(self):
data = self.DATA[Project.IMPORT_SOURCE]
project = Project.from_data(data)
project.save()
project = Project.objects.get()
self.assertEqual(project.state,
State.objects.get(name=data['BeneficiaryState']))
self.assertEqual(project.outcome,
Outcome.objects.get_by_natural_key(data['OutcomeCode']))
status_attr = utils.str_to_constant_name(data['ProjectStatus'])
self.assertEqual(project.status,
getattr(Project.STATUS, status_attr))
self.assertEqual(project.code,
data['ProjectCode'])
self.assertEqual(project.name,
data['Project'])
self.assertEqual(project.allocation,
data['GrantAmount'])
self.assertEqual(project.programme_co_financing,
data['ProgrammeCoFinancing'])
self.assertEqual(project.project_co_financing,
data['ProjectCoFinancing'])
self.assertEqual(project.nuts,
data['NUTSCode'])
def _test_priority_sectors(self):
data = self.DATA[PrioritySector.IMPORT_SOURCE]
sector = PrioritySector.from_data(data)
sector.save()
sector = PrioritySector.objects.get()
self.assertEqual(sector.code, data['PSCode'])
self.assertEqual(sector.name, data['PrioritySector'])
grant_type = utils.str_to_constant_name(data['GrantName'].split()[0])
self.assertEqual(sector.type, getattr(GRANT_TYPE, grant_type))
def _test_organisation_types(self):
data = self.DATA[OrganisationType.IMPORT_SOURCE]
org_type = OrganisationType.from_data(data)
org_type.save()
org_type = OrganisationType.objects.get()
category_attr = utils.str_to_constant_name(
data['OrganisationTypeCategory'])
self.assertEqual(org_type.category,
getattr(OrganisationType.CATEGORIES, category_attr))
self.assertEqual(org_type.name, data['OrganisationType'])
def _test_organisations(self):
data = self.DATA[Organisation.IMPORT_SOURCE]
org = Organisation.from_data(data)
org.save()
org = Organisation.objects.get()
self.assertEqual(org.id, data['IdOrganisation'])
self.assertEqual(org.name, data['Organisation'])
ptype_attr = utils.str_to_constant_name(
data['IsProgrammeOrProjectOrg'])
self.assertEqual(org.ptype,
getattr(Organisation.ORGANISATION_TYPE, ptype_attr))
self.assertEqual(
org.orgtype,
OrganisationType.objects.get(name=data['OrganisationType']))