def validate(self, model): applicable_model = get_field_tuple(model, self.applicable_field)[1] footnote_type = get_field_tuple(model, self.footnote_type_field)[1] if ( footnote_type.application_code not in applicable_model.footnote_application_codes ): raise self.violation(model)
def make_non_duplicate_record(factory, identifying_fields=None): """Creates two records using the passed factory that are not duplicates of each other and returns the record created last.""" existing = factory.create() not_duplicate = factory.create() if identifying_fields is None: identifying_fields = list(factory._meta.model.identifying_fields) assert any( get_field_tuple(existing, f) != get_field_tuple(not_duplicate, f) for f in identifying_fields) return not_duplicate
def validate(self, model): _, container = get_field_tuple(model, self.container_field_name) contained = model if self.contained_field_name: _, contained = get_field_tuple(model, self.contained_field_name) if not container: # TODO should this raise an exception? log.debug( "Skipping %s: Container field %s not found.", self.__class__.__name__, self.container_field_name, ) return self.query_contains_validity(container, contained, model)
def validate(self, model): identifying_fields = self.identifying_fields or model.identifying_fields query = dict( get_field_tuple(model, field) for field in identifying_fields) if (model.__class__.objects.filter(**query).approved_up_to_transaction( self.transaction).exclude(id=model.id).exists()): raise self.violation(model)
def get_fields_dict(instance, field_names): """ Retrieve dict of fields from django model instance, fetching data via the double underscore __ linked models. :param instance: Django model instance. :param field_names: List of fields to retrieve. :return: dict of {field_name: field_value} """ return dict(get_field_tuple(instance, name) for name in field_names)
def make_duplicate_record(factory, identifying_fields=None): """Creates two records using the passed factory that are duplicates of each other and returns the record created last.""" existing = factory.create() # allow overriding identifying_fields if identifying_fields is None: identifying_fields = list(factory._meta.model.identifying_fields) return factory.create(**dict( get_field_tuple(existing, field) for field in identifying_fields))
def make_dupe(factory, identifying_fields=None): existing = factory.create() # allow overriding identifying_fields if identifying_fields is None: identifying_fields = list(factory._meta.model.identifying_fields) if hasattr(existing, "valid_between"): identifying_fields.append("valid_between") return factory.create( **dict(get_field_tuple(existing, field) for field in identifying_fields) )
def get_identifying_fields( self, identifying_fields: Optional[Iterable[str]] = None, ) -> Dict[str, Any]: """ Get a name/value mapping of the fields that identify this model. :param identifying_fields Optional[Iterable[str]]: Optionally override the fields to retrieve :rtype dict[str, Any]: A dict of field names to values """ identifying_fields = identifying_fields or self.identifying_fields fields = {} for field in identifying_fields: _, fields[field] = get_field_tuple(self, field) return fields
def validate(self, model): """ Check other models with the same identifying fields do not have overlapping validity periods, except other versions of the same model. :param model TrackedModel: The model to compare with :raises self.violation: Rule violation """ identifying_fields = self.identifying_fields or model.identifying_fields query = dict(get_field_tuple(model, field) for field in identifying_fields) query["valid_between__overlap"] = model.valid_between if ( model.__class__.objects.filter(**query) .approved_up_to_transaction(self.transaction) .exclude(version_group=model.version_group) .exists() ): raise self.violation(model)
def validate(self, model): """ Check no other model has the same identifying fields, except other versions of the same model. :param model TrackedModel: The model to compare with :raises self.violation: Rule violation """ identifying_fields = self.identifying_fields or model.identifying_fields query = dict(get_field_tuple(model, field) for field in identifying_fields) if ( type(model) .objects.filter(**query) .approved_up_to_transaction(self.transaction) .exclude(version_group=model.version_group) .exists() ): raise self.violation(model)
def test_get_field_tuple(model_data, field, expected): model = factories.TestModel3Factory(**model_data) assert util.get_field_tuple(model, field) == (field, expected)