class InterventionAmendmentCUSerializer(AttachmentSerializerMixin,
serializers.ModelSerializer):
amendment_number = serializers.CharField(read_only=True)
signed_amendment_file = serializers.FileField(source="signed_amendment",
read_only=True)
signed_amendment_attachment = AttachmentSingleFileField(
override="signed_amendment")
internal_prc_review = AttachmentSingleFileField()
class Meta:
model = InterventionAmendment
fields = "__all__"
def validate(self, data):
data = super(InterventionAmendmentCUSerializer, self).validate(data)
if 'signed_date' in data and data['signed_date'] > date.today():
raise ValidationError("Date cannot be in the future!")
if 'intervention' in data:
if data['intervention'].in_amendment is True:
raise ValidationError(
"Cannot add a new amendment while another amendment is in progress."
)
if data['intervention'].agreement.partner.blocked is True:
raise ValidationError(
"Cannot add a new amendment while the partner is blocked in Vision."
)
return data
class InterventionCreateUpdateSerializer(SnapshotModelSerializer):
planned_budget = InterventionBudgetCUSerializer(read_only=True)
partner = serializers.CharField(source='agreement.partner.name',
read_only=True)
prc_review_document_file = serializers.FileField(
source='prc_review_document', read_only=True)
prc_review_attachment = AttachmentSingleFileField(read_only=True)
signed_pd_document_file = serializers.FileField(
source='signed_pd_document', read_only=True)
signed_pd_attachment = AttachmentSingleFileField(read_only=True)
attachments = InterventionAttachmentSerializer(many=True,
read_only=True,
required=False)
result_links = InterventionResultCUSerializer(many=True,
read_only=True,
required=False)
frs = serializers.PrimaryKeyRelatedField(
many=True,
queryset=FundsReservationHeader.objects.prefetch_related(
'intervention').all(),
required=False)
class Meta:
model = Intervention
fields = "__all__"
def to_internal_value(self, data):
if 'frs' in data:
if data['frs'] is None:
data['frs'] = []
return super(InterventionCreateUpdateSerializer,
self).to_internal_value(data)
def validate_frs(self, frs):
for fr in frs:
if fr.intervention:
if (self.instance is None) or (not self.instance.id) or (
fr.intervention.id != self.instance.id):
raise ValidationError([
'One or more of the FRs selected is related to a different PD/SSFA,'
' {}'.format(fr.fr_number)
])
else:
pass
# unicef/etools-issues:779
# TODO: add this validation back after all legacy data has been handled.
# make sure it's not expired
# if fr.expired:
# raise ValidationError({'error': 'One or more selected FRs is expired,'
# ' {}'.format(fr.fr_number)})
return frs
@transaction.atomic
def update(self, instance, validated_data):
updated = super(InterventionCreateUpdateSerializer,
self).update(instance, validated_data)
return updated
class AgreementDetailSerializer(serializers.ModelSerializer):
partner_name = serializers.CharField(source='partner.name', read_only=True)
authorized_officers = PartnerStaffMemberNestedSerializer(many=True,
read_only=True)
amendments = AgreementAmendmentCreateUpdateSerializer(many=True,
read_only=True)
unicef_signatory = SimpleUserSerializer(source='signed_by')
partner_signatory = SimpleStaffMemberSerializer(source='partner_manager')
attached_agreement_file = serializers.FileField(
source="attached_agreement", read_only=True)
attachment = AttachmentSingleFileField(read_only=True)
permissions = serializers.SerializerMethodField(read_only=True)
def get_permissions(self, obj):
user = self.context['request'].user
ps = Agreement.permission_structure()
permissions = AgreementPermissions(user=user,
instance=self.instance,
permission_structure=ps)
return permissions.get_permissions()
class Meta:
model = Agreement
fields = "__all__"
class CoreValuesAssessmentSerializer(serializers.ModelSerializer):
attachment = AttachmentSingleFileField(read_only=True)
# assessment = serializers.FileField(required=True)
assessment_file = serializers.FileField(source='assessment',
read_only=True)
class Meta:
model = CoreValuesAssessment
fields = "__all__"
class AgreementAmendmentCreateUpdateSerializer(AttachmentSerializerMixin, serializers.ModelSerializer):
number = serializers.CharField(read_only=True)
created = serializers.DateTimeField(read_only=True)
modified = serializers.DateTimeField(read_only=True)
signed_amendment_file = serializers.FileField(source="signed_amendment", read_only=True)
signed_amendment_attachment = AttachmentSingleFileField()
class Meta:
model = AgreementAmendment
fields = "__all__"
class AgreementCreateUpdateSerializer(SnapshotModelSerializer):
partner_name = serializers.CharField(source='partner.name', read_only=True)
agreement_type = serializers.CharField(required=True)
amendments = AgreementAmendmentCreateUpdateSerializer(many=True,
read_only=True)
country_programme = serializers.PrimaryKeyRelatedField(
queryset=CountryProgramme.objects.all(),
required=False,
allow_null=True)
unicef_signatory = SimpleUserSerializer(source='signed_by', read_only=True)
partner_signatory = SimpleStaffMemberSerializer(source='partner_manager',
read_only=True)
agreement_number = serializers.CharField(read_only=True)
attached_agreement_file = serializers.FileField(
source="attached_agreement", read_only=True)
attachment = AttachmentSingleFileField(read_only=True)
class Meta:
model = Agreement
fields = "__all__"
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
class AssessmentDetailSerializer(serializers.ModelSerializer):
report_attachment = AttachmentSingleFileField(read_only=True)
report_file = serializers.FileField(source='report', read_only=True)
report = serializers.FileField(required=True)
completed_date = serializers.DateField(required=True)
class Meta:
model = Assessment
fields = "__all__"
def validate_completed_date(self, completed_date):
today = timezone.now().date()
if completed_date > today:
raise serializers.ValidationError(
'The Date of Report cannot be in the future')
return completed_date
class InterventionAttachmentSerializer(serializers.ModelSerializer):
attachment_file = serializers.FileField(source="attachment",
read_only=True)
attachment_document = AttachmentSingleFileField(source="attachment_file",
read_only=True)
class Meta:
model = InterventionAttachment
fields = (
'id',
'intervention',
'created',
'type',
'attachment',
'attachment_file',
'attachment_document',
)
class PartnerOrganizationDetailSerializer(serializers.ModelSerializer):
staff_members = PartnerStaffMemberDetailSerializer(many=True,
read_only=True)
assessments = AssessmentDetailSerializer(many=True, read_only=True)
planned_engagement = PlannedEngagementSerializer(read_only=True)
hact_values = serializers.SerializerMethodField(read_only=True)
core_values_assessment_file = serializers.FileField(
source='core_values_assessment', read_only=True)
core_values_assessment_attachment = AttachmentSingleFileField(
read_only=True)
interventions = serializers.SerializerMethodField(read_only=True)
hact_min_requirements = serializers.JSONField(read_only=True)
hidden = serializers.BooleanField(read_only=True)
planned_visits = PartnerPlannedVisitsSerializer(many=True,
read_only=True,
required=False)
partner_type_slug = serializers.ReadOnlyField()
flags = serializers.ReadOnlyField()
def get_hact_values(self, obj):
return json.loads(obj.hact_values) if isinstance(
obj.hact_values, str) else obj.hact_values
def get_interventions(self, obj):
interventions = InterventionListSerializer(
self.get_related_interventions(obj), many=True)
return interventions.data
def get_related_interventions(self, partner):
qs = Intervention.objects.frs_qs()\
.filter(agreement__partner=partner)\
.exclude(status='draft')
return qs
class Meta:
model = PartnerOrganization
fields = "__all__"
class InterventionDetailSerializer(serializers.ModelSerializer):
planned_budget = InterventionBudgetCUSerializer(read_only=True)
partner = serializers.CharField(source='agreement.partner.name')
partner_vendor = serializers.CharField(
source='agreement.partner.vendor_number')
partner_id = serializers.CharField(source='agreement.partner.id',
read_only=True)
prc_review_document_file = serializers.FileField(
source='prc_review_document', read_only=True)
prc_review_attachment = AttachmentSingleFileField(read_only=True)
signed_pd_document_file = serializers.FileField(
source='signed_pd_document', read_only=True)
signed_pd_attachment = AttachmentSingleFileField(read_only=True)
amendments = InterventionAmendmentCUSerializer(many=True,
read_only=True,
required=False)
attachments = InterventionAttachmentSerializer(many=True,
read_only=True,
required=False)
result_links = InterventionResultNestedSerializer(many=True,
read_only=True,
required=False)
submitted_to_prc = serializers.ReadOnlyField()
frs_details = FRsSerializer(source='frs', read_only=True)
permissions = serializers.SerializerMethodField(read_only=True)
flagged_sections = serializers.SerializerMethodField(read_only=True)
section_names = serializers.SerializerMethodField(read_only=True)
days_from_submission_to_signed = serializers.CharField(read_only=True)
days_from_review_to_signed = serializers.CharField(read_only=True)
locations = serializers.SerializerMethodField()
location_names = serializers.SerializerMethodField()
cluster_names = serializers.SerializerMethodField()
donors = serializers.SerializerMethodField()
donor_codes = serializers.SerializerMethodField()
grants = serializers.SerializerMethodField()
location_p_codes = serializers.SerializerMethodField()
def get_location_p_codes(self, obj):
return [location.p_code for location in obj.flat_locations.all()]
def get_donors(self, obj):
donors = set()
for fr_item_qs in obj.frs.all():
for fr_li in fr_item_qs.fr_items.all():
donors.add(fr_li.donor)
return donors
def get_donor_codes(self, obj):
donor_codes = set()
for fr_item_qs in obj.frs.all():
for fr_li in fr_item_qs.fr_items.all():
donor_codes.add(fr_li.donor_code)
return donor_codes
def get_grants(self, obj):
grants = set()
for fr_item_qs in obj.frs.all():
for fr_li in fr_item_qs.fr_items.all():
grants.add(fr_li.grant_number)
return grants
def get_permissions(self, obj):
user = self.context['request'].user
ps = Intervention.permission_structure()
permissions = InterventionPermissions(user=user,
instance=self.instance,
permission_structure=ps)
return permissions.get_permissions()
def get_locations(self, obj):
return [l.id for l in obj.intervention_locations()]
def get_location_names(self, obj):
return [
'{} [{} - {}]'.format(l.name, l.gateway.name, l.p_code)
for l in obj.intervention_locations()
]
def get_section_names(self, obj):
return [l.name for l in obj.flagged_sections()]
def get_flagged_sections(self, obj):
return [l.id for l in obj.flagged_sections()]
def get_cluster_names(self, obj):
return [c for c in obj.intervention_clusters()]
class Meta:
model = Intervention
fields = (
"id", 'frs', "partner", "agreement", "document_type", "number",
"prc_review_document_file", "frs_details",
"signed_pd_document_file", "title", "status", "start", "end",
"submission_date_prc", "review_date_prc", "submission_date",
"prc_review_document", "submitted_to_prc", "signed_pd_document",
"signed_by_unicef_date", "unicef_signatory", "unicef_focal_points",
"partner_focal_points", "partner_authorized_officer_signatory",
"offices", "population_focus", "signed_by_partner_date", "created",
"modified", "planned_budget", "result_links", 'country_programme',
'metadata', 'contingency_pd', "amendments", "attachments",
'permissions', 'partner_id', "sections", "locations",
"location_names", "cluster_names", "flat_locations",
"flagged_sections", "section_names", "in_amendment",
"prc_review_attachment", "signed_pd_attachment", "donors",
"donor_codes", "grants", "location_p_codes",
"days_from_submission_to_signed", "days_from_review_to_signed",
"partner_vendor", "reference_number_year")