def _make_agreement_status_automatic_transitions(country_name):
"""Implementation core of agreement_status_automatic_transition() (q.v.)"""
logger.info('Starting agreement auto status transition for country {}'.format(country_name))
admin_user = get_user_model().objects.get(username=settings.TASK_ADMIN_USER)
# these are agreements that are not even valid within their own status
# compiling a list of them to send to an admin or save somewhere in the future
bad_agreements = []
# SSFAs don't transition automatically unless they transition based on the intervention.
signed_ended_agrs = Agreement.objects.filter(
status__in=[Agreement.DRAFT, Agreement.SIGNED],
end__lt=datetime.date.today()
).exclude(agreement_type=Agreement.SSFA)
processed = 0
for agr in signed_ended_agrs:
old_status = agr.status
# this function mutates agreement
with transaction.atomic():
validator = AgreementValid(agr, user=admin_user, disable_rigid_check=True)
if validator.is_valid:
if agr.status != old_status:
# this one transitioned forward
agr.save()
processed += 1
else:
bad_agreements.append(agr)
logger.error('Bad agreements {}'.format(len(bad_agreements)))
logger.error('Bad agreements ids: ' + ' '.join(str(a.id) for a in bad_agreements))
logger.info('Total agreements {}'.format(signed_ended_agrs.count()))
logger.info("Transitioned agreements {} ".format(processed))
def update(self, request, *args, **kwargs):
related_fields = ['amendments']
instance, old_instance, serializer = self.my_update(
request, related_fields, **kwargs)
validator = AgreementValid(instance,
old=old_instance,
user=request.user)
if not validator.is_valid:
logging.debug(validator.errors)
raise ValidationError(validator.errors)
if getattr(instance, '_prefetched_objects_cache', None):
# If 'prefetch_related' has been applied to a queryset, we need to
# refresh the instance from the database.
instance = self.get_object()
# if agreement becomes suspended, send notification
if instance.status == instance.SUSPENDED and instance.status != old_instance.status:
send_agreement_suspended_notification(instance, request.user)
return Response(
AgreementDetailSerializer(
instance, context=self.get_serializer_context()).data)
def validate(self, data):
data = super(AgreementCreateUpdateSerializer, self).validate(data)
agreement_type = data.get('agreement_type',
None) or self.instance.agreement_type
if agreement_type == Agreement.PCA:
# Look for country programme in data and on instance.
country_programme = data.get('country_programme')
if not country_programme and self.instance:
country_programme = self.instance.country_programme
if country_programme is None:
raise ValidationError({
'country_programme':
'Country Programme is required for PCAs!'
})
# When running validations in the serializer.. keep in mind that the
# related fields have not been updated and therefore not accessible on old_instance.relatedfield_old.
# If you want to run validation only after related fields have been updated. please run it in the view
if self.context.get('skip_global_validator', None):
return data
validator = AgreementValid(data,
old=self.instance,
user=self.context['request'].user)
if not validator.is_valid:
raise serializers.ValidationError({'errors': validator.errors})
return data
def create(self, request, *args, **kwargs):
related_fields = ['amendments']
serializer = self.my_create(request, related_fields, **kwargs)
instance = serializer.instance
validator = AgreementValid(instance, user=request.user)
if not validator.is_valid:
logging.debug(validator.errors)
raise ValidationError({'errors': validator.errors})
headers = self.get_success_headers(serializer.data)
if getattr(serializer.instance, '_prefetched_objects_cache', None):
# If 'prefetch_related' has been applied to a queryset, we need to
# refresh the instance from the database.
instance = self.get_object()
return Response(AgreementDetailSerializer(
instance, context=self.get_serializer_context()).data,
status=status.HTTP_201_CREATED,
headers=headers)