def comparison(cls, comparison, **kwargs):
result = cls.basic_attempt(comparison, None, **kwargs)
result.extensions = Extensions() if not result.extensions else result.extensions
winner = "Undecided"
if comparison.winner == WinningAnswer.draw:
winner = "Draw"
elif comparison.winner == WinningAnswer.answer1:
winner = ResourceIRI.answer(comparison.course_uuid, comparison.assignment_uuid, comparison.answer1_uuid)
elif comparison.winner == WinningAnswer.answer2:
winner = ResourceIRI.answer(comparison.course_uuid, comparison.assignment_uuid, comparison.answer2_uuid)
result.response = winner
result.extensions['http://xapi.learninganalytics.ubc.ca/extension/criteria'] = {}
for comparison_criterion in comparison.comparison_criteria:
winner = "Undecided"
if comparison_criterion.winner == WinningAnswer.answer1:
winner = ResourceIRI.answer(comparison.course_uuid, comparison.assignment_uuid, comparison.answer1_uuid)
elif comparison_criterion.winner == WinningAnswer.answer2:
winner = ResourceIRI.answer(comparison.course_uuid, comparison.assignment_uuid, comparison.answer2_uuid)
result.extensions['http://xapi.learninganalytics.ubc.ca/extension/criteria'][
ResourceIRI.criterion(comparison_criterion.criterion_uuid)] = winner
return result
def membership(cls, course, user):
roles = []
extensions = {}
course_role = user.get_course_role(course.id)
if course_role in [
CourseRole.instructor, CourseRole.teaching_assistant
]:
roles.append("Instructor")
if course_role == CourseRole.teaching_assistant:
roles.append("Instructor#TeachingAssistant")
if course_role == CourseRole.student:
roles.append("Learner")
if user.system_role == SystemRole.sys_admin:
roles.append("Administrator")
if course.lti_has_sis_data:
sis_data = course.lti_sis_data
extensions['sis_courses'] = []
for sis_course_id, sis_section_ids in sis_data.items():
extensions['sis_courses'].append({
'id': sis_course_id,
'section_ids': sis_section_ids
})
return caliper.entities.Membership(
id=ResourceIRI.user_membership(course.uuid, user.uuid),
member=CaliperActor.generate_actor(user),
organization=ResourceIRI.course(course.uuid),
roles=roles if len(roles) > 0 else None,
status="Active"
if course_role != CourseRole.dropped else "Inactive",
extensions=extensions)
def _add_default(cls, user, statement):
if not statement.timestamp:
statement.timestamp = LearningRecord.generate_timestamp()
if impersonation.is_impersonating() and user.id == current_user.id:
statement.actor = XAPIActor.generate_actor(
impersonation.get_impersonation_original_user())
else:
statement.actor = XAPIActor.generate_actor(user)
# add default context info
if not statement.context:
statement.context = Context()
if not statement.context.context_activities:
statement.context.context_activities = ContextActivities()
if not statement.context.context_activities.category:
statement.context.context_activities.category = ActivityList()
statement.context.context_activities.category.append(
XAPIActivity.compair_source())
statement.context.platform = ResourceIRI.compair()
if not statement.context.extensions:
statement.context.extensions = Extensions()
statement.context.extensions[
'http://id.tincanapi.com/extension/session-info'] = {
'id': ResourceIRI.user_session(sess.get('session_id', '')),
'start_at': sess.get('start_at'),
'login_method': sess.get('login_method'),
}
if sess.get('end_at'):
statement.context.extensions[
'http://id.tincanapi.com/extension/session-info'][
'end_at'] = sess.get('end_at')
if impersonation.is_impersonating() and user.id == current_user.id:
statement.context.extensions[
'http://id.tincanapi.com/extension/session-info'][
'impersonating-as'] = XAPIActor.generate_actor(
user).as_version()
statement.context.extensions[
'http://id.tincanapi.com/extension/browser-info'] = {}
if request and request.environ.get('HTTP_USER_AGENT'):
statement.context.extensions[
'http://id.tincanapi.com/extension/browser-info'][
'user-agent'] = request.environ.get('HTTP_USER_AGENT')
if request and request.environ.get('HTTP_REFERER'):
statement.context.extensions[
'http://id.tincanapi.com/extension/browser-info'][
'referer'] = request.environ.get('HTTP_REFERER')
return statement
def answer(cls, answer):
attempt = None
extensions = {
"isDraft": answer.draft,
}
if answer.attempt_uuid:
attempt = CaliperEntities.answer_attempt(answer)
extensions.update(cls._basic_content_extension(answer.content))
if answer.score:
score = answer.score
score_details = {
"algorithm": score.scoring_algorithm.value,
"score": score.score,
"wins": score.wins,
"loses": score.loses,
"rounds": score.rounds,
"opponents": score.opponents,
"criteria": {}
}
if score.scoring_algorithm == ScoringAlgorithm.true_skill:
score_details['mu'] = score.variable1
score_details['sigma'] = score.variable2
extensions["scoreDetails"] = score_details
for criterion_score in answer.criteria_scores:
score_details = {
"score": criterion_score.score,
"wins": criterion_score.wins,
"loses": criterion_score.loses,
"rounds": criterion_score.rounds,
"opponents": criterion_score.opponents,
}
if criterion_score.scoring_algorithm == ScoringAlgorithm.true_skill:
score_details["mu"] = criterion_score.variable1
score_details["sigma"] = criterion_score.variable2
extensions["scoreDetails"]["criteria"][ResourceIRI.criterion(
criterion_score.criterion_uuid)] = score_details
return caliper.entities.Response(
id=ResourceIRI.answer(answer.course_uuid, answer.assignment_uuid,
answer.uuid),
attempt=attempt,
dateCreated=answer.created.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z',
dateModified=answer.modified.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z',
extensions=extensions)
def answer(cls, answer):
ret = {
"id": ResourceIRI.answer(answer.course_uuid, answer.assignment_uuid, answer.uuid),
"type": CALIPER_ENTITY_TYPES["RESPONSE"],
"dateCreated": answer.created.replace(tzinfo=pytz.utc).isoformat(),
"dateModified": answer.modified.replace(tzinfo=pytz.utc).isoformat(),
"extensions": {
"isDraft": answer.draft
}
}
ret["extensions"].update(cls._basic_content_extension(answer.content))
if answer.attempt_uuid:
ret["attempt"] = CaliperEntities.answer_attempt(answer)
if answer.score:
score = answer.score
score_details = {
"algorithm": score.scoring_algorithm.value,
"score": score.score,
"wins": score.wins,
"loses": score.loses,
"rounds": score.rounds,
"opponents": score.opponents,
"criteria": {}
}
if score.scoring_algorithm == ScoringAlgorithm.true_skill:
score_details['mu'] = score.variable1
score_details['sigma'] = score.variable2
ret["extensions"]["scoreDetails"] = score_details
for criterion_score in answer.criteria_scores:
score_details = {
"score": criterion_score.score,
"wins": criterion_score.wins,
"loses": criterion_score.loses,
"rounds": criterion_score.rounds,
"opponents": criterion_score.opponents,
}
if criterion_score.scoring_algorithm == ScoringAlgorithm.true_skill:
score_details["mu"] = criterion_score.variable1
score_details["sigma"] = criterion_score.variable2
ret["extensions"]["scoreDetails"]["criteria"][ResourceIRI.criterion(criterion_score.criterion_uuid)] = score_details
return ret
def comparison(cls, comparison, current_comparison=None):
attempt = None
extensions = {
"pairingAlgorithm":
comparison.pairing_algorithm.value,
"winner":
"Undecided",
"criteria": {},
"answers": [
ResourceIRI.answer(comparison.course_uuid,
comparison.assignment_uuid,
comparison.answer1_uuid),
ResourceIRI.answer(comparison.course_uuid,
comparison.assignment_uuid,
comparison.answer2_uuid)
],
"completed":
comparison.completed
}
if comparison.winner == WinningAnswer.draw:
extensions["winner"] = "Draw"
elif comparison.winner == WinningAnswer.answer1:
extensions["winner"] = ResourceIRI.answer(
comparison.course_uuid, comparison.assignment_uuid,
comparison.answer1_uuid)
elif comparison.winner == WinningAnswer.answer2:
extensions["winner"] = ResourceIRI.answer(
comparison.course_uuid, comparison.assignment_uuid,
comparison.answer2_uuid)
if comparison.attempt_uuid and current_comparison:
attempt = CaliperEntities.comparison_attempt(
comparison, current_comparison)
for comparison_criterion in comparison.comparison_criteria:
winner = "Undecided"
if comparison_criterion.winner == WinningAnswer.answer1:
winner = ResourceIRI.answer(comparison.course_uuid,
comparison.assignment_uuid,
comparison.answer1_uuid)
elif comparison_criterion.winner == WinningAnswer.answer2:
winner = ResourceIRI.answer(comparison.course_uuid,
comparison.assignment_uuid,
comparison.answer2_uuid)
extensions["criteria"][ResourceIRI.criterion(
comparison_criterion.criterion_uuid)] = winner
return caliper.entities.Response(
id=ResourceIRI.comparison(comparison.course_uuid,
comparison.assignment_uuid,
comparison.uuid),
attempt=attempt,
dateCreated=comparison.created.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z',
dateModified=comparison.modified.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z',
extensions=extensions)
def answer_comment(cls, answer_comment):
return caliper.entities.Comment(
id=ResourceIRI.answer_comment(answer_comment.course_uuid,
answer_comment.assignment_uuid,
answer_comment.answer_uuid,
answer_comment.uuid),
commenter=CaliperActor.generate_actor(answer_comment.user),
commentedOn=CaliperEntities.answer(answer_comment.answer),
value=LearningRecord.trim_text_to_size_limit(
answer_comment.content),
dateCreated=answer_comment.created.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z',
dateModified=answer_comment.modified.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z',
extensions={
"type":
answer_comment.comment_type.value,
"isDraft":
answer_comment.draft,
"characterCount":
LearningRecord.character_count(answer_comment.content)
if answer_comment.content else 0,
"wordCount":
LearningRecord.word_count(answer_comment.content)
if answer_comment.content else 0
})
def self_evaluation_question(cls, assignment):
dateToStartOn = assignment.answer_end.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'
dateToSubmit = None
description = None
if assignment.self_eval_start and assignment.self_eval_end:
dateToStartOn = assignment.self_eval_start.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'
dateToSubmit = assignment.self_eval_end.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'
elif assignment.compare_start and assignment.compare_end:
dateToStartOn = assignment.answer_end.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'
if assignment.self_eval_instructions:
description = LearningRecord.trim_text_to_size_limit(
assignment.self_eval_instructions)
return caliper.entities.AssessmentItem(
id=ResourceIRI.self_evaluation_question(assignment.course_uuid,
assignment.uuid),
name="Assignment self-evaluation",
description=description,
dateToStartOn=dateToStartOn,
dateToSubmit=dateToSubmit,
isPartOf=CaliperEntities.assignment(assignment),
dateCreated=assignment.created.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z',
dateModified=assignment.modified.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z')
def compair_app(cls):
return caliper.entities.SoftwareApplication(
id=ResourceIRI.compair(),
name="ComPAIR",
description=
"The ComPAIR learning application pairs student answers for deeper learning through comparison of peer work.",
version=text_type(current_app.config.get('COMPAIR_VERSION', '')))
def evaluation_question(cls, assignment, evaluation_number):
dateToStartOn = assignment.answer_end.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'
dateToSubmit = None
description = None
if assignment.compare_start and assignment.compare_end:
dateToStartOn = assignment.compare_start.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'
dateToSubmit = assignment.compare_end.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'
if assignment.peer_feedback_prompt:
description = LearningRecord.trim_text_to_size_limit(
assignment.peer_feedback_prompt)
return caliper.entities.AssessmentItem(
id=ResourceIRI.evaluation_question(assignment.course_uuid,
assignment.uuid,
evaluation_number),
name="Assignment Answer Evaluation #" + str(evaluation_number),
description=description,
dateToStartOn=dateToStartOn,
dateToSubmit=dateToSubmit,
isPartOf=CaliperEntities.assignment(assignment),
dateCreated=assignment.created.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z',
dateModified=assignment.modified.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z')
def course(cls, course):
otherIdentifiers = []
if course.lti_linked:
for lti_context in course.lti_contexts:
lti_consumer = lti_context.lti_consumer
otherIdentifiers.append(
caliper.entities.SystemIdentifier(
identifier=lti_context.context_id,
identifierType=CALIPER_SYSTEM_TYPES['LTI_CONTEXT_ID'],
source=lti_consumer.tool_consumer_instance_url,
extensions={
"oauth_consumer_key":
lti_consumer.oauth_consumer_key,
"tool_consumer_instance_guid":
lti_consumer.tool_consumer_instance_guid,
"tool_consumer_instance_name":
lti_consumer.tool_consumer_instance_name,
"lis_course_offering_sourcedid":
lti_context.lis_course_offering_sourcedid,
"lis_course_section_sourcedid":
lti_context.lis_course_section_sourcedid,
}))
return caliper.entities.CourseOffering(
id=ResourceIRI.course(course.uuid),
academicSession=course.term,
name=LearningRecord.trim_text_to_size_limit(course.name),
dateCreated=course.created.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z',
dateModified=course.modified.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z',
otherIdentifiers=otherIdentifiers)
def group(cls, group):
members = [
CaliperActor.generate_actor(uc.user)
for uc in group.user_courses.all()
]
return caliper.entities.Group(
id=ResourceIRI.group(group.course_uuid, group.uuid),
name=group.name,
subOrganizationOf=ResourceIRI.course(group.course_uuid),
members=members,
dateCreated=group.created.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z',
dateModified=group.modified.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z',
)
def _defaults(cls, user, course=None):
caliper_actor = CaliperActor.generate_actor(user)
if impersonation.is_impersonating() and user.id == current_user.id:
caliper_actor = CaliperActor.generate_actor(impersonation.get_impersonation_original_user())
defaults = {
'context': CaliperSensor._version,
'eventTime': LearningRecord.generate_timestamp(),
'actor': caliper_actor,
'edApp': ResourceIRI.compair()
}
session = CaliperEntities.session(caliper_actor)
if request:
session.setdefault("extensions", {}).setdefault("browser-info", {})
if request.environ.get('HTTP_USER_AGENT'):
session["extensions"]["browser-info"]["userAgent"] = request.environ.get('HTTP_USER_AGENT')
if request.environ.get('HTTP_REFERER'):
session["extensions"]["browser-info"]["referer"] = request.environ.get('HTTP_REFERER')
if impersonation.is_impersonating() and user.id == current_user.id:
session["extensions"]["impersonating-as"] = CaliperActor.generate_actor(user)
defaults['session'] = session
if course:
defaults['membership'] = CaliperEntities.membership(course, user)
return defaults
def _generate_global_unique_identifier_account(cls, user):
external_id = user.global_unique_identifier
homepage = current_app.config.get(
'LRS_ACTOR_ACCOUNT_GLOBAL_UNIQUE_IDENTIFIER_HOMEPAGE')
if not external_id or not homepage:
return cls._generate_compair_account(user)
if not homepage.endswith('/'):
homepage += '/'
return caliper.entities.Person(
id=homepage + external_id,
name=user.fullname,
dateCreated=user.created.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z',
dateModified=user.modified.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z',
otherIdentifiers=cls._generate_other_identifiers(user) + [
caliper.entities.SystemIdentifier(
identifier=external_id,
identifierType=CALIPER_SYSTEM_TYPES['SIS_SOURCEDID'],
source=homepage),
caliper.entities.SystemIdentifier(
identifier=user.uuid,
identifierType=CALIPER_SYSTEM_TYPES['SYSTEM_ID'],
source=ResourceIRI.compair())
])
def course(cls, course):
ret = {
"id": ResourceIRI.course(course.uuid),
"type": CALIPER_ENTITY_TYPES["COURSE_OFFERING"],
"academicSession": course.term,
"name": LearningRecord.trim_text_to_size_limit(course.name),
"dateCreated": course.created.replace(tzinfo=pytz.utc).isoformat(),
"dateModified": course.modified.replace(tzinfo=pytz.utc).isoformat(),
"extensions": {}
}
if course.lti_linked:
ret["extensions"]["ltiContexts"] = []
for lti_context in course.lti_contexts:
lti_consumer = lti_context.lti_consumer
ret["extensions"]["ltiContexts"].append({
"oauth_consumer_key": lti_consumer.oauth_consumer_key,
"tool_consumer_instance_guid": lti_consumer.tool_consumer_instance_guid,
"tool_consumer_instance_name": lti_consumer.tool_consumer_instance_name,
"tool_consumer_instance_url": lti_consumer.tool_consumer_instance_url,
"lis_course_offering_sourcedid": lti_context.lis_course_offering_sourcedid,
"lis_course_section_sourcedid": lti_context.lis_course_section_sourcedid,
"context_id": lti_context.context_id
})
return ret
def report(cls, file_name, mimetype):
return {
"id": ResourceIRI.report(file_name),
"type": CALIPER_ENTITY_TYPES["DOCUMENT"],
"name": file_name,
"mediaType": mimetype,
}
def self_evaluation_question(cls, assignment):
return Activity(
id=ResourceIRI.self_evaluation_question(assignment.course_uuid,
assignment.uuid),
definition=ActivityDefinition(
type=XAPIActivity.activity_types.get('question'),
name=LanguageMap({'en-US': "Assignment self-evaluation"})))
def _defaults(cls, user, course=None):
caliper_actor = CaliperActor.generate_actor(user)
if impersonation.is_impersonating() and user.id == current_user.id:
caliper_actor = CaliperActor.generate_actor(
impersonation.get_impersonation_original_user())
defaults = {
'context': CaliperSensor._version,
'eventTime': LearningRecord.generate_timestamp(),
'actor': caliper_actor,
'edApp': ResourceIRI.compair()
}
session = CaliperEntities.session(caliper_actor)
if request:
session.setdefault("extensions", {}).setdefault("browser-info", {})
if request.environ.get('HTTP_USER_AGENT'):
session["extensions"]["browser-info"][
"userAgent"] = request.environ.get('HTTP_USER_AGENT')
if request.environ.get('HTTP_REFERER'):
session["extensions"]["browser-info"][
"referer"] = request.environ.get('HTTP_REFERER')
if impersonation.is_impersonating() and user.id == current_user.id:
session["extensions"][
"impersonating-as"] = CaliperActor.generate_actor(user)
defaults['session'] = session
if course:
defaults['membership'] = CaliperEntities.membership(course, user)
return defaults
def _add_default(cls, user, statement):
if not statement.timestamp:
statement.timestamp = LearningRecord.generate_timestamp()
if impersonation.is_impersonating() and user.id == current_user.id:
statement.actor = XAPIActor.generate_actor(impersonation.get_impersonation_original_user())
else:
statement.actor = XAPIActor.generate_actor(user)
# add default context info
if not statement.context:
statement.context = Context()
if not statement.context.context_activities:
statement.context.context_activities = ContextActivities()
if not statement.context.context_activities.category:
statement.context.context_activities.category = ActivityList()
statement.context.context_activities.category.append(
XAPIActivity.compair_source()
)
statement.context.platform = ResourceIRI.compair()
if not statement.context.extensions:
statement.context.extensions = Extensions()
statement.context.extensions['http://id.tincanapi.com/extension/session-info'] = {
'id': ResourceIRI.user_session(sess.get('session_id', '')),
'start_at': sess.get('start_at'),
'login_method': sess.get('login_method'),
}
if sess.get('end_at'):
statement.context.extensions['http://id.tincanapi.com/extension/session-info']['end_at'] = sess.get('end_at')
if impersonation.is_impersonating() and user.id == current_user.id:
statement.context.extensions['http://id.tincanapi.com/extension/session-info']['impersonating-as'] = XAPIActor.generate_actor(user)
statement.context.extensions['http://id.tincanapi.com/extension/browser-info'] = {}
if request and request.environ.get('HTTP_USER_AGENT'):
statement.context.extensions['http://id.tincanapi.com/extension/browser-info']['user-agent'] = request.environ.get('HTTP_USER_AGENT')
if request and request.environ.get('HTTP_REFERER'):
statement.context.extensions['http://id.tincanapi.com/extension/browser-info']['referer'] = request.environ.get('HTTP_REFERER')
return statement
def _generate_compair_account(cls, user):
return {
"id": ResourceIRI.actor_homepage() + user.uuid,
"type": CALIPER_ENTITY_TYPES["PERSON"],
"name": user.fullname,
"dateCreated": user.created.replace(tzinfo=pytz.utc).isoformat(),
"dateModified": user.modified.replace(tzinfo=pytz.utc).isoformat(),
}
def compair_app(cls):
return {
"id": ResourceIRI.compair(),
"type": CALIPER_ENTITY_TYPES["SOFTWARE_APPLICATION"],
"name": "ComPAIR",
"description": "The ComPAIR learning application pairs student answers for deeper learning through comparison of peer work.",
"version": current_app.config.get('COMPAIR_VERSION')
}
def comparison_question(cls, assignment, comparison_number):
return Activity(
id=ResourceIRI.comparison_question(assignment.course_uuid, assignment.uuid, comparison_number),
definition=ActivityDefinition(
type=XAPIActivity.activity_types.get('question'),
name=LanguageMap({ 'en-US': "Assignment comparison #"+str(comparison_number) })
)
)
def self_evaluation_question(cls, assignment):
return Activity(
id=ResourceIRI.self_evaluation_question(assignment.course_uuid, assignment.uuid),
definition=ActivityDefinition(
type=XAPIActivity.activity_types.get('question'),
name=LanguageMap({ 'en-US': "Assignment self-evaluation" })
)
)
def _generate_compair_account(cls, user):
return {
"id": ResourceIRI.actor_homepage()+user.uuid,
"type": CALIPER_ENTITY_TYPES["PERSON"],
"name": user.fullname,
"dateCreated": user.created.replace(tzinfo=pytz.utc).isoformat(),
"dateModified": user.modified.replace(tzinfo=pytz.utc).isoformat(),
}
def _generate_compair_account(cls, user):
return caliper.entities.Person(
id=ResourceIRI.actor_homepage() + user.uuid,
name=user.fullname,
dateCreated=user.created.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z',
dateModified=user.modified.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z',
otherIdentifiers=cls._generate_other_identifiers(user))
def criterion(cls, criterion):
return {
"id": ResourceIRI.criterion(criterion.uuid),
"type": CALIPER_ENTITY_TYPES["ENTITY"],
"name": LearningRecord.trim_text_to_size_limit(criterion.name),
"description": LearningRecord.trim_text_to_size_limit(criterion.description),
"dateCreated": criterion.created.replace(tzinfo=pytz.utc).isoformat(),
"dateModified": criterion.modified.replace(tzinfo=pytz.utc).isoformat(),
}
def assignment_attempt(cls, assignment, attempt_mixin_object, user):
ret = {
"id": ResourceIRI.assignment_attempt(assignment.course_uuid, assignment.uuid, attempt_mixin_object.attempt_uuid),
"type": CALIPER_ENTITY_TYPES["ATTEMPT"],
"assignee": CaliperActor.generate_actor(user),
"assignable": CaliperEntities.assignment(assignment),
}
ret.update(cls._basic_attempt(attempt_mixin_object))
return ret
def report(cls, file_name, mimetype):
activity = Activity(id=ResourceIRI.report(file_name),
definition=ActivityDefinition(
type=XAPIActivity.activity_types.get('file'),
name=LanguageMap({'en-US': file_name}),
extensions=Extensions()))
activity.definition.extensions[
'http://id.tincanapi.com/extension/mime-type'] = mimetype
return activity
def answer_attachment(cls, answer, file, mimetype):
return {
"id": ResourceIRI.attachment(file.name),
"type": CALIPER_ENTITY_TYPES["DOCUMENT"],
"name": file.alias,
"mediaType": mimetype,
"isPartOf": CaliperEntities.answer(answer),
"dateCreated": file.created.replace(tzinfo=pytz.utc).isoformat(),
"dateModified": file.modified.replace(tzinfo=pytz.utc).isoformat()
}
def _add_sis_data(cls, context, course):
if course.lti_has_sis_data:
if not context.context_activities:
context.context_activities = ContextActivities()
if not context.context_activities.grouping:
context.context_activities.grouping = ActivityList()
sis_data = course.lti_sis_data
for sis_course_id, sis_section_ids in sis_data.items():
context.context_activities.grouping.append({
"id": ResourceIRI.sis_course(sis_course_id),
"objectType": "Activity"
})
for sis_section_id in sis_section_ids:
context.context_activities.grouping.append({
"id": ResourceIRI.sis_section(sis_course_id, sis_section_id),
"objectType": "Activity"
})
def criterion(cls, criterion):
return caliper.entities.DigitalResource(
id=ResourceIRI.criterion(criterion.uuid),
name=LearningRecord.trim_text_to_size_limit(criterion.name),
description=LearningRecord.trim_text_to_size_limit(
criterion.description),
dateCreated=criterion.created.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z',
dateModified=criterion.modified.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z')
def comparison_attempt(cls, comparison, current_comparison):
ret = {
"id": ResourceIRI.comparison_attempt(comparison.course_uuid, comparison.assignment_uuid, current_comparison, comparison.attempt_uuid),
"type": CALIPER_ENTITY_TYPES["ATTEMPT"],
"assignee": CaliperActor.generate_actor(comparison.user),
"assignable": CaliperEntities.comparison_question(comparison.assignment, current_comparison),
}
ret.update(cls._basic_attempt(comparison))
return ret
def client(cls, request):
if not request:
return None
return caliper.entities.SoftwareApplication(
id=ResourceIRI.user_client(sess.get('session_id', '')),
userAgent=text_type(request.environ.get('HTTP_USER_AGENT', '')),
ipAddress=text_type(request.environ.get('REMOTE_ADDR', '')),
host=text_type(request.environ.get('HTTP_HOST', '')),
)
def answer_attachment(cls, answer, file, mimetype):
return caliper.entities.Document(
id=ResourceIRI.attachment(file.name),
name=file.alias,
mediaType=mimetype,
isPartOf=CaliperEntities.answer(answer),
dateCreated=file.created.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z',
dateModified=file.modified.replace(
tzinfo=pytz.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z')
def answer_attempt(cls, answer):
ret = {
"id": ResourceIRI.answer_attempt(answer.course_uuid, answer.assignment_uuid, answer.attempt_uuid),
"type": CALIPER_ENTITY_TYPES["ATTEMPT"],
"assignee": CaliperActor.generate_actor(answer.user),
"assignable": CaliperEntities.assignment_question(answer.assignment),
}
ret.update(cls._basic_attempt(answer))
return ret
def course(cls, course):
activity = Activity(
id=ResourceIRI.course(course.uuid),
definition=ActivityDefinition(
type=XAPIActivity.activity_types.get('course'),
name=LanguageMap({ 'en-US': LearningRecord.trim_text_to_size_limit(course.name) })
)
)
return activity
def membership(cls, course, user):
membership = {
"id": ResourceIRI.user_membership(course.uuid, user.uuid),
"type": CALIPER_ENTITY_TYPES["MEMBERSHIP"],
"member": CaliperActor.generate_actor(user),
"organization": ResourceIRI.course(course.uuid),
"status": "Active",
"extensions": {}
}
roles = []
course_role = user.get_course_role(course.id)
if course_role in [CourseRole.instructor, CourseRole.teaching_assistant]:
roles.append("Instructor")
if course_role == CourseRole.teaching_assistant:
roles.append("Instructor#TeachingAssistant")
if course_role == CourseRole.student:
roles.append("Learner")
if user.system_role == SystemRole.sys_admin:
roles.append("Administrator")
if len(roles) > 0:
membership["roles"] = roles
if course_role == CourseRole.dropped:
membership['status'] = "Inactive"
if course.lti_has_sis_data:
sis_data = course.lti_sis_data
membership['extensions']['sis_courses'] = []
membership['extensions']['sis_sections'] = []
for sis_course_id, sis_section_ids in sis_data.items():
membership['extensions']['sis_courses'].append(ResourceIRI.sis_course(sis_course_id))
for sis_section_id in sis_section_ids:
membership['extensions']['sis_sections'].append(ResourceIRI.sis_section(sis_course_id, sis_section_id))
sis_course_id = list(sis_data.keys())[0]
sis_section_id = sis_data[sis_course_id][0]
membership['organization'] = cls.course_section(sis_course_id, sis_section_id)
return membership
def assignment_attempt(cls, assignment, attempt_mixin_object):
activity = Activity(
id=ResourceIRI.assignment_attempt(assignment.course_uuid, assignment.uuid, attempt_mixin_object.attempt_uuid),
definition=ActivityDefinition(
type=XAPIActivity.activity_types.get('attempt'),
extensions=Extensions()
)
)
activity.definition.extensions["http://id.tincanapi.com/extension/attempt"] = cls._basic_attempt(attempt_mixin_object)
return activity
def answer(cls, answer):
activity = Activity(
id=ResourceIRI.answer(answer.course_uuid, answer.assignment_uuid, answer.uuid),
definition=ActivityDefinition(
type=XAPIActivity.activity_types.get('solution'),
extensions=Extensions()
)
)
activity.definition.extensions['http://id.tincanapi.com/extension/isDraft'] = answer.draft
return activity
def report(cls, file_name, mimetype):
activity = Activity(
id=ResourceIRI.report(file_name),
definition=ActivityDefinition(
type=XAPIActivity.activity_types.get('file'),
name=LanguageMap({ 'en-US': file_name }),
extensions=Extensions()
)
)
activity.definition.extensions['http://id.tincanapi.com/extension/mime-type'] = mimetype
return activity
def compair(cls):
activity = Activity(
id=ResourceIRI.compair(),
definition=ActivityDefinition(
type=XAPIActivity.activity_types.get('service'),
name=LanguageMap({ 'en-US': "ComPAIR" }),
extensions=Extensions()
)
)
activity.definition.extensions['http://id.tincanapi.com/extension/version'] = current_app.config.get('COMPAIR_VERSION')
return activity
def comparison_attempt(cls, comparison, current_comparison):
activity = Activity(
id=ResourceIRI.comparison_attempt(comparison.course_uuid, comparison.assignment_uuid,
current_comparison, comparison.attempt_uuid),
definition=ActivityDefinition(
type=XAPIActivity.activity_types.get('attempt'),
extensions=Extensions()
)
)
activity.definition.extensions["http://id.tincanapi.com/extension/attempt"] = cls._basic_attempt(comparison)
return activity
def self_evaluation_attempt(cls, answer_comment):
activity = Activity(
id=ResourceIRI.self_evaluation_attempt(answer_comment.course_uuid, answer_comment.assignment_uuid,
answer_comment.attempt_uuid),
definition=ActivityDefinition(
type=XAPIActivity.activity_types.get('attempt'),
description=LanguageMap({ 'en-US': LearningRecord.trim_text_to_size_limit(answer_comment.content) }),
extensions=Extensions()
)
)
activity.definition.extensions["http://id.tincanapi.com/extension/attempt"] = cls._basic_attempt(answer_comment)
return activity
def self_evaluation_response(cls, answer_comment):
activity = Activity(
id=ResourceIRI.self_evaluation_response(answer_comment.course_uuid, answer_comment.assignment_uuid,
answer_comment.answer_uuid, answer_comment.uuid),
definition=ActivityDefinition(
type=XAPIActivity.activity_types.get('solution'),
extensions=Extensions()
)
)
activity.definition.extensions['http://id.tincanapi.com/extension/isDraft'] = answer_comment.draft
return activity
def comparison(cls, comparison):
activity = Activity(
id=ResourceIRI.comparison(comparison.course_uuid, comparison.assignment_uuid, comparison.uuid),
definition=ActivityDefinition(
type=XAPIActivity.activity_types.get('solution'),
name=LanguageMap({ 'en-US': "Assignment comparison" }),
extensions=Extensions()
)
)
activity.definition.extensions['http://id.tincanapi.com/extension/completed'] = comparison.completed
return activity
def assignment_question(cls, assignment):
activity = Activity(
id=ResourceIRI.assignment_question(assignment.course_uuid, assignment.uuid),
definition=ActivityDefinition(
type=XAPIActivity.activity_types.get('question'),
name=LanguageMap({ 'en-US': LearningRecord.trim_text_to_size_limit(assignment.name) })
)
)
if assignment.description:
activity.definition.description = LanguageMap({
'en-US': LearningRecord.trim_text_to_size_limit(assignment.description)
})
return activity
def criterion(cls, criterion):
activity = Activity(
id=ResourceIRI.criterion(criterion.uuid),
definition=ActivityDefinition(
type=XAPIActivity.activity_types.get('question'),
name=LanguageMap({ 'en-US': LearningRecord.trim_text_to_size_limit(criterion.name) })
)
)
if criterion.description:
activity.definition.description = LanguageMap({
'en-US': LearningRecord.trim_text_to_size_limit(criterion.description)
})
return activity
def answer_comment(cls, answer_comment):
activity = Activity(
id=ResourceIRI.answer_comment(answer_comment.course_uuid, answer_comment.assignment_uuid,
answer_comment.answer_uuid, answer_comment.uuid),
definition=ActivityDefinition(
type=XAPIActivity.activity_types.get('comment'),
name=LanguageMap({ 'en-US': "Assignment answer comment" }),
extensions=Extensions()
)
)
activity.definition.extensions['http://id.tincanapi.com/extension/type'] = answer_comment.comment_type.value
activity.definition.extensions['http://id.tincanapi.com/extension/isDraft'] = answer_comment.draft
return activity
def evaluation_response(cls, answer_comment):
activity = Activity(
id=ResourceIRI.evaluation_response(answer_comment.course_uuid, answer_comment.assignment_uuid,
answer_comment.answer_uuid, answer_comment.uuid),
definition=ActivityDefinition(
type=XAPIActivity.activity_types.get('solution'),
description=LanguageMap({ 'en-US': LearningRecord.trim_text_to_size_limit(answer_comment.content) }),
extensions=Extensions()
)
)
activity.definition.extensions['http://id.tincanapi.com/extension/isDraft'] = answer_comment.draft
return activity