class BackpackAssertionSerializerV2(DetailSerializerV2,
OriginalJsonSerializerMixin):
acceptance = serializers.ChoiceField(
choices=BadgeInstance.ACCEPTANCE_CHOICES,
default=BadgeInstance.ACCEPTANCE_ACCEPTED)
# badgeinstance
openBadgeId = serializers.URLField(source='jsonld_id', read_only=True)
badgeclass = EntityRelatedFieldV2(source='cached_badgeclass',
required=False,
queryset=BadgeClass.cached)
badgeclassOpenBadgeId = serializers.URLField(source='badgeclass_jsonld_id',
read_only=True)
issuer = EntityRelatedFieldV2(source='cached_issuer',
required=False,
queryset=Issuer.cached)
issuerOpenBadgeId = serializers.URLField(source='issuer_jsonld_id',
read_only=True)
image = serializers.FileField(read_only=True)
recipient = BadgeRecipientSerializerV2(source='*')
issuedOn = serializers.DateTimeField(source='issued_on', read_only=True)
narrative = MarkdownCharField(required=False)
evidence = EvidenceItemSerializerV2(many=True, required=False)
revoked = HumanReadableBooleanField(read_only=True)
revocationReason = serializers.CharField(source='revocation_reason',
read_only=True)
expires = serializers.DateTimeField(source='expires_at', required=False)
class Meta(DetailSerializerV2.Meta):
model = BadgeInstance
class EvidenceItemSerializerV2(BaseSerializerV2, OriginalJsonSerializerMixin):
url = serializers.URLField(source='evidence_url', max_length=1024, required=False)
narrative = MarkdownCharField(required=False)
class Meta:
apispec_definition = ('AssertionEvidence', {
'properties': OrderedDict([
('url', {
'type': "string",
'format': "url",
'description': "URL of a webpage presenting evidence of the achievement",
}),
('narrative', {
'type': "string",
'format': "markdown",
'description': "Markdown narrative that describes the achievement",
}),
])
})
def validate(self, attrs):
if not (attrs.get('evidence_url', None) or attrs.get('narrative', None)):
raise serializers.ValidationError("Either url or narrative is required")
return attrs
class BackpackAssertionSerializerV2(DetailSerializerV2, OriginalJsonSerializerMixin):
acceptance = serializers.ChoiceField(choices=BadgeInstance.ACCEPTANCE_CHOICES, default=BadgeInstance.ACCEPTANCE_ACCEPTED)
# badgeinstance
openBadgeId = serializers.URLField(source='jsonld_id', read_only=True)
badgeclass = EntityRelatedFieldV2(source='cached_badgeclass', required=False, queryset=BadgeClass.cached)
badgeclassOpenBadgeId = serializers.URLField(source='badgeclass_jsonld_id', read_only=True)
issuer = EntityRelatedFieldV2(source='cached_issuer', required=False, queryset=Issuer.cached)
issuerOpenBadgeId = serializers.URLField(source='issuer_jsonld_id', read_only=True)
image = serializers.FileField(read_only=True)
recipient = BadgeRecipientSerializerV2(source='*')
issuedOn = serializers.DateTimeField(source='issued_on', read_only=True)
narrative = MarkdownCharField(required=False)
evidence = EvidenceItemSerializerV2(many=True, required=False)
revoked = HumanReadableBooleanField(read_only=True)
revocationReason = serializers.CharField(source='revocation_reason', read_only=True)
expires = serializers.DateTimeField(source='expires_at', required=False)
class Meta(DetailSerializerV2.Meta):
model = BadgeInstance
def to_representation(self, instance):
representation = super(BackpackAssertionSerializerV2, self).to_representation(instance)
request_kwargs = self.context['kwargs']
expands = request_kwargs['expands']
if 'badgeclass' in expands:
representation['badgeclass'] = instance.cached_badgeclass.get_json(include_extra=True, use_canonical_id=True)
if 'issuer' in expands:
representation['badgeclass']['issuer'] = instance.cached_issuer.get_json(include_extra=True, use_canonical_id=True)
return representation
class EvidenceItemSerializer(serializers.Serializer):
evidence_url = serializers.URLField(max_length=1024, required=False, allow_blank=True)
narrative = MarkdownCharField(required=False, allow_blank=True)
class Meta:
apispec_definition = ('AssertionEvidence', {})
def validate(self, attrs):
if not (attrs.get('evidence_url', None) or attrs.get('narrative', None)):
raise serializers.ValidationError("Either url or narrative is required")
return attrs
class EvidenceItemSerializer(serializers.Serializer):
evidence_url = serializers.URLField(max_length=1024,
required=False,
allow_blank=True)
narrative = MarkdownCharField(required=False, allow_blank=True)
name = serializers.CharField(max_length=255,
required=False,
allow_null=True,
allow_blank=True)
description = StripTagsCharField(max_length=16384,
required=False,
allow_null=True,
allow_blank=True)
def validate(self, attrs):
if not (attrs.get('evidence_url', None)
or attrs.get('narrative', None)):
raise BadgrValidationFieldError(
'narrative', "Either url or narrative is required", 910)
return attrs
class LocalBadgeInstanceUploadSerializerV1(serializers.Serializer):
image = Base64FileField(required=False, write_only=True)
url = serializers.URLField(required=False, write_only=True)
assertion = serializers.CharField(required=False, write_only=True)
recipient_identifier = serializers.CharField(required=False,
read_only=True)
acceptance = serializers.CharField(default='Accepted')
public = serializers.BooleanField(required=False, default=False)
include_evidence = serializers.BooleanField(required=False, default=False)
narrative = MarkdownCharField(required=False, read_only=True)
extensions = serializers.DictField(source='extension_items',
read_only=True)
def to_representation(self, obj):
"""
If the APIView initialized the serializer with the extra context
variable 'format' from a query param in the GET request with the
value "plain", make the `json` field for this instance read_only.
"""
if self.context.get('format', 'v1') == 'plain':
self.fields.json = serializers.DictField(read_only=True)
representation = super(LocalBadgeInstanceUploadSerializerV1,
self).to_representation(obj)
representation['id'] = obj.entity_id
representation['json'] = V1BadgeInstanceSerializer(
obj, context=self.context).data
representation['imagePreview'] = {
"type":
"image",
"id":
"{}{}?type=png".format(
OriginSetting.HTTP,
reverse('badgeclass_image',
kwargs={'entity_id': obj.cached_badgeclass.entity_id}))
}
if obj.cached_issuer.image:
representation['issuerImagePreview'] = {
"type":
"image",
"id":
"{}{}?type=png".format(
OriginSetting.HTTP,
reverse('issuer_image',
kwargs={'entity_id': obj.cached_issuer.entity_id}))
}
if obj.image:
representation['image'] = obj.image_url()
representation['shareUrl'] = obj.share_url
return representation
def validate(self, data):
"""
Ensure only one assertion input field given.
"""
fields_present = [
'image' in data, 'url' in data, 'assertion' in data
and data.get('assertion')
]
if (fields_present.count(True) > 1):
raise serializers.ValidationError(
"Only one instance input field allowed.")
return data
def create(self, validated_data):
owner = validated_data.get('created_by')
try:
instance, created = BadgeCheckHelper.get_or_create_assertion(
url=validated_data.get('url', None),
imagefile=validated_data.get('image', None),
assertion=validated_data.get('assertion', None),
created_by=owner,
)
if not created:
if instance.acceptance == BadgeInstance.ACCEPTANCE_ACCEPTED:
raise RestframeworkValidationError([{
'name':
"DUPLICATE_BADGE",
'description':
"You already have this badge in your backpack"
}])
instance.acceptance = BadgeInstance.ACCEPTANCE_ACCEPTED
instance.save()
owner.publish() # update BadgeUser.cached_badgeinstances()
except DjangoValidationError as e:
raise RestframeworkValidationError(e.args[0])
return instance
def update(self, instance, validated_data):
""" Updating acceptance status (to 'Accepted') is permitted as well as changing public status. """
# Only locally issued badges will ever have an acceptance status other than 'Accepted'
if instance.acceptance in [
'Unaccepted', 'Rejected'
] and validated_data.get('acceptance') == 'Accepted':
instance.acceptance = 'Accepted'
instance.save()
public = validated_data.get('public', None)
if public is not None:
instance.public = public
instance.include_evidence = validated_data.get(
'include_evidence', False)
instance.save()
return instance
class BadgeInstanceSerializerV2(DetailSerializerV2,
OriginalJsonSerializerMixin):
openBadgeId = serializers.URLField(source='jsonld_id', read_only=True)
createdAt = DateTimeWithUtcZAtEndField(source='created_at',
read_only=True,
default_timezone=pytz.utc)
createdBy = EntityRelatedFieldV2(source='cached_creator', read_only=True)
badgeclass = EntityRelatedFieldV2(source='cached_badgeclass',
required=False,
queryset=BadgeClass.cached)
badgeclassOpenBadgeId = CachedUrlHyperlinkedRelatedField(
source='badgeclass_jsonld_id',
view_name='badgeclass_json',
lookup_field='entity_id',
queryset=BadgeClass.cached,
required=False)
badgeclassName = serializers.CharField(write_only=True, required=False)
issuer = EntityRelatedFieldV2(source='cached_issuer',
required=False,
queryset=Issuer.cached)
issuerOpenBadgeId = serializers.URLField(source='issuer_jsonld_id',
read_only=True)
image = serializers.FileField(read_only=True)
recipient = BadgeRecipientSerializerV2(source='*', required=False)
issuedOn = DateTimeWithUtcZAtEndField(source='issued_on',
required=False,
default_timezone=pytz.utc)
narrative = MarkdownCharField(required=False, allow_null=True)
evidence = EvidenceItemSerializerV2(source='evidence_items',
many=True,
required=False)
revoked = HumanReadableBooleanField(read_only=True)
revocationReason = serializers.CharField(source='revocation_reason',
read_only=True)
acceptance = serializers.CharField(read_only=True)
expires = DateTimeWithUtcZAtEndField(source='expires_at',
required=False,
allow_null=True,
default_timezone=pytz.utc)
notify = HumanReadableBooleanField(write_only=True,
required=False,
default=False)
allowDuplicateAwards = serializers.BooleanField(write_only=True,
required=False,
default=True)
extensions = serializers.DictField(source='extension_items',
required=False,
validators=[BadgeExtensionValidator()])
class Meta(DetailSerializerV2.Meta):
model = BadgeInstance
apispec_definition = ('Assertion', {
'properties':
OrderedDict([
('entityId', {
'type': "string",
'format': "string",
'description': "Unique identifier for this Assertion",
'readOnly': True,
}),
('entityType', {
'type': "string",
'format': "string",
'description': "\"Assertion\"",
'readOnly': True,
}),
('openBadgeId', {
'type': "string",
'format': "url",
'description': "URL of the OpenBadge compliant json",
'readOnly': True,
}),
('createdAt', {
'type': 'string',
'format': 'ISO8601 timestamp',
'description': "Timestamp when the Assertion was created",
'readOnly': True,
}),
('createdBy', {
'type': 'string',
'format': 'entityId',
'description': "BadgeUser who created the Assertion",
'readOnly': True,
}),
('badgeclass', {
'type': 'string',
'format': 'entityId',
'description': "BadgeClass that issued this Assertion",
'required': False,
}),
('badgeclassOpenBadgeId', {
'type': 'string',
'format': 'url',
'description': "URL of the BadgeClass to award",
'required': False,
}),
('badgeclassName', {
'type': 'string',
'format': 'string',
'description':
"Name of BadgeClass to create assertion against, case insensitive",
'required': False,
}),
('revoked', {
'type': 'boolean',
'description': "True if this Assertion has been revoked",
'readOnly': True,
}),
('revocationReason', {
'type': 'string',
'format': "string",
'description':
"Short description of why the Assertion was revoked",
'readOnly': True,
}),
('acceptance', {
'type': 'string',
'description':
"Recipient interaction with Assertion. One of: Unaccepted, Accepted, or Rejected",
'readOnly': True,
}),
('image', {
'type': 'string',
'format': 'url',
'description': "URL to the baked assertion image",
'readOnly': True,
}),
('issuedOn', {
'type': 'string',
'format': 'ISO8601 timestamp',
'description': "Timestamp when the Assertion was issued",
'required': False,
}),
('narrative', {
'type': 'string',
'format': 'markdown',
'description': "Markdown narrative of the achievement",
'required': False,
}),
('evidence', {
'type': 'array',
'items': {
'$ref': '#/definitions/AssertionEvidence'
},
'description':
"List of evidence associated with the achievement",
'required': False,
}),
('recipient', {
'type': 'object',
'$ref': '#/definitions/BadgeRecipient',
'description': "Recipient that was issued the Assertion",
'required': False,
}),
('expires', {
'type': 'string',
'format': 'ISO8601 timestamp',
'description': "Timestamp when the Assertion expires",
'required': False,
}),
])
})
def validate_issuedOn(self, value):
if value > timezone.now():
raise serializers.ValidationError(
"Only issuedOn dates in the past are acceptable.")
if value.year < 1583:
raise serializers.ValidationError(
"Only issuedOn dates after the introduction of the Gregorian calendar are allowed."
)
return value
def update(self, instance, validated_data):
updateable_fields = [
'evidence_items', 'expires_at', 'extension_items', 'hashed',
'issued_on', 'narrative', 'recipient_identifier', 'recipient_type'
]
for field_name in updateable_fields:
if field_name in validated_data:
setattr(instance, field_name, validated_data.get(field_name))
instance.rebake(save=True)
return instance
def validate(self, data):
request = self.context.get('request', None)
expected_issuer = self.context.get('kwargs', {}).get('issuer')
badgeclass_identifiers = [
'badgeclass_jsonld_id', 'badgeclassName', 'cached_badgeclass',
'badgeclass'
]
badge_instance_properties = list(data.keys())
if 'badgeclass' in self.context:
badge_instance_properties.append('badgeclass')
if sum(
[el in badgeclass_identifiers
for el in badge_instance_properties]) > 1:
raise serializers.ValidationError(
'Multiple badge class identifiers. Exactly one of the following badge class identifiers are allowed: badgeclass, badgeclassName, or badgeclassOpenBadgeId'
)
if request and request.method != 'PUT':
# recipient and badgeclass are only required on create, ignored on update
if 'recipient_identifier' not in data:
raise serializers.ValidationError(
{'recipient': ["This field is required"]})
if 'cached_badgeclass' in data:
# included badgeclass in request
data['badgeclass'] = data.pop('cached_badgeclass')
elif 'badgeclass' in self.context:
# badgeclass was passed in context
data['badgeclass'] = self.context.get('badgeclass')
elif 'badgeclass_jsonld_id' in data:
data['badgeclass'] = data.pop('badgeclass_jsonld_id')
elif 'badgeclassName' in data:
name = data.pop('badgeclassName')
matches = BadgeClass.objects.filter(name=name,
issuer=expected_issuer)
len_matches = len(matches)
if len_matches == 1:
data['badgeclass'] = matches.first()
elif len_matches == 0:
raise serializers.ValidationError(
"No matching BadgeClass found with name {}".format(
name))
else:
raise serializers.ValidationError(
"Could not award; {} BadgeClasses with name {}".format(
len_matches, name))
else:
raise serializers.ValidationError(
{"badgeclass": ["This field is required"]})
allow_duplicate_awards = data.pop('allowDuplicateAwards')
if allow_duplicate_awards is False:
previous_awards = BadgeInstance.objects.filter(
recipient_identifier=data['recipient_identifier'],
badgeclass=data['badgeclass']).filter(
revoked=False).filter(
Q(expires_at__isnull=True)
| Q(expires_at__gt=timezone.now()))
if previous_awards.exists():
raise serializers.ValidationError(
"A previous award of this badge already exists for this recipient."
)
if expected_issuer and data[
'badgeclass'].issuer_id != expected_issuer.id:
raise serializers.ValidationError({
"badgeclass":
["Could not find matching badgeclass for this issuer."]
})
if 'badgeclass' in data:
data['issuer'] = data['badgeclass'].issuer
return data
class BadgeClassSerializerV2(DetailSerializerV2, OriginalJsonSerializerMixin):
openBadgeId = serializers.URLField(source='jsonld_id', read_only=True)
createdAt = DateTimeWithUtcZAtEndField(source='created_at', read_only=True)
createdBy = EntityRelatedFieldV2(source='cached_creator', read_only=True)
issuer = EntityRelatedFieldV2(source='cached_issuer',
required=False,
queryset=Issuer.cached)
issuerOpenBadgeId = serializers.URLField(source='issuer_jsonld_id',
read_only=True)
name = StripTagsCharField(max_length=1024)
image = ValidImageField(required=False)
description = StripTagsCharField(max_length=16384,
required=True,
convert_null=True)
criteriaUrl = StripTagsCharField(source='criteria_url',
required=False,
allow_null=True,
validators=[URLValidator()])
criteriaNarrative = MarkdownCharField(source='criteria_text',
required=False,
allow_null=True)
alignments = AlignmentItemSerializerV2(source='alignment_items',
many=True,
required=False)
tags = serializers.ListField(child=StripTagsCharField(max_length=1024),
source='tag_items',
required=False)
expires = BadgeClassExpirationSerializerV2(source='*',
required=False,
allow_null=True)
extensions = serializers.DictField(source='extension_items',
required=False,
validators=[BadgeExtensionValidator()])
class Meta(DetailSerializerV2.Meta):
model = BadgeClass
apispec_definition = ('BadgeClass', {
'properties':
OrderedDict([
('entityId', {
'type': "string",
'format': "string",
'description': "Unique identifier for this BadgeClass",
'readOnly': True,
}),
('entityType', {
'type': "string",
'format': "string",
'description': "\"BadgeClass\"",
'readOnly': True,
}),
('openBadgeId', {
'type': "string",
'format': "url",
'description': "URL of the OpenBadge compliant json",
'readOnly': True,
}),
('createdAt', {
'type': 'string',
'format': 'ISO8601 timestamp',
'description': "Timestamp when the BadgeClass was created",
'readOnly': True,
}),
('createdBy', {
'type': 'string',
'format': 'entityId',
'description': "BadgeUser who created this BadgeClass",
'readOnly': True,
}),
('issuer', {
'type': 'string',
'format': 'entityId',
'description':
"entityId of the Issuer who owns the BadgeClass",
'required': False,
}),
('name', {
'type': "string",
'format': "string",
'description': "Name of the BadgeClass",
'required': True,
}),
('description', {
'type': "string",
'format': "string",
'description': "Short description of the BadgeClass",
'required': True,
}),
('image', {
'type': "string",
'format': "data:image/png;base64",
'description':
"Base64 encoded string of an image that represents the BadgeClass.",
'required': False,
}),
('criteriaUrl', {
'type': "string",
'format': "url",
'description':
"External URL that describes in a human-readable format the criteria for the BadgeClass",
'required': False,
}),
('criteriaNarrative', {
'type': "string",
'format': "markdown",
'description':
"Markdown formatted description of the criteria",
'required': False,
}),
('tags', {
'type': "array",
'items': {
'type': "string",
'format': "string"
},
'description': "List of tags that describe the BadgeClass",
'required': False,
}),
('alignments', {
'type': "array",
'items': {
'$ref': '#/definitions/BadgeClassAlignment'
},
'description':
"List of objects describing objectives or educational standards",
'required': False,
}),
('expires', {
'$ref': "#/definitions/BadgeClassExpiration",
'description':
"Expiration period for Assertions awarded from this BadgeClass",
'required': False,
}),
])
})
def to_internal_value(self, data):
if not isinstance(data, BadgeClass) and 'expires' in data:
if not data['expires'] or len(data['expires']) == 0:
# if expires was included blank, remove it so to_internal_value() doesnt choke
del data['expires']
return super(BadgeClassSerializerV2, self).to_internal_value(data)
def update(self, instance, validated_data):
if 'cached_issuer' in validated_data:
validated_data.pop('cached_issuer') # issuer is not updatable
if 'image' in validated_data:
self.context['save_kwargs'] = dict(force_resize=True)
if not IsEditor().has_object_permission(self.context.get('request'),
None, instance.issuer):
raise serializers.ValidationError({
"issuer":
"You do not have permission to edit badges on this issuer."
})
return super(BadgeClassSerializerV2,
self).update(instance, validated_data)
def create(self, validated_data):
if 'image' not in validated_data:
raise serializers.ValidationError(
{'image': 'Valid image file or data URI required.'})
if 'cached_issuer' in validated_data:
# included issuer in request
validated_data['issuer'] = validated_data.pop('cached_issuer')
elif 'issuer' in self.context:
# issuer was passed in context
validated_data['issuer'] = self.context.get('issuer')
else:
# issuer is required on create
raise serializers.ValidationError(
{"issuer": "This field is required"})
if not IsEditor().has_object_permission(
self.context.get('request'), None, validated_data['issuer']):
raise serializers.ValidationError({
"issuer":
"You do not have permission to edit badges on this issuer."
})
return super(BadgeClassSerializerV2, self).create(validated_data)
class BadgeClassSerializerV1(OriginalJsonSerializerMixin, ExtensionsSaverMixin,
serializers.Serializer):
created_at = serializers.DateTimeField(read_only=True)
created_by = BadgeUserIdentifierFieldV1()
id = serializers.IntegerField(required=False, read_only=True)
name = StripTagsCharField(max_length=255)
image = ValidImageField(required=False)
slug = StripTagsCharField(max_length=255,
read_only=True,
source='entity_id')
criteria = MarkdownCharField(allow_blank=True,
required=False,
write_only=True)
criteria_text = MarkdownCharField(required=False,
allow_null=True,
allow_blank=True)
criteria_url = StripTagsCharField(required=False,
allow_blank=True,
allow_null=True,
validators=[URLValidator()])
recipient_count = serializers.IntegerField(required=False, read_only=True)
enrollment_count = serializers.IntegerField(required=False, read_only=True)
pathway_element_count = serializers.IntegerField(required=False,
read_only=True)
description = StripTagsCharField(max_length=16384,
required=True,
convert_null=True)
alignment = AlignmentItemSerializerV1(many=True,
source='alignment_items',
required=False)
tags = serializers.ListField(child=StripTagsCharField(max_length=1024),
source='tag_items',
required=False)
extensions = serializers.DictField(source='extension_items',
required=False,
validators=[BadgeExtensionValidator()])
class Meta:
apispec_definition = ('BadgeClass', {})
def to_representation(self, instance):
representation = super(BadgeClassSerializerV1,
self).to_representation(instance)
representation['issuer'] = OriginSetting.HTTP + reverse(
'issuer_json',
kwargs={'entity_id': instance.cached_issuer.entity_id})
representation['json'] = instance.get_json(obi_version='1_1',
use_canonical_id=True)
return representation
def validate_image(self, image):
if image is not None:
img_name, img_ext = os.path.splitext(image.name)
image.name = 'issuer_badgeclass_' + str(uuid.uuid4()) + img_ext
return image
def validate_criteria_text(self, criteria_text):
if criteria_text is not None and criteria_text != '':
return criteria_text
else:
return None
def validate_criteria_url(self, criteria_url):
if criteria_url is not None and criteria_url != '':
return criteria_url
else:
return None
def add_extensions(self, instance, add_these_extensions, extension_items):
for extension_name in add_these_extensions:
original_json = extension_items[extension_name]
extension = BadgeClassExtension(
name=extension_name,
original_json=json.dumps(original_json),
badgeclass_id=instance.pk)
extension.save()
def update(self, instance, validated_data):
new_name = validated_data.get('name')
if new_name:
new_name = strip_tags(new_name)
instance.name = new_name
new_description = validated_data.get('description')
if new_description:
instance.description = strip_tags(new_description)
if 'criteria_text' in validated_data:
instance.criteria_text = validated_data.get('criteria_text')
if 'criteria_url' in validated_data:
instance.criteria_url = validated_data.get('criteria_url')
if 'image' in validated_data:
instance.image = validated_data.get('image')
instance.alignment_items = validated_data.get('alignment_items')
instance.tag_items = validated_data.get('tag_items')
self.save_extensions(validated_data, instance)
instance.save()
return instance
def validate(self, data):
if 'criteria' in data:
if 'criteria_url' in data or 'criteria_text' in data:
raise serializers.ValidationError(
"The criteria field is mutually-exclusive with the criteria_url and criteria_text fields"
)
if utils.is_probable_url(data.get('criteria')):
data['criteria_url'] = data.pop('criteria')
elif not isinstance(data.get('criteria'), (str, unicode)):
raise serializers.ValidationError(
"Provided criteria text could not be properly processed as URL or plain text."
)
else:
data['criteria_text'] = data.pop('criteria')
else:
if data.get('criteria_text', None) is None and data.get(
'criteria_url', None) is None:
raise serializers.ValidationError(
"One or both of the criteria_text and criteria_url fields must be provided"
)
return data
def filter_extensions(self, validated_data):
extension_items = validated_data['extension_items']
for extension_name in extension_items.keys():
extension_item = extension_items[extension_name]
if extension_name == 'languageExtension':
del extension_item['typedLanguage']
def create(self, validated_data, **kwargs):
if 'image' not in validated_data:
raise serializers.ValidationError(
{"image": ["This field is required"]})
if 'issuer' in self.context:
validated_data['issuer'] = self.context.get('issuer')
self.filter_extensions(validated_data)
new_badgeclass = BadgeClass.objects.create(**validated_data)
return new_badgeclass
class BadgeInstanceSerializerV1(OriginalJsonSerializerMixin,
serializers.Serializer):
created_at = DateTimeWithUtcZAtEndField(read_only=True,
default_timezone=pytz.utc)
created_by = BadgeUserIdentifierFieldV1(read_only=True)
slug = serializers.CharField(max_length=255,
read_only=True,
source='entity_id')
image = serializers.FileField(
read_only=True) # use_url=True, might be necessary
email = serializers.EmailField(max_length=1024,
required=False,
write_only=True)
recipient_identifier = serializers.CharField(max_length=1024,
required=False)
recipient_type = serializers.CharField(default=RECIPIENT_TYPE_EMAIL)
allow_uppercase = serializers.BooleanField(default=False,
required=False,
write_only=True)
evidence = serializers.URLField(write_only=True,
required=False,
allow_blank=True,
max_length=1024)
narrative = MarkdownCharField(required=False,
allow_blank=True,
allow_null=True)
evidence_items = EvidenceItemSerializer(many=True, required=False)
revoked = HumanReadableBooleanField(read_only=True)
revocation_reason = serializers.CharField(read_only=True)
expires = DateTimeWithUtcZAtEndField(source='expires_at',
required=False,
allow_null=True,
default_timezone=pytz.utc)
create_notification = HumanReadableBooleanField(write_only=True,
required=False,
default=False)
allow_duplicate_awards = serializers.BooleanField(write_only=True,
required=False,
default=True)
hashed = serializers.NullBooleanField(default=None, required=False)
extensions = serializers.DictField(source='extension_items',
required=False,
validators=[BadgeExtensionValidator()])
class Meta:
apispec_definition = ('Assertion', {})
def validate(self, data):
recipient_type = data.get('recipient_type')
if data.get('recipient_identifier') and data.get('email') is None:
if recipient_type == RECIPIENT_TYPE_EMAIL:
recipient_validator = EmailValidator()
elif recipient_type in (RECIPIENT_TYPE_URL, RECIPIENT_TYPE_ID):
recipient_validator = URLValidator()
else:
recipient_validator = TelephoneValidator()
try:
recipient_validator(data['recipient_identifier'])
except DjangoValidationError as e:
raise serializers.ValidationError(e.message)
elif data.get('email') and data.get('recipient_identifier') is None:
data['recipient_identifier'] = data.get('email')
allow_duplicate_awards = data.pop('allow_duplicate_awards')
if allow_duplicate_awards is False and self.context.get(
'badgeclass') is not None:
previous_awards = BadgeInstance.objects.filter(
recipient_identifier=data['recipient_identifier'],
badgeclass=self.context['badgeclass']).filter(
Q(expires_at__isnull=True)
| Q(expires_at__lt=timezone.now()))
if previous_awards.exists():
raise serializers.ValidationError(
"A previous award of this badge already exists for this recipient."
)
hashed = data.get('hashed', None)
if hashed is None:
if recipient_type in (RECIPIENT_TYPE_URL, RECIPIENT_TYPE_ID):
data['hashed'] = False
else:
data['hashed'] = True
return data
def validate_narrative(self, data):
if data is None or data == "":
return None
else:
return data
def to_representation(self, instance):
representation = super(BadgeInstanceSerializerV1,
self).to_representation(instance)
representation['json'] = instance.get_json(obi_version="1_1",
use_canonical_id=True)
if self.context.get('include_issuer', False):
representation['issuer'] = IssuerSerializerV1(
instance.cached_badgeclass.cached_issuer).data
else:
representation['issuer'] = OriginSetting.HTTP + reverse(
'issuer_json',
kwargs={'entity_id': instance.cached_issuer.entity_id})
if self.context.get('include_badge_class', False):
representation['badge_class'] = BadgeClassSerializerV1(
instance.cached_badgeclass, context=self.context).data
else:
representation['badge_class'] = OriginSetting.HTTP + reverse(
'badgeclass_json',
kwargs={'entity_id': instance.cached_badgeclass.entity_id})
representation['public_url'] = OriginSetting.HTTP + reverse(
'badgeinstance_json', kwargs={'entity_id': instance.entity_id})
return representation
def create(self, validated_data):
"""
Requires self.context to include request (with authenticated request.user)
and badgeclass: issuer.models.BadgeClass.
"""
evidence_items = []
# ob1 evidence url
evidence_url = validated_data.get('evidence')
if evidence_url:
evidence_items.append({'evidence_url': evidence_url})
# ob2 evidence items
submitted_items = validated_data.get('evidence_items')
if submitted_items:
evidence_items.extend(submitted_items)
try:
return self.context.get('badgeclass').issue(
recipient_id=validated_data.get('recipient_identifier'),
narrative=validated_data.get('narrative'),
evidence=evidence_items,
notify=validated_data.get('create_notification'),
created_by=self.context.get('request').user,
allow_uppercase=validated_data.get('allow_uppercase'),
recipient_type=validated_data.get('recipient_type',
RECIPIENT_TYPE_EMAIL),
badgr_app=BadgrApp.objects.get_current(
self.context.get('request')),
expires_at=validated_data.get('expires_at', None),
extensions=validated_data.get('extension_items', None))
except DjangoValidationError as e:
raise serializers.ValidationError(e.message)
def update(self, instance, validated_data):
updateable_fields = [
'evidence_items', 'expires_at', 'extension_items', 'hashed',
'narrative', 'recipient_identifier', 'recipient_type'
]
for field_name in updateable_fields:
if field_name in validated_data:
setattr(instance, field_name, validated_data.get(field_name))
instance.rebake(save=False)
instance.save()
return instance
class BadgeInstanceSerializerV1(OriginalJsonSerializerMixin,
serializers.Serializer):
created_at = serializers.DateTimeField(read_only=True)
created_by = BadgeUserIdentifierFieldV1(read_only=True)
slug = serializers.CharField(max_length=255,
read_only=True,
source='entity_id')
image = serializers.FileField(
read_only=True) # use_url=True, might be necessary
email = serializers.EmailField(max_length=1024,
required=False,
write_only=True)
recipient_identifier = serializers.CharField(max_length=1024,
required=False)
recipient_type = serializers.CharField(
default=BadgeInstance.RECIPIENT_TYPE_EMAIL)
allow_uppercase = serializers.BooleanField(default=False,
required=False,
write_only=True)
evidence = serializers.URLField(write_only=True,
required=False,
allow_blank=True,
max_length=1024)
narrative = MarkdownCharField(required=False,
allow_blank=True,
allow_null=True)
evidence_items = EvidenceItemSerializer(many=True, required=False)
revoked = HumanReadableBooleanField(read_only=True)
revocation_reason = serializers.CharField(read_only=True)
expires = serializers.DateTimeField(source='expires_at',
required=False,
allow_null=True)
create_notification = HumanReadableBooleanField(write_only=True,
required=False,
default=False)
hashed = serializers.NullBooleanField(default=None, required=False)
extensions = serializers.DictField(source='extension_items',
required=False,
validators=[BadgeExtensionValidator()])
class Meta:
apispec_definition = ('Assertion', {})
def validate(self, data):
if data.get('email') and not data.get('recipient_identifier'):
data['recipient_identifier'] = data.get('email')
hashed = data.get('hashed', None)
if hashed is None:
recipient_type = data.get('recipient_type')
if recipient_type in (BadgeInstance.RECIPIENT_TYPE_URL,
BadgeInstance.RECIPIENT_TYPE_ID):
data['hashed'] = False
else:
data['hashed'] = True
return data
def validate_narrative(self, data):
if data is None or data == "":
return None
else:
return data
def to_representation(self, instance):
# if self.context.get('extended_json'):
# self.fields['json'] = V1InstanceSerializer(source='extended_json')
representation = super(BadgeInstanceSerializerV1,
self).to_representation(instance)
representation['json'] = instance.get_json(obi_version="1_1",
use_canonical_id=True)
if self.context.get('include_issuer', False):
representation['issuer'] = IssuerSerializerV1(
instance.cached_badgeclass.cached_issuer).data
else:
representation['issuer'] = OriginSetting.HTTP + reverse(
'issuer_json',
kwargs={'entity_id': instance.cached_issuer.entity_id})
if self.context.get('include_badge_class', False):
representation['badge_class'] = BadgeClassSerializerV1(
instance.cached_badgeclass, context=self.context).data
else:
representation['badge_class'] = OriginSetting.HTTP + reverse(
'badgeclass_json',
kwargs={'entity_id': instance.cached_badgeclass.entity_id})
representation['public_url'] = OriginSetting.HTTP + reverse(
'badgeinstance_json', kwargs={'entity_id': instance.entity_id})
if apps.is_installed('badgebook'):
try:
from badgebook.models import BadgeObjectiveAward
from badgebook.serializers import BadgeObjectiveAwardSerializer
try:
award = BadgeObjectiveAward.cached.get(
badge_instance_id=instance.id)
except BadgeObjectiveAward.DoesNotExist:
representation['award'] = None
else:
representation['award'] = BadgeObjectiveAwardSerializer(
award).data
except ImportError:
pass
return representation
def create(self, validated_data):
"""
Requires self.context to include request (with authenticated request.user)
and badgeclass: issuer.models.BadgeClass.
"""
evidence_items = []
# ob1 evidence url
evidence_url = validated_data.get('evidence')
if evidence_url:
evidence_items.append({'evidence_url': evidence_url})
# ob2 evidence items
submitted_items = validated_data.get('evidence_items')
if submitted_items:
evidence_items.extend(submitted_items)
return self.context.get('badgeclass').issue(
recipient_id=validated_data.get('recipient_identifier'),
narrative=validated_data.get('narrative'),
evidence=evidence_items,
notify=validated_data.get('create_notification'),
created_by=self.context.get('request').user,
allow_uppercase=validated_data.get('allow_uppercase'),
recipient_type=validated_data.get(
'recipient_type', BadgeInstance.RECIPIENT_TYPE_EMAIL),
badgr_app=BadgrApp.objects.get_current(
self.context.get('request')),
expires_at=validated_data.get('expires_at', None),
extensions=validated_data.get('extension_items', None))
def update(self, instance, validated_data):
updateable_fields = [
'evidence_items', 'expires_at', 'extension_items', 'hashed',
'issued_on', 'narrative', 'recipient_identifier', 'recipient_type'
]
for field_name in updateable_fields:
if field_name in validated_data:
setattr(instance, field_name, validated_data.get(field_name))
instance.save()
return instance
class LocalBadgeInstanceUploadSerializerV1(serializers.Serializer):
image = Base64FileField(required=False, write_only=True)
url = serializers.URLField(required=False, write_only=True)
assertion = serializers.CharField(required=False, write_only=True)
recipient_identifier = serializers.CharField(required=False,
read_only=True)
acceptance = serializers.CharField(default='Accepted')
narrative = MarkdownCharField(required=False, read_only=True)
evidence_items = EvidenceItemSerializer(many=True,
required=False,
read_only=True)
pending = serializers.ReadOnlyField()
extensions = serializers.DictField(source='extension_items',
read_only=True)
# Reinstantiation using fields from badge instance when returned by .create
# id = serializers.IntegerField(read_only=True)
# json = V1InstanceSerializer(read_only=True)
def to_representation(self, obj):
"""
If the APIView initialized the serializer with the extra context
variable 'format' from a query param in the GET request with the
value "plain", make the `json` field for this instance read_only.
"""
if self.context.get('format', 'v1') == 'plain':
self.fields.json = serializers.DictField(read_only=True)
representation = super(LocalBadgeInstanceUploadSerializerV1,
self).to_representation(obj)
# if isinstance(obj, LocalBadgeInstance):
# representation['json'] = V1InstanceSerializer(obj.json, context=self.context).data
# representation['imagePreview'] = {
# "type": "image",
# "id": "{}{}?type=png".format(OriginSetting.HTTP, reverse('localbadgeinstance_image', kwargs={'slug': obj.slug}))
# }
# if isinstance(obj, BadgeInstance):
representation['id'] = obj.entity_id
representation['json'] = V1BadgeInstanceSerializer(
obj, context=self.context).data
representation['imagePreview'] = {
"type":
"image",
"id":
"{}{}?type=png".format(
OriginSetting.HTTP,
reverse('badgeclass_image',
kwargs={'entity_id': obj.cached_badgeclass.entity_id}))
}
if obj.cached_issuer.image:
representation['issuerImagePreview'] = {
"type":
"image",
"id":
"{}{}?type=png".format(
OriginSetting.HTTP,
reverse('issuer_image',
kwargs={'entity_id': obj.cached_issuer.entity_id}))
}
if obj.image:
representation['image'] = obj.image_url()
representation['shareUrl'] = obj.share_url
return representation
# def validate_recipient_identifier(self, data):
# user = self.context.get('request').user
# current_emails = [e.email for e in user.cached_emails()] + [e.email for e in user.cached_email_variants()]
#
# if data in current_emails:
# return None
# if user.can_add_variant(data):
# return data
# raise serializers.ValidationError("Requested recipient ID {} is not one of your verified email addresses.")
#
def validate(self, data):
"""
Ensure only one assertion input field given.
"""
fields_present = [
'image' in data, 'url' in data, 'assertion' in data
and data.get('assertion')
]
if (fields_present.count(True) > 1):
raise serializers.ValidationError(
"Only one instance input field allowed.")
return data
def create(self, validated_data):
owner = validated_data.get('created_by')
try:
instance, created = BadgeCheckHelper.get_or_create_assertion(
url=validated_data.get('url', None),
imagefile=validated_data.get('image', None),
assertion=validated_data.get('assertion', None),
created_by=owner,
)
if not created:
if instance.acceptance == BadgeInstance.ACCEPTANCE_ACCEPTED:
raise RestframeworkValidationError([{
'name':
"DUPLICATE_BADGE",
'description':
"You already have this badge in your backpack"
}])
instance.acceptance = BadgeInstance.ACCEPTANCE_ACCEPTED
instance.save()
owner.publish() # update BadgeUser.cached_badgeinstances()
except DjangoValidationError as e:
raise RestframeworkValidationError(e.args[0])
return instance
def update(self, instance, validated_data):
""" Only updating acceptance status (to 'Accepted') is permitted for now. """
# Only locally issued badges will ever have an acceptance status other than 'Accepted'
if instance.acceptance == 'Unaccepted' and validated_data.get(
'acceptance') == 'Accepted':
instance.acceptance = 'Accepted'
instance.save()
owner = instance.user
if owner:
owner.publish()
return instance
class BadgeInstanceSerializer(OriginalJsonSerializerMixin,
serializers.Serializer):
allow_uppercase = serializers.BooleanField(default=False,
required=False,
write_only=True)
issue_signed = serializers.BooleanField(required=False)
signing_password = serializers.CharField(max_length=1024, required=False)
enrollment_entity_id = serializers.CharField(max_length=1024,
required=False)
extensions = serializers.DictField(source='extension_items',
required=False,
validators=[BadgeExtensionValidator()])
narrative = MarkdownCharField(required=False,
allow_blank=True,
allow_null=True)
evidence_items = EvidenceItemSerializer(many=True, required=False)
def get_recipient_email(self, obj):
return obj.get_email_address()
def get_recipient_name(self, obj):
return obj.get_recipient_name()
def validate(self, data):
badgeclass = self.context['request'].data.get('badgeclass')
if badgeclass.narrative_required and not data.get('narrative'):
raise BadgrValidationError(error_code=999,
error_message="Narrative is required")
if badgeclass.evidence_required and not data.get("evidence_items"):
raise BadgrValidationError(error_code=999,
error_message="Eviidence is required")
if data.get('email') and not data.get('recipient_identifier'):
data['recipient_identifier'] = data.get('email')
hashed = data.get('hashed', None)
if hashed is None:
recipient_type = data.get('recipient_type')
if recipient_type in (BadgeInstance.RECIPIENT_TYPE_URL,
BadgeInstance.RECIPIENT_TYPE_ID):
data['hashed'] = False
else:
data['hashed'] = True
return data
def validate_narrative(self, data):
if data is None or data == "":
return None
else:
return data
def to_representation(self, instance):
representation = super(BadgeInstanceSerializer,
self).to_representation(instance)
representation['json'] = instance.get_json(obi_version="1_1",
use_canonical_id=True)
if self.context.get('include_issuer', False):
representation['issuer'] = IssuerSerializer(
instance.cached_badgeclass.cached_issuer).data
else:
representation['issuer'] = OriginSetting.HTTP + reverse(
'issuer_json',
kwargs={'entity_id': instance.cached_issuer.entity_id})
if self.context.get('include_badge_class', False):
representation['badge_class'] = BadgeClassSerializer(
instance.cached_badgeclass, context=self.context).data
else:
representation['badge_class'] = OriginSetting.HTTP + reverse(
'badgeclass_json',
kwargs={'entity_id': instance.cached_badgeclass.entity_id})
representation['public_url'] = OriginSetting.HTTP + reverse(
'badgeinstance_json', kwargs={'entity_id': instance.entity_id})
if apps.is_installed('badgebook'):
try:
from badgebook.models import BadgeObjectiveAward
from badgebook.serializers import BadgeObjectiveAwardSerializer
try:
award = BadgeObjectiveAward.cached.get(
badge_instance_id=instance.id)
except BadgeObjectiveAward.DoesNotExist:
representation['award'] = None
else:
representation['award'] = BadgeObjectiveAwardSerializer(
award).data
except ImportError:
pass
return representation
def create(self, validated_data):
"""
Requires self.context to include request (with authenticated request.user)
and badgeclass: issuer.models.BadgeClass.
"""
badgeclass = self.context['request'].data.get('badgeclass')
enrollment = StudentsEnrolled.objects.get(
entity_id=validated_data.get('enrollment_entity_id'))
expires_at = None
if badgeclass.expiration_period:
expires_at = datetime.datetime.now().replace(
microsecond=0, second=0, minute=0,
hour=0) + badgeclass.expiration_period
if enrollment.badge_instance:
raise BadgrValidationError(
"Can't award enrollment, it has already been awarded", 213)
if self.context['request'].data.get('issue_signed', False):
assertion = badgeclass.issue_signed(
recipient=enrollment.user,
created_by=self.context.get('request').user,
allow_uppercase=validated_data.get('allow_uppercase'),
recipient_type=validated_data.get(
'recipient_type', BadgeInstance.RECIPIENT_TYPE_EDUID),
expires_at=expires_at,
extensions=validated_data.get('extension_items', None),
identifier=uuid.uuid4().urn,
signer=validated_data.get('created_by'),
# evidence=validated_data.get('evidence_items', None) # Dont forget this one when you re-implement signing
# narrative=validated_data.get('narrative', None) # idem
)
else:
assertion = badgeclass.issue(
recipient=enrollment.user,
created_by=self.context.get('request').user,
allow_uppercase=validated_data.get('allow_uppercase'),
recipient_type=validated_data.get(
'recipient_type', BadgeInstance.RECIPIENT_TYPE_EDUID),
expires_at=expires_at,
extensions=validated_data.get('extension_items', None),
evidence=validated_data.get('evidence_items', None),
narrative=validated_data.get('narrative', None))
enrollment.date_awarded = timezone.now()
enrollment.badge_instance = assertion
enrollment.save()
enrollment.user.remove_cached_data(['cached_pending_enrollments'])
# delete the pending direct awards for this badgeclass and this user
badgeclass.cached_pending_direct_awards().filter(
eppn__in=enrollment.user.eppns).delete()
return assertion
class BadgeClassSerializer(OriginalJsonSerializerMixin, ExtensionsSaverMixin,
InternalValueErrorOverrideMixin,
serializers.Serializer):
created_at = serializers.DateTimeField(read_only=True)
created_by = BadgeUserIdentifierField()
name = StripTagsCharField(max_length=255)
image = ValidImageField(required=True)
formal = serializers.BooleanField(required=True)
is_private = serializers.BooleanField(required=False, default=False)
narrative_required = serializers.BooleanField(required=False,
default=False)
evidence_required = serializers.BooleanField(required=False, default=False)
entity_id = StripTagsCharField(max_length=255, read_only=True)
issuer = IssuerSlugRelatedField(slug_field='entity_id', required=True)
criteria = MarkdownCharField(allow_blank=True,
required=False,
write_only=True)
criteria_text = MarkdownCharField(required=False,
allow_null=True,
allow_blank=True)
criteria_url = StripTagsCharField(required=False,
allow_blank=True,
allow_null=True,
validators=[URLValidator()])
description = StripTagsCharField(max_length=16384,
required=True,
convert_null=True)
alignments = AlignmentItemSerializer(many=True,
source='alignment_items',
required=False)
tags = serializers.ListField(child=StripTagsCharField(max_length=1024),
source='tag_items',
required=False)
extensions = serializers.DictField(source='extension_items',
required=False,
validators=[BadgeExtensionValidator()])
expiration_period = PeriodField(required=False)
award_allowed_institutions = PrimaryKeyRelatedField(
many=True, queryset=Institution.objects.all(), required=False)
class Meta:
apispec_definition = ('BadgeClass', {})
def get_expiration_period(self, instance):
if instance.expiration_period:
return instance.expiration_period.days
def to_representation(self, instance):
representation = super(BadgeClassSerializer,
self).to_representation(instance)
representation['issuer'] = OriginSetting.HTTP + reverse(
'issuer_json',
kwargs={'entity_id': instance.cached_issuer.entity_id})
representation['json'] = instance.get_json(obi_version='1_1',
use_canonical_id=True)
return representation
def validate_image(self, image):
if image is not None:
img_name, img_ext = os.path.splitext(image.name)
image.name = 'issuer_badgeclass_' + str(uuid.uuid4()) + img_ext
image = resize_image(image)
app = BadgrApp.objects.get_current(
self.context.get('request', None))
if app.is_demo_environment:
image = add_watermark(image)
if verify_svg(image):
image = scrub_svg_image(image)
return image
def validate_criteria_text(self, criteria_text):
if criteria_text is not None and criteria_text != '':
return criteria_text
else:
return None
def validate_criteria_url(self, criteria_url):
if criteria_url is not None and criteria_url != '':
return criteria_url
else:
return None
def validate_name(self, name):
return strip_tags(name)
def validate_description(self, description):
return strip_tags(description)
def validate_extensions(self, extensions):
is_formal = False
if extensions:
for ext_name, ext in extensions.items():
if "@context" in ext and not ext['@context'].startswith(
settings.EXTENSIONS_ROOT_URL):
raise BadgrValidationError(
error_code=999,
error_message=
f"extensions @context invalid {ext['@context']}")
if ext_name.endswith('ECTSExtension') or ext_name.endswith(
'StudyLoadExtension'):
is_formal = True
self.formal = is_formal
return extensions
def add_extensions(self, instance, add_these_extensions, extension_items):
for extension_name in add_these_extensions:
original_json = extension_items[extension_name]
extension = BadgeClassExtension(
name=extension_name,
original_json=json.dumps(original_json),
badgeclass_id=instance.pk)
extension.save()
def update(self, instance, validated_data):
if instance.assertions and len(
[ass for ass in instance.assertions if not ass.revoked]) > 0:
raise BadgrValidationError(
error_code=999,
error_message=
"Cannot change any value, assertions have already been issued")
self.save_extensions(validated_data, instance)
for key, value in validated_data.items():
if key is not 'award_allowed_institutions':
setattr(instance, key, value)
instance.award_allowed_institutions.set(
validated_data.get('award_allowed_institutions', []))
try:
instance.save()
except IntegrityError:
raise BadgrValidationFieldError(
'name',
"There is already a Badgeclass with this name inside this Issuer",
911)
return instance
def validate_alignments(self, alignments):
alignment_max = 8
if alignments.__len__() >= alignment_max:
raise BadgrValidationFieldError(
'alignments',
"There are too many Related educational framework objects, the maximum is {}."
.format(str(alignment_max), 922))
return alignments
def to_internal_value_error_override(self, data):
"""Function used in combination with the InternalValueErrorOverrideMixin to override serializer excpetions when
data is internalised (i.e. the to_internal_value() method is called)"""
errors = OrderedDict()
if not data.get('criteria_text', False) and not data.get(
'criteria_url', False):
e = OrderedDict([
('criteria_text', [
ErrorDetail(
'Either criteria_url or criteria_text is required',
code=905)
]),
('criteria_url', [
ErrorDetail(
'Either criteria_url or criteria_text is required',
code=905)
])
])
errors = OrderedDict(chain(errors.items(), e.items()))
if data.get('criteria_url', False):
if not utils.is_probable_url(data.get('criteria_url')):
e = OrderedDict([
('criteria_url',
[ErrorDetail('Must be a proper url.', code=902)])
])
errors = OrderedDict(chain(errors.items(), e.items()))
if data.get('name') == settings.EDUID_BADGE_CLASS_NAME:
e = OrderedDict([('name', [
ErrorDetail(
f"{settings.EDUID_BADGE_CLASS_NAME} is a reserved name for badgeclasses",
code=907)
])])
errors = OrderedDict(chain(errors.items(), e.items()))
return errors
def create(self, validated_data, **kwargs):
user_permissions = validated_data['issuer'].get_permissions(
validated_data['created_by'])
if user_permissions['may_create']:
if validated_data['formal'] and not validated_data[
'issuer'].faculty.institution.grondslag_formeel:
raise BadgrValidationError(
"Cannot create a formal badgeclass for an institution without the judicial basis for formal badges",
215)
if not validated_data['formal'] and not validated_data[
'issuer'].faculty.institution.grondslag_informeel:
raise BadgrValidationError(
"Cannot create an informal badgeclass for an institution without the judicial basis for informal badges",
216)
try:
new_badgeclass = BadgeClass.objects.create(**validated_data)
except IntegrityError:
raise BadgrValidationFieldError(
'name',
"There is already a Badgeclass with this name inside this Issuer",
911)
return new_badgeclass
else:
raise BadgrValidationError(
"You don't have the necessary permissions", 100)
class BadgeClassSerializerV1(OriginalJsonSerializerMixin, ExtensionsSaverMixin,
serializers.Serializer):
created_at = DateTimeWithUtcZAtEndField(read_only=True)
created_by = BadgeUserIdentifierFieldV1()
id = serializers.IntegerField(required=False, read_only=True)
name = StripTagsCharField(max_length=255)
image = ValidImageField(required=False)
slug = StripTagsCharField(max_length=255,
read_only=True,
source='entity_id')
criteria = MarkdownCharField(allow_blank=True,
required=False,
write_only=True)
criteria_text = MarkdownCharField(required=False,
allow_null=True,
allow_blank=True)
criteria_url = StripTagsCharField(required=False,
allow_blank=True,
allow_null=True,
validators=[URLValidator()])
recipient_count = serializers.IntegerField(required=False,
read_only=True,
source='v1_api_recipient_count')
description = StripTagsCharField(max_length=16384,
required=True,
convert_null=True)
alignment = AlignmentItemSerializerV1(many=True,
source='alignment_items',
required=False)
tags = serializers.ListField(child=StripTagsCharField(max_length=1024),
source='tag_items',
required=False)
extensions = serializers.DictField(source='extension_items',
required=False,
validators=[BadgeExtensionValidator()])
expires = BadgeClassExpirationSerializerV1(source='*',
required=False,
allow_null=True)
# issuerName = StripTagsCharField(max_length=255)
class Meta:
apispec_definition = ('BadgeClass', {})
def to_internal_value(self, data):
if 'expires' in data:
if not data['expires'] or len(data['expires']) == 0:
# if expires was included blank, remove it so to_internal_value() doesnt choke
del data['expires']
return super(BadgeClassSerializerV1, self).to_internal_value(data)
def to_representation(self, instance):
representation = super(BadgeClassSerializerV1,
self).to_representation(instance)
representation['issuerName'] = instance.cached_issuer.name
representation['issuer'] = OriginSetting.HTTP + reverse(
'issuer_json',
kwargs={'entity_id': instance.cached_issuer.entity_id})
representation['json'] = instance.get_json(obi_version='1_1',
use_canonical_id=True)
return representation
def validate_image(self, image):
if image is not None:
img_name, img_ext = os.path.splitext(image.name)
image.name = 'issuer_badgeclass_' + str(uuid.uuid4()) + img_ext
return image
def validate_criteria_text(self, criteria_text):
if criteria_text is not None and criteria_text != '':
return criteria_text
else:
return None
def validate_criteria_url(self, criteria_url):
if criteria_url is not None and criteria_url != '':
return criteria_url
else:
return None
def validate_extensions(self, extensions):
is_formal = False
if extensions:
for ext_name, ext in extensions.items():
# if "@context" in ext and not ext['@context'].startswith(settings.EXTENSIONS_ROOT_URL):
# raise BadgrValidationError(
# error_code=999,
# error_message=f"extensions @context invalid {ext['@context']}")
if ext_name.endswith('ECTSExtension') or ext_name.endswith(
'StudyLoadExtension') or ext_name.endswith(
'CategoryExtension') or ext_name.endswith(
'LevelExtension'):
is_formal = True
self.formal = is_formal
return extensions
def add_extensions(self, instance, add_these_extensions, extension_items):
for extension_name in add_these_extensions:
original_json = extension_items[extension_name]
extension = BadgeClassExtension(
name=extension_name,
original_json=json.dumps(original_json),
badgeclass_id=instance.pk)
extension.save()
def update(self, instance, validated_data):
logger.info("UPDATE BADGECLASS")
logger.debug(validated_data)
force_image_resize = False
new_name = validated_data.get('name')
if new_name:
new_name = strip_tags(new_name)
instance.name = new_name
new_description = validated_data.get('description')
if new_description:
instance.description = strip_tags(new_description)
# Assure both criteria_url and criteria_text will not be empty
if 'criteria_url' in validated_data or 'criteria_text' in validated_data:
end_criteria_url = validated_data['criteria_url'] if 'criteria_url' in validated_data \
else instance.criteria_url
end_criteria_text = validated_data['criteria_text'] if 'criteria_text' in validated_data \
else instance.criteria_text
if ((end_criteria_url is None or not end_criteria_url.strip()) and
(end_criteria_text is None or not end_criteria_text.strip())):
raise serializers.ValidationError(
'Changes cannot be made that would leave both criteria_url and criteria_text blank.'
)
else:
instance.criteria_text = end_criteria_text
instance.criteria_url = end_criteria_url
if 'image' in validated_data:
instance.image = validated_data.get('image')
force_image_resize = True
instance.alignment_items = validated_data.get('alignment_items')
instance.tag_items = validated_data.get('tag_items')
instance.expires_amount = validated_data.get('expires_amount', None)
instance.expires_duration = validated_data.get('expires_duration',
None)
logger.debug("SAVING EXTENSION")
self.save_extensions(validated_data, instance)
instance.save(force_resize=force_image_resize)
return instance
def validate(self, data):
if 'criteria' in data:
if 'criteria_url' in data or 'criteria_text' in data:
raise serializers.ValidationError(
"The criteria field is mutually-exclusive with the criteria_url and criteria_text fields"
)
if utils.is_probable_url(data.get('criteria')):
data['criteria_url'] = data.pop('criteria')
elif not isinstance(data.get('criteria'), str):
raise serializers.ValidationError(
"Provided criteria text could not be properly processed as URL or plain text."
)
else:
data['criteria_text'] = data.pop('criteria')
return data
def create(self, validated_data, **kwargs):
logger.info("CREATE NEW BADGECLASS")
logger.debug(validated_data)
if 'image' not in validated_data:
raise serializers.ValidationError(
{"image": ["This field is required"]})
if 'issuer' in self.context:
validated_data['issuer'] = self.context.get('issuer')
if validated_data.get('criteria_text',
None) is None and validated_data.get(
'criteria_url', None) is None:
raise serializers.ValidationError(
"One or both of the criteria_text and criteria_url fields must be provided"
)
new_badgeclass = BadgeClass.objects.create(**validated_data)
return new_badgeclass
class BackpackCollectionSerializerV2(DetailSerializerV2):
name = serializers.CharField()
description = MarkdownCharField(required=False)
owner = EntityRelatedFieldV2(read_only=True, source='created_by')
share_url = serializers.URLField(read_only=True)
shareHash = serializers.CharField(read_only=True, source='share_hash')
published = serializers.BooleanField(required=False)
assertions = EntityRelatedFieldV2(many=True,
source='badge_items',
required=False,
queryset=BadgeInstance.cached)
class Meta(DetailSerializerV2.Meta):
model = BackpackCollection
apispec_definition = ('Collection', {
'properties':
OrderedDict([
('entityId', {
'type': "string",
'format': "string",
'description': "Unique identifier for this Collection",
}),
('entityType', {
'type': "string",
'format': "string",
'description': "\"Collection\"",
}),
('createdAt', {
'type': 'string',
'format': 'ISO8601 timestamp',
'description': "Timestamp when the Collection was created",
}),
('createdBy', {
'type': 'string',
'format': 'entityId',
'description': "BadgeUser who created this Collection",
}),
('name', {
'type': "string",
'format': "string",
'description': "Name of the Collection",
}),
('description', {
'type': "string",
'format': "text",
'description': "Short description of the Collection",
}),
('share_url', {
'type':
"string",
'format':
"url",
'description':
"A public URL for sharing the Collection. Read only.",
}),
('shareHash', {
'type':
"string",
'format':
"url",
'description':
"The share hash that allows construction of a public sharing URL. Read only.",
}),
('published', {
'type':
"boolean",
'description':
"True if the Collection has a public share URL",
}),
('assertions', {
'type': "array",
'items': {
'$ref': '#/definitions/Assertion'
},
'description': "List of Assertions in the collection",
}),
])
})
class BackpackAssertionSerializerV2(DetailSerializerV2,
OriginalJsonSerializerMixin):
acceptance = serializers.ChoiceField(
choices=BadgeInstance.ACCEPTANCE_CHOICES,
default=BadgeInstance.ACCEPTANCE_ACCEPTED)
# badgeinstance
openBadgeId = serializers.URLField(source='jsonld_id', read_only=True)
badgeclass = EntityRelatedFieldV2(source='cached_badgeclass',
required=False,
queryset=BadgeClass.cached)
badgeclassOpenBadgeId = serializers.URLField(source='badgeclass_jsonld_id',
read_only=True)
issuer = EntityRelatedFieldV2(source='cached_issuer',
required=False,
queryset=Issuer.cached)
issuerOpenBadgeId = serializers.URLField(source='issuer_jsonld_id',
read_only=True)
image = serializers.FileField(read_only=True)
recipient = BadgeRecipientSerializerV2(source='*')
issuedOn = DateTimeWithUtcZAtEndField(source='issued_on', read_only=True)
narrative = MarkdownCharField(required=False)
evidence = EvidenceItemSerializerV2(many=True, required=False)
revoked = HumanReadableBooleanField(read_only=True)
revocationReason = serializers.CharField(source='revocation_reason',
read_only=True)
expires = DateTimeWithUtcZAtEndField(source='expires_at', required=False)
pending = serializers.ReadOnlyField()
class Meta(DetailSerializerV2.Meta):
model = BadgeInstance
apispec_definition = ('BackpackAssertion', {
'properties':
OrderedDict([
('entityId', {
'type': "string",
'format': "string",
'description': "Unique identifier for this Issuer",
'readOnly': True,
}),
('entityType', {
'type': "string",
'format': "string",
'description': "\"Issuer\"",
'readOnly': True,
}),
('openBadgeId', {
'type': "string",
'format': "url",
'description': "URL of the OpenBadge compliant json",
'readOnly': True,
}),
('badgeclass', {
'type': 'string',
'format': 'entityId',
'description': "BadgeClass that issued this Assertion",
'required': False,
}),
('badgeclassOpenBadgeId', {
'type': 'string',
'format': 'url',
'description': "URL of the BadgeClass to award",
'readOnly': True,
}),
('image', {
'type': 'string',
'format': 'url',
'description': "URL to the baked assertion image",
'readOnly': True,
}),
('recipient', {
'type':
'object',
'properties':
OrderedDict([
('identity', {
'type': 'string',
'format': 'string',
'description':
'Either the hash of the identity or the plaintext value',
'required': True,
}),
('type', {
'type':
'string',
'enum': [
c[0]
for c in BadgeInstance.RECIPIENT_TYPE_CHOICES
],
'description':
"Type of identifier used to identify recipient",
'required':
False,
}),
('hashed', {
'type': 'boolean',
'description':
"Whether or not the identity value is hashed.",
'required': False,
}),
('plaintextIdentity', {
'type': 'string',
'description': "The plaintext identity",
'required': False,
}),
]),
'description':
"Recipient that was issued the Assertion",
'required':
True,
}),
('issuedOn', {
'type': 'string',
'format': 'ISO8601 timestamp',
'description': "Timestamp when the Assertion was issued",
'required': True,
}),
('narrative', {
'type': 'string',
'format': 'markdown',
'description': "Markdown narrative of the achievement",
'required': False,
}),
('evidence', {
'type': 'array',
'items': {
'$ref': '#/definitions/AssertionEvidence'
},
'description':
"List of evidence associated with the achievement",
'required': False,
}),
('revoked', {
'type': 'boolean',
'description': "True if this Assertion has been revoked",
'readOnly': True,
}),
('revocationReason', {
'type': 'string',
'format': "string",
'description':
"Short description of why the Assertion was revoked",
'readOnly': True,
}),
('expires', {
'type': 'string',
'format': 'ISO8601 timestamp',
'description': "Timestamp when the Assertion expires",
'required': False,
}),
])
})
def to_representation(self, instance):
representation = super(BackpackAssertionSerializerV2,
self).to_representation(instance)
request_kwargs = self.context['kwargs']
expands = request_kwargs.get('expands', [])
if self.parent is not None:
# we'll have a bare representation
instance_data_pointer = representation
else:
instance_data_pointer = representation['result'][0]
if 'badgeclass' in expands:
instance_data_pointer[
'badgeclass'] = instance.cached_badgeclass.get_json(
include_extra=True, use_canonical_id=True)
if 'issuer' in expands:
instance_data_pointer['badgeclass'][
'issuer'] = instance.cached_issuer.get_json(
include_extra=True, use_canonical_id=True)
return representation
class BadgeClassSerializerV1(OriginalJsonSerializerMixin,
serializers.Serializer):
created_at = DateTimeWithUtcZAtEndField(read_only=True)
created_by = BadgeUserIdentifierFieldV1()
id = serializers.IntegerField(required=False, read_only=True)
name = StripTagsCharField(max_length=255)
image = ValidImageField(required=False)
slug = StripTagsCharField(max_length=255,
read_only=True,
source='entity_id')
criteria = MarkdownCharField(allow_blank=True,
required=False,
write_only=True)
criteria_text = MarkdownCharField(required=False,
allow_null=True,
allow_blank=True)
criteria_url = StripTagsCharField(required=False,
allow_blank=True,
allow_null=True,
validators=[URLValidator()])
recipient_count = serializers.IntegerField(required=False, read_only=True)
pathway_element_count = serializers.IntegerField(required=False,
read_only=True)
description = StripTagsCharField(max_length=16384,
required=True,
convert_null=True)
alignment = AlignmentItemSerializerV1(many=True,
source='alignment_items',
required=False)
tags = serializers.ListField(child=StripTagsCharField(max_length=1024),
source='tag_items',
required=False)
expires = BadgeClassExpirationSerializerV1(source='*',
required=False,
allow_null=True)
class Meta:
apispec_definition = ('BadgeClass', {})
def to_internal_value(self, data):
if 'expires' in data:
if not data['expires'] or len(data['expires']) == 0:
# if expires was included blank, remove it so to_internal_value() doesnt choke
del data['expires']
return super(BadgeClassSerializerV1, self).to_internal_value(data)
def to_representation(self, instance):
representation = super(BadgeClassSerializerV1,
self).to_representation(instance)
representation['issuer'] = OriginSetting.HTTP + reverse(
'issuer_json',
kwargs={'entity_id': instance.cached_issuer.entity_id})
representation['json'] = instance.get_json(obi_version='1_1',
use_canonical_id=True)
return representation
def validate_image(self, image):
if image is not None:
img_name, img_ext = os.path.splitext(image.name)
image.name = 'issuer_badgeclass_' + str(uuid.uuid4()) + img_ext
return image
def validate_criteria_text(self, criteria_text):
if criteria_text is not None and criteria_text != '':
return criteria_text
else:
return None
def validate_criteria_url(self, criteria_url):
if criteria_url is not None and criteria_url != '':
return criteria_url
else:
return None
def update(self, instance, validated_data):
force_image_resize = False
new_name = validated_data.get('name')
if new_name:
new_name = strip_tags(new_name)
instance.name = new_name
new_description = validated_data.get('description')
if new_description:
instance.description = strip_tags(new_description)
if 'criteria_text' in validated_data:
instance.criteria_text = validated_data.get('criteria_text')
if 'criteria_url' in validated_data:
instance.criteria_url = validated_data.get('criteria_url')
if 'image' in validated_data:
instance.image = validated_data.get('image')
force_image_resize = True
instance.alignment_items = validated_data.get('alignment_items')
instance.tag_items = validated_data.get('tag_items')
instance.expires_amount = validated_data.get('expires_amount', None)
instance.expires_duration = validated_data.get('expires_duration',
None)
instance.save(force_resize=force_image_resize)
return instance
def validate(self, data):
if 'criteria' in data:
if 'criteria_url' in data or 'criteria_text' in data:
raise serializers.ValidationError(
"The criteria field is mutually-exclusive with the criteria_url and criteria_text fields"
)
if utils.is_probable_url(data.get('criteria')):
data['criteria_url'] = data.pop('criteria')
elif not isinstance(data.get('criteria'), str):
raise serializers.ValidationError(
"Provided criteria text could not be properly processed as URL or plain text."
)
else:
data['criteria_text'] = data.pop('criteria')
else:
if data.get('criteria_text', None) is None and data.get(
'criteria_url', None) is None:
raise serializers.ValidationError(
"One or both of the criteria_text and criteria_url fields must be provided"
)
return data
def create(self, validated_data, **kwargs):
if 'image' not in validated_data:
raise serializers.ValidationError(
{"image": ["This field is required"]})
if 'issuer' in self.context:
validated_data['issuer'] = self.context.get('issuer')
new_badgeclass = BadgeClass.objects.create(**validated_data)
return new_badgeclass
class BadgeClassSerializerV2(DetailSerializerV2, OriginalJsonSerializerMixin):
openBadgeId = serializers.URLField(source='jsonld_id', read_only=True)
createdAt = serializers.DateTimeField(source='created_at', read_only=True)
createdBy = EntityRelatedFieldV2(source='cached_creator', read_only=True)
issuer = EntityRelatedFieldV2(source='cached_issuer',
required=False,
queryset=Issuer.cached)
issuerOpenBadgeId = serializers.URLField(source='issuer_jsonld_id',
read_only=True)
name = StripTagsCharField(max_length=1024)
image = ValidImageField(required=False)
description = StripTagsCharField(max_length=16384,
required=True,
convert_null=True)
criteriaUrl = StripTagsCharField(source='criteria_url',
required=False,
allow_null=True,
validators=[URLValidator()])
criteriaNarrative = MarkdownCharField(source='criteria_text',
required=False,
allow_null=True)
alignments = AlignmentItemSerializerV2(source='alignment_items',
many=True,
required=False)
tags = serializers.ListField(child=StripTagsCharField(max_length=1024),
source='tag_items',
required=False)
extensions = serializers.DictField(source='extension_items',
required=False,
validators=[BadgeExtensionValidator()])
class Meta(DetailSerializerV2.Meta):
model = BadgeClass
apispec_definition = ('BadgeClass', {
'properties':
OrderedDict([
('entityId', {
'type': "string",
'format': "string",
'description': "Unique identifier for this BadgeClass",
}),
('entityType', {
'type': "string",
'format': "string",
'description': "\"BadgeClass\"",
}),
('openBadgeId', {
'type': "string",
'format': "url",
'description': "URL of the OpenBadge compliant json",
}),
('createdAt', {
'type': 'string',
'format': 'ISO8601 timestamp',
'description': "Timestamp when the BadgeClass was created",
}),
('createdBy', {
'type': 'string',
'format': 'entityId',
'description': "BadgeUser who created this BadgeClass",
}),
('issuer', {
'type':
'string',
'format':
'entityId',
'description':
"entityId of the Issuer who owns the BadgeClass",
}),
('name', {
'type': "string",
'format': "string",
'description': "Name of the BadgeClass",
}),
('description', {
'type': "string",
'format': "string",
'description': "Short description of the BadgeClass",
}),
('image', {
'type':
"string",
'format':
"data:image/png;base64",
'description':
"Base64 encoded string of an image that represents the BadgeClass.",
}),
('criteriaUrl', {
'type':
"string",
'format':
"url",
'description':
"External URL that describes in a human-readable format the criteria for the BadgeClass"
}),
('criteriaNarrative', {
'type':
"string",
'format':
"markdown",
'description':
"Markdown formatted description of the criteria"
}),
('tags', {
'type': "array",
'items': {
'type': "string",
'format': "string"
},
'description': "List of tags that describe the BadgeClass"
}),
('alignments', {
'type':
"array",
'items': {
'$ref': '#/definitions/BadgeClassAlignment'
},
'description':
"List of objects describing objectives or educational standards"
}),
])
})
def update(self, instance, validated_data):
if 'cached_issuer' in validated_data:
validated_data.pop('cached_issuer') # issuer is not updatable
return super(BadgeClassSerializerV2,
self).update(instance, validated_data)
def create(self, validated_data):
if 'cached_issuer' in validated_data:
# included issuer in request
validated_data['issuer'] = validated_data.pop('cached_issuer')
elif 'issuer' in self.context:
# issuer was passed in context
validated_data['issuer'] = self.context.get('issuer')
else:
# issuer is required on create
raise serializers.ValidationError(
{"issuer": "This field is required"})
return super(BadgeClassSerializerV2, self).create(validated_data)
class BadgeConnectAssertionSerializer(BadgeConnectBaseEntitySerializer):
id = serializers.URLField(source='jsonld_id', read_only=True)
badge = serializers.URLField(source='badgeclass_jsonld_id', read_only=True)
image = serializers.FileField(read_only=True)
recipient = BadgeRecipientSerializerV2(source='*')
issuedOn = serializers.DateTimeField(source='issued_on', read_only=True)
narrative = MarkdownCharField(required=False)
evidence = EvidenceItemSerializerV2(many=True, required=False)
revoked = HumanReadableBooleanField(read_only=True)
revocationReason = serializers.CharField(source='revocation_reason', read_only=True)
expires = serializers.DateTimeField(source='expires_at', required=False)
type = serializers.CharField(read_only=True, default='Assertion')
class Meta:
SCHEMA_TYPE = 'Assertion'
model = BadgeInstance
apispec_definition = ('BadgeConnectAssertion', {
'properties': OrderedDict([
('id', {
'type': "string",
'format': "url",
'readOnly': True,
'description': "URL of the BadgeInstance",
}),
('badge', {
'type': "string",
'format': "url",
'readOnly': True,
'description': "URL of the BadgeClass",
}),
('image', {
'type': "string",
'format': "string",
'readOnly': True,
'description': "Badge Image",
}),
('recipient', {
'type': 'object',
'properties': BadgeRecipientSerializerV2.Meta.apispec_definition[1]['properties'],
'readOnly': True,
'description': "Recipient that was issued the Assertion"
}),
('issuedOn', {
'type': 'string',
'format': 'ISO8601 timestamp',
'readOnly': True,
'description': "Timestamp when the Assertion was issued",
}),
('narrative', {
'type': 'string',
'format': 'markdown',
'description': "Markdown narrative of the achievement",
}),
('evidence', {
'type': "string",
'format': "string",
'description': "Unique identifier for this Assertion",
}),
('revoked', {
'type': 'boolean',
'readOnly': True,
'description': "True if this Assertion has been revoked",
}),
('revocationReason', {
'type': 'string',
'format': "string",
'readOnly': True,
'description': "Short description of why the Assertion was revoked",
}),
('expires', {
'type': 'string',
'format': 'ISO8601 timestamp',
'description': "Timestamp when the Assertion expires",
}),
('@context', {
'type': 'string',
'format': 'url',
'default': CONTEXT_URI,
'example': CONTEXT_URI,
}),
('type', {
'type': 'string',
'default': SCHEMA_TYPE,
'example': SCHEMA_TYPE
})
])
})
class BadgeInstanceSerializerV2(DetailSerializerV2,
OriginalJsonSerializerMixin):
openBadgeId = serializers.URLField(source='jsonld_id', read_only=True)
createdAt = serializers.DateTimeField(source='created_at', read_only=True)
createdBy = EntityRelatedFieldV2(source='cached_creator', read_only=True)
badgeclass = EntityRelatedFieldV2(source='cached_badgeclass',
required=False,
queryset=BadgeClass.cached)
badgeclassOpenBadgeId = CachedUrlHyperlinkedRelatedField(
source='badgeclass_jsonld_id',
view_name='badgeclass_json',
lookup_field='entity_id',
queryset=BadgeClass.cached,
required=False)
issuer = EntityRelatedFieldV2(source='cached_issuer',
required=False,
queryset=Issuer.cached)
issuerOpenBadgeId = serializers.URLField(source='issuer_jsonld_id',
read_only=True)
image = serializers.FileField(read_only=True)
recipient = BadgeRecipientSerializerV2(source='*', required=False)
issuedOn = serializers.DateTimeField(source='issued_on', required=False)
narrative = MarkdownCharField(required=False, allow_null=True)
evidence = EvidenceItemSerializerV2(source='evidence_items',
many=True,
required=False)
revoked = HumanReadableBooleanField(read_only=True)
revocationReason = serializers.CharField(source='revocation_reason',
read_only=True)
expires = serializers.DateTimeField(source='expires_at',
required=False,
allow_null=True)
notify = HumanReadableBooleanField(write_only=True,
required=False,
default=False)
extensions = serializers.DictField(source='extension_items',
required=False,
validators=[BadgeExtensionValidator()])
class Meta(DetailSerializerV2.Meta):
model = BadgeInstance
apispec_definition = ('Assertion', {
'properties':
OrderedDict([
('entityId', {
'type': "string",
'format': "string",
'description': "Unique identifier for this Assertion",
}),
('entityType', {
'type': "string",
'format': "string",
'description': "\"Assertion\"",
}),
('openBadgeId', {
'type': "string",
'format': "url",
'description': "URL of the OpenBadge compliant json",
}),
('createdAt', {
'type': 'string',
'format': 'ISO8601 timestamp',
'description': "Timestamp when the Assertion was created",
}),
('createdBy', {
'type': 'string',
'format': 'entityId',
'description': "BadgeUser who created the Assertion",
}),
('badgeclass', {
'type': 'string',
'format': 'entityId',
'description': "BadgeClass that issued this Assertion",
}),
('badgeclassOpenBadgeId', {
'type': 'string',
'format': 'url',
'description': "URL of the BadgeClass to award",
}),
('revoked', {
'type': 'boolean',
'description': "True if this Assertion has been revoked",
}),
('revocationReason', {
'type':
'string',
'format':
"string",
'description':
"Short description of why the Assertion was revoked",
}),
('image', {
'type': 'string',
'format': 'url',
'description': "URL to the baked assertion image",
}),
('issuedOn', {
'type': 'string',
'format': 'ISO8601 timestamp',
'description': "Timestamp when the Assertion was issued",
}),
('narrative', {
'type': 'string',
'format': 'markdown',
'description': "Markdown narrative of the achievement",
}),
('evidence', {
'type':
'array',
'items': {
'$ref': '#/definitions/AssertionEvidence'
},
'description':
"List of evidence associated with the achievement"
}),
('recipient', {
'type':
'object',
'properties':
OrderedDict([
('identity', {
'type':
'string',
'format':
'string',
'description':
'Either the hash of the identity or the plaintext value'
}),
('type', {
'type':
'string',
'enum': [
c[0]
for c in BadgeInstance.RECIPIENT_TYPE_CHOICES
],
'description':
"Type of identifier used to identify recipient"
}),
('hashed', {
'type':
'boolean',
'description':
"Whether or not the identity value is hashed."
}),
('plaintextIdentity', {
'type': 'string',
'description': "The plaintext identity"
}),
]),
'description':
"Recipient that was issued the Assertion"
}),
('expires', {
'type': 'string',
'format': 'ISO8601 timestamp',
'description': "Timestamp when the Assertion expires",
}),
])
})
def update(self, instance, validated_data):
updateable_fields = [
'evidence_items', 'expires_at', 'extension_items', 'hashed',
'issued_on', 'narrative', 'recipient_identifier', 'recipient_type'
]
for field_name in updateable_fields:
if field_name in validated_data:
setattr(instance, field_name, validated_data.get(field_name))
instance.save()
instance.rebake()
return instance
def validate(self, data):
request = self.context.get('request', None)
if request and request.method != 'PUT':
# recipient and badgeclass are only required on create, ignored on update
if 'recipient_identifier' not in data:
raise serializers.ValidationError(
{'recipient_identifier': ["This field is required"]})
if 'cached_badgeclass' in data:
# included badgeclass in request
data['badgeclass'] = data.pop('cached_badgeclass')
elif 'badgeclass' in self.context:
# badgeclass was passed in context
data['badgeclass'] = self.context.get('badgeclass')
elif 'badgeclass_jsonld_id' in data:
data['badgeclass'] = data.pop('badgeclass_jsonld_id')
else:
raise serializers.ValidationError(
{"badgeclass": ["This field is required"]})
expected_issuer = self.context.get('kwargs', {}).get('issuer')
if expected_issuer and data['badgeclass'].issuer != expected_issuer:
raise serializers.ValidationError({
"badgeclass":
["Could not find matching badgeclass for this issuer."]
})
if 'badgeclass' in data:
data['issuer'] = data['badgeclass'].issuer
return data
