Example #1
0
    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
Example #2
0
    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)
Example #3
0
    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)
Example #4
0
    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
Example #5
0
    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
Example #6
0
    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',
        )
Example #7
0
    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