def test_init(self): # In case of creation form = TrainingForm({}, user=self.user, education_group_type=self.education_group_type) self.assertFalse(form.dict_initial_egy) self.assertEqual(form.initial_dicts, {'educationgrouporganization_set': {}}) # In case of update coorg = EducationGroupOrganizationFactory( organization=OrganizationFactory(), education_group_year=self.education_group_year) form = TrainingForm({}, user=self.user, instance=self.education_group_year) dict_initial_egy = model_to_dict_fk(self.education_group_year, exclude=form.field_to_exclude) self.assertEqual(str(form.dict_initial_egy), str(dict_initial_egy)) initial_dict_coorg = model_to_dict_fk( self.education_group_year.coorganizations.first(), exclude=FIELD_TO_EXCLUDE_IN_SET) self.assertEqual( form.initial_dicts, { 'educationgrouporganization_set': { coorg.organization.id: initial_dict_coorg } })
def duplicate_education_group_year(old_education_group_year, new_academic_year, dict_initial_egy=None, hops_values=None): dict_new_value = model_to_dict_fk(old_education_group_year, exclude=FIELD_TO_EXCLUDE) defaults_values = {x: v for x, v in dict_new_value.items() if not isinstance(v, list)} postponed_egy, created = EducationGroupYear.objects.get_or_create( education_group=old_education_group_year.education_group, academic_year=new_academic_year, # Create object without m2m relations defaults=defaults_values ) # During create of new postponed object, we need to update only the m2m relations if created: # Postpone the m2m [languages / secondary_domains] _postpone_m2m(old_education_group_year, postponed_egy, hops_values) # During the update, we need to check if the postponed object has been modify else: dict_postponed_egy = model_to_dict_fk(postponed_egy, exclude=FIELD_TO_EXCLUDE) differences = compare_objects(dict_initial_egy, dict_postponed_egy) \ if dict_initial_egy and dict_postponed_egy else {} if differences: raise ConsistencyError(postponed_egy, differences) update_object(postponed_egy, dict_new_value) # Postpone the m2m [languages / secondary_domains] _postpone_m2m(old_education_group_year, postponed_egy, hops_values) return postponed_egy
def duplicate_education_group_year(old_education_group_year, new_academic_year, initial_dicts=None, hops_values=None, fields_to_exclude=None): if initial_dicts is None: initial_dicts = {} if fields_to_exclude is None: fields_to_exclude = FIELD_TO_EXCLUDE dict_new_value = model_to_dict_fk(old_education_group_year, exclude=fields_to_exclude) defaults_values = { x: v for x, v in dict_new_value.items() if not isinstance(v, list) } postponed_egy, created = EducationGroupYear.objects.get_or_create( education_group=old_education_group_year.education_group, academic_year=new_academic_year, # Create object without m2m relations defaults=defaults_values) # During create of new postponed object, we need to update only the m2m relations if created: # Postpone the m2m [languages / secondary_domains] _postpone_m2m(old_education_group_year, postponed_egy, hops_values) # During the update, we need to check if the postponed object has been modify else: dict_postponed_egy = model_to_dict_fk(postponed_egy, exclude=fields_to_exclude) differences = compare_objects(initial_dicts['dict_initial_egy'], dict_postponed_egy) \ if initial_dicts['dict_initial_egy'] and dict_postponed_egy else {} if differences: raise ConsistencyError( { 'model': EducationGroupYear, 'last_instance_updated': postponed_egy }, differences) update_object(postponed_egy, dict_new_value) # Postpone the m2m [languages / secondary_domains] _postpone_m2m(old_education_group_year, postponed_egy, hops_values, fields_to_exclude=fields_to_exclude) if education_group.has_coorganization(old_education_group_year): duplicate_set(old_education_group_year, postponed_egy, initial_dicts.get('initial_sets_dict')) return postponed_egy
def setUpTestData(cls): super().setUpTestData() cls.current_academic_year = AcademicYearFactory(current=True) cls.generated_ac_years = AcademicYearFactory.produce( base_year=cls.current_academic_year.year, number_past=0, number_future=7) cls.entity_version = MainEntityVersionFactory( entity_type=entity_type.SECTOR) cls.central_manager = CentralManagerFactory() PersonEntityFactory(person=cls.central_manager, entity=cls.entity_version.entity) cls.training = TrainingFactory( management_entity=cls.entity_version.entity, administration_entity=cls.entity_version.entity, academic_year=cls.current_academic_year) cls.form_data = model_to_dict_fk(cls.training, exclude=('secondary_domains', )) cls.form_data.update({ 'primary_language': cls.form_data['primary_language_id'], 'administration_entity': cls.entity_version.pk, 'management_entity': cls.entity_version.pk })
def _postpone_m2m(education_group_year, postponed_egy, hops_values, fields_to_exclude=None): if fields_to_exclude is None: fields_to_exclude = [] opts = education_group_year._meta for f in opts.many_to_many: if f.name in fields_to_exclude: continue m2m_cls = f.remote_field.through # Remove records of postponed_egy m2m_cls.objects.all().filter( education_group_year=postponed_egy).delete() # Recreate records for m2m_obj in m2m_cls.objects.all().filter( education_group_year_id=education_group_year): m2m_data_to_postpone = model_to_dict_fk( m2m_obj, exclude=['id', 'external_id', 'education_group_year']) m2m_cls(education_group_year=postponed_egy, **m2m_data_to_postpone).save() if hops_values and any(elem in HOPS_FIELDS and hops_values[elem] for elem in hops_values): _postpone_hops(hops_values, postponed_egy)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.postpone_start_year = None self.postpone_end_year = None # The list will not include the current instance of education group year self.education_group_year_postponed = [] self.postponement_errors = {} self.warnings = [] if not self._is_creation(): self.dict_initial_egy = model_to_dict_fk( self.forms[forms.ModelForm].instance, exclude=self.field_to_exclude) self.initial_dicts['educationgrouporganization_set'] = { coorganization.organization.id: model_to_dict_fk(coorganization, exclude=FIELD_TO_EXCLUDE_IN_SET) for coorganization in self.forms[ forms.ModelForm].instance.coorganizations }
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.postpone_start_year = None self.postpone_end_year = None # The list will not include the current instance of education group year self.education_group_year_postponed = [] self.postponement_errors = {} self.warnings = [] if not self._is_creation(): self.dict_initial_egy = model_to_dict_fk( self.forms[forms.ModelForm].instance, exclude=self.field_to_exclude )
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.postpone_start_year = None self.postpone_end_year = None # The list will not include the current instance of education group year self.education_group_year_postponed = [] self.postponement_errors = {} self.warnings = [] if not self._is_creation(): self.dict_initial_egy = model_to_dict_fk( self.forms[forms.ModelForm].instance, exclude=self.field_to_exclude)
def duplicate_education_group_year(old_education_group_year, new_academic_year, dict_initial_egy=None, hops_values=None): dict_new_value = model_to_dict_fk(old_education_group_year, exclude=FIELD_TO_EXCLUDE) defaults_values = { x: v for x, v in dict_new_value.items() if not isinstance(v, list) } postponed_egy, created = EducationGroupYear.objects.get_or_create( education_group=old_education_group_year.education_group, academic_year=new_academic_year, # Create object without m2m relations defaults=defaults_values) # During create of new postponed object, we need to update only the m2m relations if created: # Postpone the m2m [languages / secondary_domains] _postpone_m2m(old_education_group_year, postponed_egy, hops_values) # During the update, we need to check if the postponed object has been modify else: dict_postponed_egy = model_to_dict_fk(postponed_egy, exclude=FIELD_TO_EXCLUDE) differences = compare_objects(dict_initial_egy, dict_postponed_egy) \ if dict_initial_egy and dict_postponed_egy else {} if differences: raise ConsistencyError(postponed_egy, differences) update_object(postponed_egy, dict_new_value) # Postpone the m2m [languages / secondary_domains] _postpone_m2m(old_education_group_year, postponed_egy, hops_values) return postponed_egy
def test_init(self): # In case of creation form = TrainingForm({}, user=self.user, education_group_type=self.education_group_type) self.assertFalse(form.dict_initial_egy) # In case of update form = TrainingForm({}, user=self.user, instance=self.education_group_year) dict_initial_egy = model_to_dict_fk(self.education_group_year, exclude=form.field_to_exclude) self.assertEqual(str(form.dict_initial_egy), str(dict_initial_egy))
def test_compute_end_postponement_case_specific_end_date_and_data_in_future_gte(self): # Set end date of education group self.education_group_year.education_group.end_year = self.current_academic_year.year + 2 self.education_group_year.refresh_from_db() # Create data in future lastest_academic_year = self.generated_ac_years.academic_years[-1] field_to_exclude = ['id', 'external_id', 'academic_year', 'languages', 'secondary_domains', 'certificate_aims'] defaults = model_to_dict_fk(self.education_group_year, exclude=field_to_exclude) EducationGroupYear.objects.update_or_create( education_group=self.education_group_year.education_group, academic_year=lastest_academic_year, defaults=defaults ) result = _compute_end_year(self.education_group_year.education_group) self.assertEqual(result, lastest_academic_year.year)
def _check_differences_and_update(dict_new_values, initial_set, postponed_item, set_tuple): set_name, set_model, set_filter_field = set_tuple dict_postponed_item = model_to_dict_fk(postponed_item, exclude=FIELD_TO_EXCLUDE_IN_SET) initial_item = initial_set.get(dict_postponed_item[set_filter_field]) differences = compare_objects(initial_item, dict_postponed_item) \ if initial_item and dict_postponed_item else {} if differences: raise ConsistencyError( { 'model': set_model, 'last_instance_updated': postponed_item }, differences) update_object(postponed_item, dict_new_values)
def _postpone_m2m(education_group_year, postponed_egy, hops_values): fields_to_exclude = [] opts = education_group_year._meta for f in opts.many_to_many: if f.name in fields_to_exclude: continue m2m_cls = f.rel.through # Remove records of postponed_egy m2m_cls.objects.all().filter(education_group_year=postponed_egy).delete() # Recreate records for m2m_obj in m2m_cls.objects.all().filter(education_group_year_id=education_group_year): m2m_data_to_postpone = model_to_dict_fk(m2m_obj, exclude=['id', 'external_id', 'education_group_year']) m2m_cls(education_group_year=postponed_egy, **m2m_data_to_postpone).save() if hops_values and any(elem in HOPS_FIELDS and hops_values[elem] for elem in hops_values): _postpone_hops(hops_values, postponed_egy)
def setUpTestData(cls): super().setUpTestData() cls.current_academic_year = AcademicYearFactory(current=True) cls.generated_ac_years = AcademicYearFactory.produce( base_year=cls.current_academic_year.year, number_past=0, number_future=7) cls.entity_version = MainEntityVersionFactory( entity_type=entity_type.SECTOR) cls.central_manager = CentralManagerFactory() PersonEntityFactory(person=cls.central_manager, entity=cls.entity_version.entity) cls.training = TrainingFactory( management_entity=cls.entity_version.entity, administration_entity=cls.entity_version.entity, academic_year=cls.current_academic_year) # Save the training instance will create N+6 data... form_data = model_to_dict_fk(cls.training, exclude=('secondary_domains', )) form_data.update({ 'primary_language': form_data['primary_language_id'], 'administration_entity': cls.entity_version.pk, 'management_entity': cls.entity_version.pk }) training_form = TrainingForm(form_data, instance=cls.training, user=cls.central_manager.user) training_form.is_valid() training_form.save() cls.certificate_aim_type_2 = CertificateAimFactory(section=2, code=200) cls.certificate_aim_type_4 = CertificateAimFactory(section=4, code=400) cls.form_data = { 'certificate_aims': [cls.certificate_aim_type_2.pk, cls.certificate_aim_type_4.pk] }
def _update_and_check_consistency_of_set(education_group_year, old_egy, initial_sets, set_tuple): ids = [] set_name, set_model, set_filter_field = set_tuple initial_set = initial_sets.get(set_name, {}) egy_set = getattr(old_egy, set_name).all() sets_is_consistent = _check_consistency_of_all_set(education_group_year, initial_set, set_tuple) if not sets_is_consistent: raise ConsistencyError( { 'model': set_model, 'last_instance_updated': education_group_year }, {'consistency': ()}) for item_set in egy_set: dict_new_values = model_to_dict_fk(item_set, exclude=FIELD_TO_EXCLUDE_IN_SET) defaults_values = { x: v for x, v in dict_new_values.items() if not isinstance(v, list) } postponed_item, created = set_model.objects.get_or_create( education_group_year=education_group_year, defaults=defaults_values, **{set_filter_field: dict_new_values[set_filter_field]}) ids.append(postponed_item.id) if not created: _check_differences_and_update(dict_new_values, initial_set, postponed_item, set_tuple) set_model.objects.filter( education_group_year=education_group_year).exclude( id__in=ids).delete()