HewlettPackard / squest / 2509092723

from django.db.models import Model, CharField, ForeignKey, BooleanField, IntegerField, CASCADE, SET_NULL

from django.db.models.signals import post_save, pre_save, post_delete

from django.dispatch import receiver

from django.core.exceptions import ValidationError

from django.utils.translation import ugettext_lazy as _

from service_catalog.models.job_templates import JobTemplate

from service_catalog.models.operation_type import OperationType

from service_catalog.models.services import Service

class Operation(Model):

    name = CharField(max_length=100, verbose_name="Operation name")

    description = CharField(max_length=500, blank=True, null=True)

    type = CharField(

    service = ForeignKey(Service, on_delete=CASCADE, related_name="operations",

    job_template = ForeignKey(JobTemplate, null=True, on_delete=SET_NULL)

    auto_accept = BooleanField(default=False, blank=True)

    auto_process = BooleanField(default=False, blank=True)

    process_timeout_second = IntegerField(default=60, verbose_name="Process timeout (s)")

    enabled = BooleanField(default=True, blank=True)

    approval_workflow = ForeignKey(

    def __str__(self):

        return f"{self.name} ({self.service})"

    def clean(self):

        if self.approval_workflow and not self.approval_workflow.entry_point:

            raise ValidationError({'approval_workflow': _("You cannot use an approval workflow without entrypoint.")})

        if self.auto_accept and self.approval_workflow:

            raise ValidationError({'auto_accept': _("Auto accept cannot be set with an approval step.")})

    def update_survey(self):

        if self.job_template is not None:

            spec_list = self.job_template.survey.get("spec", [])

            list_of_field_to_have = [survey_spec["variable"] for survey_spec in spec_list]

            list_current_field = [tower_field.name for tower_field in self.tower_survey_fields.all()]

            to_add = list(set(list_of_field_to_have) - set(list_current_field))

            to_remove = list(set(list_current_field) - set(list_of_field_to_have))

            from service_catalog.models.tower_survey_field import TowerSurveyField

            for field_name in to_add:

                TowerSurveyField.objects.create(name=field_name, enabled=True, operation=self)

            for field_name in to_remove:

                TowerSurveyField.objects.get(name=field_name, operation=self).delete()

    def switch_tower_fields_enable_from_dict(self, dict_of_field):

        for key, enabled in dict_of_field.items():

            field = self.tower_survey_fields.get(name=key)

            field.enabled = enabled

            field.save()

    @classmethod

    def add_job_template_survey_as_default_survey(cls, sender, instance, created, *args, **kwargs):

        from service_catalog.models.tower_survey_field import TowerSurveyField

        if created:

            if instance.type == OperationType.CREATE and instance.service:

                instance.service.enabled = True

                instance.service.save()

            default_survey = instance.job_template.survey

            if "spec" in default_survey:

                for survey_field in default_survey["spec"]:

                    TowerSurveyField.objects.create(name=survey_field["variable"], enabled=True, operation=instance)

    @classmethod

    def update_survey_after_job_template_update(cls, job_template):

        operations = Operation.objects.filter(job_template=job_template)

        for operation in operations:

            operation.update_survey()

post_save.connect(Operation.add_job_template_survey_as_default_survey, sender=Operation)

@receiver(pre_save, sender=Operation)

def on_change(sender, instance: Operation, **kwargs):

    if instance.id is not None:

        previous = Operation.objects.get(id=instance.id)

        if previous.job_template != instance.job_template:

            instance.update_survey()

        if instance.type == OperationType.CREATE and instance.enabled and previous.enabled != instance.enabled and instance.service.can_be_enabled():

@receiver(post_save, sender=Operation)

def disable_service(sender, instance: Operation, **kwargs):

    if instance.type == OperationType.CREATE and not instance.service.can_be_enabled():

        instance.service.enabled = False

        instance.service.save()

@receiver(post_delete, sender=Operation)

def on_delete(sender, instance: Operation, **kwargs):

    if instance.type == OperationType.CREATE and not instance.service.can_be_enabled():

        instance.service.enabled = False

        instance.service.save()