from collections import OrderedDict from datetime import date from django import forms from django.contrib.contenttypes.models import ContentType from django.core.validators import ValidationError from django.db import models from utilities.forms import CSVChoiceField, DatePicker, LaxURLField, StaticSelect2, add_blank_choice from extras.choices import * from extras.utils import FeatureQuery # # Custom fields # class CustomFieldModel(models.Model): custom_field_data = models.JSONField( blank=True, default=dict ) class Meta: abstract = True def __init__(self, *args, custom_fields=None, **kwargs): self._cf = custom_fields super().__init__(*args, **kwargs) @property def cf(self): """ Convenience wrapper for custom field data. """ return self.custom_field_data def get_custom_fields(self): """ Return a dictionary of custom fields for a single object in the form {: value}. """ fields = CustomField.objects.get_for_model(self) return OrderedDict([ (field, self.custom_field_data.get(field.name)) for field in fields ]) class CustomFieldManager(models.Manager): use_in_migrations = True def get_for_model(self, model): """ Return all CustomFields assigned to the given model. """ content_type = ContentType.objects.get_for_model(model._meta.concrete_model) return self.get_queryset().filter(obj_type=content_type) class CustomField(models.Model): obj_type = models.ManyToManyField( to=ContentType, related_name='custom_fields', verbose_name='Object(s)', limit_choices_to=FeatureQuery('custom_fields'), help_text='The object(s) to which this field applies.' ) type = models.CharField( max_length=50, choices=CustomFieldTypeChoices, default=CustomFieldTypeChoices.TYPE_TEXT ) name = models.CharField( max_length=50, unique=True ) label = models.CharField( max_length=50, blank=True, help_text='Name of the field as displayed to users (if not provided, ' 'the field\'s name will be used)' ) description = models.CharField( max_length=200, blank=True ) required = models.BooleanField( default=False, help_text='If true, this field is required when creating new objects ' 'or editing an existing object.' ) filter_logic = models.CharField( max_length=50, choices=CustomFieldFilterLogicChoices, default=CustomFieldFilterLogicChoices.FILTER_LOOSE, help_text='Loose matches any instance of a given string; exact ' 'matches the entire field.' ) default = models.CharField( max_length=100, blank=True, help_text='Default value for the field. Use "true" or "false" for booleans.' ) weight = models.PositiveSmallIntegerField( default=100, help_text='Fields with higher weights appear lower in a form.' ) objects = CustomFieldManager() class Meta: ordering = ['weight', 'name'] def __str__(self): return self.label or self.name.replace('_', ' ').capitalize() def serialize_value(self, value): """ Serialize the given value to a string suitable for storage as a CustomFieldValue """ if value is None: return '' if self.type == CustomFieldTypeChoices.TYPE_BOOLEAN: return str(int(bool(value))) if self.type == CustomFieldTypeChoices.TYPE_DATE: # Could be date/datetime object or string try: return value.strftime('%Y-%m-%d') except AttributeError: return value if self.type == CustomFieldTypeChoices.TYPE_SELECT: # Could be ModelChoiceField or TypedChoiceField return str(value.id) if hasattr(value, 'id') else str(value) return value def deserialize_value(self, serialized_value): """ Convert a string into the object it represents depending on the type of field """ if serialized_value == '': return None if self.type == CustomFieldTypeChoices.TYPE_INTEGER: return int(serialized_value) if self.type == CustomFieldTypeChoices.TYPE_BOOLEAN: return bool(int(serialized_value)) if self.type == CustomFieldTypeChoices.TYPE_DATE: # Read date as YYYY-MM-DD return date(*[int(n) for n in serialized_value.split('-')]) if self.type == CustomFieldTypeChoices.TYPE_SELECT: return self.choices.get(pk=int(serialized_value)) return serialized_value def to_form_field(self, set_initial=True, enforce_required=True, for_csv_import=False): """ Return a form field suitable for setting a CustomField's value for an object. set_initial: Set initial date for the field. This should be False when generating a field for bulk editing. enforce_required: Honor the value of CustomField.required. Set to False for filtering/bulk editing. for_csv_import: Return a form field suitable for bulk import of objects in CSV format. """ initial = self.default if set_initial else None required = self.required if enforce_required else False # Integer if self.type == CustomFieldTypeChoices.TYPE_INTEGER: field = forms.IntegerField(required=required, initial=initial) # Boolean elif self.type == CustomFieldTypeChoices.TYPE_BOOLEAN: choices = ( (None, '---------'), (1, 'True'), (0, 'False'), ) if initial is not None and initial.lower() in ['true', 'yes', '1']: initial = 1 elif initial is not None and initial.lower() in ['false', 'no', '0']: initial = 0 else: initial = None field = forms.NullBooleanField( required=required, initial=initial, widget=StaticSelect2(choices=choices) ) # Date elif self.type == CustomFieldTypeChoices.TYPE_DATE: field = forms.DateField(required=required, initial=initial, widget=DatePicker()) # Select elif self.type == CustomFieldTypeChoices.TYPE_SELECT: choices = [(cfc.pk, cfc.value) for cfc in self.choices.all()] if not required: choices = add_blank_choice(choices) # Set the initial value to the PK of the default choice, if any if set_initial: default_choice = self.choices.filter(value=self.default).first() if default_choice: initial = default_choice.pk field_class = CSVChoiceField if for_csv_import else forms.ChoiceField field = field_class( choices=choices, required=required, initial=initial, widget=StaticSelect2() ) # URL elif self.type == CustomFieldTypeChoices.TYPE_URL: field = LaxURLField(required=required, initial=initial) # Text else: field = forms.CharField(max_length=255, required=required, initial=initial) field.model = self field.label = self.label if self.label else self.name.replace('_', ' ').capitalize() if self.description: field.help_text = self.description return field class CustomFieldChoice(models.Model): field = models.ForeignKey( to='extras.CustomField', on_delete=models.CASCADE, related_name='choices', limit_choices_to={'type': CustomFieldTypeChoices.TYPE_SELECT} ) value = models.CharField( max_length=100 ) weight = models.PositiveSmallIntegerField( default=100, help_text='Higher weights appear lower in the list' ) class Meta: ordering = ['field', 'weight', 'value'] unique_together = ['field', 'value'] def __str__(self): return self.value def clean(self): if self.field.type != CustomFieldTypeChoices.TYPE_SELECT: raise ValidationError("Custom field choices can only be assigned to selection fields.") def delete(self, *args, **kwargs): # TODO: Prevent deletion of CustomFieldChoices which are in use? field_name = f'custom_field_data__{self.field.name}' for ct in self.field.obj_type.all(): model = ct.model_class() for instance in model.objects.filter(**{field_name: self.pk}): instance.custom_field_data.pop(self.field.name) instance.save() super().delete(*args, **kwargs)