Ejemplo n.º 1
0
class SoftDeleteMixin(models.Model):
    """
    This is a mixin to support soft deletion for specific models. This behavior is required to keep everything in the
    database but still hide it from the end users. Example: Country changes currency - the old one has to be kept but
    hidden (soft deleted)

    The functionality achieved by using the SoftDeleteMixin and the ValidityQuerySet. Both of them are depending on the
    `deleted_at` field, which defaults to EPOCH_ZERO to allow unique constrains in the db.
    IMPORTANT: Default has to be a value - boolean field or nullable datetime would not work
    IMPORTANT #2: This model does not prevent cascaded deletion - this can only happen if the soft deleted model points
                  to one which actually deletes the entity from the database
    """

    deleted_at = models.DateTimeField(default=EPOCH_ZERO,
                                      verbose_name='Deleted At')

    # IMPORTANT: The order of these two queryset is important. The normal queryset has to be defined first to have that
    #            as a default queryset
    admin_objects = QuerySet.as_manager()
    objects = ValidityQuerySet.as_manager()

    class Meta:
        abstract = True

    def delete(self, *args, **kwargs):
        self.deleted_at = now()
        self.save()
Ejemplo n.º 2
0
class Firm(models.Model):
    objects = QuerySet.as_manager()

    name = models.CharField('Name', max_length=255)

    def str(self):
        return self.name
Ejemplo n.º 3
0
class BaseModel(models.Model):
    created_date = models.DateTimeField(auto_now_add=True)
    modified_date = models.DateTimeField(auto_now=True)

    objects = QuerySet.as_manager()

    class Meta:
        abstract = True
Ejemplo n.º 4
0
class Company(models.Model):
    objects = QuerySet.as_manager()

    name = models.CharField('Name', max_length=255)
    symbol = models.CharField('Symbol', max_length=50, unique=True)
    currency = models.ForeignKey('main.Currency', on_delete=models.CASCADE)
    country = models.CharField('Country', max_length=2)

    def __str__(self):
        return f'{self.name} ({self.symbol})'
Ejemplo n.º 5
0
class SoftDeleteModel(models.Model):
    is_active = models.BooleanField(default=True)

    all_objects = QuerySet.as_manager()
    objects = ActiveQuerySet.as_manager()

    class Meta:
        abstract = True

    def delete(self, *args, **kwargs):
        self.is_active = False
        self.save()
Ejemplo n.º 6
0
class Currency(models.Model):
    objects = QuerySet.as_manager()

    name = models.CharField('Name', max_length=255, unique=True)
    code = models.CharField('Code', max_length=3, unique=True)
    symbol = models.CharField('Symbol', max_length=5)
    zero_currency = models.BooleanField('Is zero decimal currency',
                                        default=False)

    def __str__(self):
        return f'{self.name} - {self.symbol}'

    class Meta:
        verbose_name = 'Currency'
        verbose_name_plural = 'Currencies'
Ejemplo n.º 7
0
def attribute_class_filter(queryset: QuerySet, user: User = None) -> Tuple[QuerySet, QuerySet]:

    if not user:
        return queryset, queryset.as_manager().filter().none()

    # Get all of the classes that we aren't in.
    restricted_attribute_classes = AttributeClass.objects.exclude(users=user)
    attribute_class_queries = {
        "ExportRun": {"data_provider_task_records__provider__attribute_class__in": restricted_attribute_classes},
        "RunZipFile": {"data_provider_task_records__provider__attribute_class__in": restricted_attribute_classes},
        "Job": {"data_provider_tasks__provider__attribute_class__in": restricted_attribute_classes},
        "DataProvider": {"attribute_class__in": restricted_attribute_classes},
        "DataProviderTask": {"provider__attribute_class__in": restricted_attribute_classes},
        "DataProviderTaskRecord": {"provider__attribute_class__in": restricted_attribute_classes},
    }
    item = queryset.first()
    attribute_class_query = {}

    if item:
        # Get all of the objects that don't include attribute classes that we aren't in.
        attribute_class_query = attribute_class_queries.get(type(item).__name__, {})
    filtered = queryset.filter(**attribute_class_query).distinct()
    queryset = queryset.exclude(**attribute_class_query).distinct()
    return queryset, filtered