class Migration(migrations.Migration): dependencies = [] operations = [ migrations.CreateModel( name='CourseOverview', fields=[ ('id', CourseKeyField(max_length=255, serialize=False, primary_key=True, db_index=True)), ('_location', UsageKeyField(max_length=255)), ('display_name', models.TextField(null=True)), ('display_number_with_default', models.TextField()), ('display_org_with_default', models.TextField()), ('start', models.DateTimeField(null=True)), ('end', models.DateTimeField(null=True)), ('advertised_start', models.TextField(null=True)), ('course_image_url', models.TextField()), ('facebook_url', models.TextField(null=True)), ('social_sharing_url', models.TextField(null=True)), ('end_of_course_survey_url', models.TextField(null=True)), ('certificates_display_behavior', models.TextField(null=True)), ('certificates_show_before_end', models.BooleanField(default=False)), ('has_any_active_web_certificate', models.BooleanField(default=False)), ('cert_name_short', models.TextField()), ('cert_name_long', models.TextField()), ('lowest_passing_grade', models.DecimalField(null=True, max_digits=5, decimal_places=2)), ('mobile_available', models.BooleanField(default=False)), ('visible_to_staff_only', models.BooleanField(default=False)), ('_pre_requisite_courses_json', models.TextField()), ], ), ]
class BlockCompletion(TimeStampedModel, models.Model): """ Track completion of completable blocks. A completion is unique for each (user, course_key, block_key). The block_type field is included separately from the block_key to facilitate distinct aggregations of the completion of particular types of block. The completion value is stored as a float in the range [0.0, 1.0], and all calculations are performed on this float, though current practice is to only track binary completion, where 1.0 indicates that the block is complete, and 0.0 indicates that the block is incomplete. """ id = BigAutoField(primary_key=True) # pylint: disable=invalid-name user = models.ForeignKey(User) course_key = CourseKeyField(max_length=255) block_key = UsageKeyField(max_length=255) block_type = models.CharField(max_length=64) completion = models.FloatField(validators=[validate_percent]) objects = BlockCompletionManager() class Meta(object): index_together = [ ('course_key', 'block_type', 'user'), ('user', 'course_key', 'modified'), ] unique_together = [('course_key', 'block_key', 'user')] def __unicode__(self): return 'BlockCompletion: {username}, {course_key}, {block_key}: {completion}'.format( username=self.user.username, course_key=self.course_key, block_key=self.block_key, completion=self.completion, )
class GradedAssignment(models.Model): """ Model representing a single launch of a graded assignment by an individual user. There will be a row created here only if the LTI consumer may require a result to be returned from the LTI launch (determined by the presence of the lis_result_sourcedid parameter in the launch POST). There will be only one row created for a given usage/consumer combination; repeated launches of the same content by the same user from the same LTI consumer will not add new rows to the table. Some LTI-specified fields use the prefix lis_; this refers to the IMS Learning Information Services standard from which LTI inherits some properties """ user = models.ForeignKey(User, db_index=True) course_key = CourseKeyField(max_length=255, db_index=True) usage_key = UsageKeyField(max_length=255, db_index=True) outcome_service = models.ForeignKey(OutcomeService) lis_result_sourcedid = models.CharField(max_length=255, db_index=True) version_number = models.IntegerField(default=0) class Meta(object): unique_together = ('outcome_service', 'lis_result_sourcedid')
class PersistentSubsectionGrade(DeleteGradesMixin, TimeStampedModel): """ A django model tracking persistent grades at the subsection level. """ class Meta(object): app_label = "grades" unique_together = [ # * Specific grades can be pulled using all three columns, # * Progress page can pull all grades for a given (course_id, user_id) # * Course staff can see all grades for a course using (course_id,) ('course_id', 'user_id', 'usage_key'), ] # Allows querying in the following ways: # (modified): find all the grades updated within a certain timespan # (modified, course_id): find all the grades updated within a timespan for a certain course # (modified, course_id, usage_key): find all the grades updated within a timespan for a subsection # in a course # (first_attempted, course_id, user_id): find all attempted subsections in a course for a user # (first_attempted, course_id): find all attempted subsections in a course for all users index_together = [ ('modified', 'course_id', 'usage_key'), ('first_attempted', 'course_id', 'user_id') ] # primary key will need to be large for this table id = UnsignedBigIntAutoField(primary_key=True) # pylint: disable=invalid-name user_id = models.IntegerField(blank=False) course_id = CourseKeyField(blank=False, max_length=255) # note: the usage_key may not have the run filled in for # old mongo courses. Use the full_usage_key property # instead when you want to use/compare the usage_key. usage_key = UsageKeyField(blank=False, max_length=255) # Information relating to the state of content when grade was calculated subtree_edited_timestamp = models.DateTimeField(u'Last content edit timestamp', blank=True, null=True) course_version = models.CharField(u'Guid of latest course version', blank=True, max_length=255) # earned/possible refers to the number of points achieved and available to achieve. # graded refers to the subset of all problems that are marked as being graded. earned_all = models.FloatField(blank=False) possible_all = models.FloatField(blank=False) earned_graded = models.FloatField(blank=False) possible_graded = models.FloatField(blank=False) # timestamp for the learner's first attempt at content in # this subsection. If null, indicates no attempt # has yet been made. first_attempted = models.DateTimeField(null=True, blank=True) # track which blocks were visible at the time of grade calculation visible_blocks = models.ForeignKey(VisibleBlocks, db_column='visible_blocks_hash', to_field='hashed') @property def full_usage_key(self): """ Returns the "correct" usage key value with the run filled in. """ if self.usage_key.run is None: # pylint: disable=no-member return self.usage_key.replace(course_key=self.course_id) else: return self.usage_key def __unicode__(self): """ Returns a string representation of this model. """ return ( u"{} user: {}, course version: {}, subsection: {} ({}). {}/{} graded, {}/{} all, first_attempted: {}" ).format( type(self).__name__, self.user_id, self.course_version, self.usage_key, self.visible_blocks_id, self.earned_graded, self.possible_graded, self.earned_all, self.possible_all, self.first_attempted, ) @classmethod def read_grade(cls, user_id, usage_key): """ Reads a grade from database Arguments: user_id: The user associated with the desired grade usage_key: The location of the subsection associated with the desired grade Raises PersistentSubsectionGrade.DoesNotExist if applicable """ return cls.objects.select_related('visible_blocks').get( user_id=user_id, course_id=usage_key.course_key, # course_id is included to take advantage of db indexes usage_key=usage_key, ) @classmethod def bulk_read_grades(cls, user_id, course_key): """ Reads all grades for the given user and course. Arguments: user_id: The user associated with the desired grades course_key: The course identifier for the desired grades """ return cls.objects.select_related('visible_blocks').filter( user_id=user_id, course_id=course_key, ) @classmethod def update_or_create_grade(cls, **params): """ Wrapper for objects.update_or_create. """ cls._prepare_params_and_visible_blocks(params) first_attempted = params.pop('first_attempted') user_id = params.pop('user_id') usage_key = params.pop('usage_key') grade, _ = cls.objects.update_or_create( user_id=user_id, course_id=usage_key.course_key, usage_key=usage_key, defaults=params, ) if first_attempted is not None and grade.first_attempted is None: if waffle.waffle().is_enabled(waffle.ESTIMATE_FIRST_ATTEMPTED): grade.first_attempted = first_attempted else: grade.first_attempted = now() grade.save() cls._emit_grade_calculated_event(grade) return grade @classmethod def _prepare_first_attempted_for_create(cls, params): """ Update the value of 'first_attempted' to now() if we aren't using score-based estimates. """ if params['first_attempted'] is not None and not waffle.waffle().is_enabled(waffle.ESTIMATE_FIRST_ATTEMPTED): params['first_attempted'] = now() @classmethod def create_grade(cls, **params): """ Wrapper for objects.create. """ cls._prepare_params_and_visible_blocks(params) cls._prepare_first_attempted_for_create(params) grade = cls.objects.create(**params) cls._emit_grade_calculated_event(grade) return grade @classmethod def bulk_create_grades(cls, grade_params_iter, course_key): """ Bulk creation of grades. """ if not grade_params_iter: return map(cls._prepare_params, grade_params_iter) VisibleBlocks.bulk_get_or_create([params['visible_blocks'] for params in grade_params_iter], course_key) map(cls._prepare_params_visible_blocks_id, grade_params_iter) map(cls._prepare_first_attempted_for_create, grade_params_iter) grades = [PersistentSubsectionGrade(**params) for params in grade_params_iter] grades = cls.objects.bulk_create(grades) for grade in grades: cls._emit_grade_calculated_event(grade) return grades @classmethod def _prepare_params_and_visible_blocks(cls, params): """ Prepares the fields for the grade record, while creating the related VisibleBlocks, if needed. """ cls._prepare_params(params) params['visible_blocks'] = VisibleBlocks.objects.create_from_blockrecords(params['visible_blocks']) @classmethod def _prepare_params(cls, params): """ Prepares the fields for the grade record. """ if not params.get('course_id', None): params['course_id'] = params['usage_key'].course_key params['course_version'] = params.get('course_version', None) or "" params['visible_blocks'] = BlockRecordList.from_list(params['visible_blocks'], params['course_id']) @classmethod def _prepare_params_visible_blocks_id(cls, params): """ Prepares the visible_blocks_id field for the grade record, using the hash of the visible_blocks field. Specifying the hashed field eliminates extra queries to get the VisibleBlocks record. Use this variation of preparing the params when you are sure of the existence of the VisibleBlock. """ params['visible_blocks_id'] = params['visible_blocks'].hash_value del params['visible_blocks'] @staticmethod def _emit_grade_calculated_event(grade): """ Emits an edx.grades.subsection.grade_calculated event with data from the passed grade. """ # TODO: remove this context manager after completion of AN-6134 event_name = u'edx.grades.subsection.grade_calculated' context = contexts.course_context_from_course_id(grade.course_id) with tracker.get_tracker().context(event_name, context): tracker.emit( event_name, { 'user_id': unicode(grade.user_id), 'course_id': unicode(grade.course_id), 'block_id': unicode(grade.usage_key), 'course_version': unicode(grade.course_version), 'weighted_total_earned': grade.earned_all, 'weighted_total_possible': grade.possible_all, 'weighted_graded_earned': grade.earned_graded, 'weighted_graded_possible': grade.possible_graded, 'first_attempted': unicode(grade.first_attempted), 'subtree_edited_timestamp': unicode(grade.subtree_edited_timestamp), 'event_transaction_id': unicode(get_event_transaction_id()), 'event_transaction_type': unicode(get_event_transaction_type()), 'visible_blocks_hash': unicode(grade.visible_blocks_id), } )
class CourseOverview(TimeStampedModel): """ Model for storing and caching basic information about a course. This model contains basic course metadata such as an ID, display name, image URL, and any other information that would be necessary to display a course as part of: user dashboard (enrolled courses) course catalog (courses to enroll in) course about (meta data about the course) """ class Meta(object): app_label = 'course_overviews' # IMPORTANT: Bump this whenever you modify this model and/or add a migration. VERSION = 6 # Cache entry versioning. version = IntegerField() # Course identification id = CourseKeyField(db_index=True, primary_key=True, max_length=255) _location = UsageKeyField(max_length=255) org = TextField(max_length=255, default='outdated_entry') display_name = TextField(null=True) display_number_with_default = TextField() display_org_with_default = TextField() # Start/end dates start = DateTimeField(null=True) end = DateTimeField(null=True) advertised_start = TextField(null=True) announcement = DateTimeField(null=True) # URLs course_image_url = TextField() social_sharing_url = TextField(null=True) end_of_course_survey_url = TextField(null=True) # Certification data certificates_display_behavior = TextField(null=True) certificates_show_before_end = BooleanField(default=False) cert_html_view_enabled = BooleanField(default=False) has_any_active_web_certificate = BooleanField(default=False) cert_name_short = TextField() cert_name_long = TextField() certificate_available_date = DateTimeField(default=None, null=True) # Grading lowest_passing_grade = DecimalField(max_digits=5, decimal_places=2, null=True) # Access parameters days_early_for_beta = FloatField(null=True) mobile_available = BooleanField(default=False) visible_to_staff_only = BooleanField(default=False) _pre_requisite_courses_json = TextField( ) # JSON representation of list of CourseKey strings # Enrollment details enrollment_start = DateTimeField(null=True) enrollment_end = DateTimeField(null=True) enrollment_domain = TextField(null=True) invitation_only = BooleanField(default=False) max_student_enrollments_allowed = IntegerField(null=True) # Catalog information catalog_visibility = TextField(null=True) short_description = TextField(null=True) course_video_url = TextField(null=True) effort = TextField(null=True) self_paced = BooleanField(default=False) marketing_url = TextField(null=True) eligible_for_financial_aid = BooleanField(default=True) language = TextField(null=True) @classmethod def _create_or_update(cls, course): """ Creates or updates a CourseOverview object from a CourseDescriptor. Does not touch the database, simply constructs and returns an overview from the given course. Arguments: course (CourseDescriptor): any course descriptor object Returns: CourseOverview: created or updated overview extracted from the given course """ from lms.djangoapps.certificates.api import get_active_web_certificate from openedx.core.lib.courses import course_image_url # Workaround for a problem discovered in https://openedx.atlassian.net/browse/TNL-2806. # If the course has a malformed grading policy such that # course._grading_policy['GRADE_CUTOFFS'] = {}, then # course.lowest_passing_grade will raise a ValueError. # Work around this for now by defaulting to None. try: lowest_passing_grade = course.lowest_passing_grade except ValueError: lowest_passing_grade = None display_name = course.display_name start = course.start end = course.end max_student_enrollments_allowed = course.max_student_enrollments_allowed if isinstance(course.id, CCXLocator): from lms.djangoapps.ccx.utils import get_ccx_from_ccx_locator ccx = get_ccx_from_ccx_locator(course.id) display_name = ccx.display_name start = ccx.start end = ccx.due max_student_enrollments_allowed = ccx.max_student_enrollments_allowed course_overview = cls.objects.filter(id=course.id) if course_overview.exists(): log.info('Updating course overview for %s.', unicode(course.id)) course_overview = course_overview.first() else: log.info('Creating course overview for %s.', unicode(course.id)) course_overview = cls() course_overview.version = cls.VERSION course_overview.id = course.id course_overview._location = course.location course_overview.org = course.location.org course_overview.display_name = display_name course_overview.display_number_with_default = course.display_number_with_default course_overview.display_org_with_default = course.display_org_with_default course_overview.start = start course_overview.end = end course_overview.advertised_start = course.advertised_start course_overview.announcement = course.announcement course_overview.course_image_url = course_image_url(course) course_overview.social_sharing_url = course.social_sharing_url course_overview.certificates_display_behavior = course.certificates_display_behavior course_overview.certificates_show_before_end = course.certificates_show_before_end course_overview.cert_html_view_enabled = course.cert_html_view_enabled course_overview.has_any_active_web_certificate = ( get_active_web_certificate(course) is not None) course_overview.cert_name_short = course.cert_name_short course_overview.cert_name_long = course.cert_name_long course_overview.certificate_available_date = course.certificate_available_date course_overview.lowest_passing_grade = lowest_passing_grade course_overview.end_of_course_survey_url = course.end_of_course_survey_url course_overview.days_early_for_beta = course.days_early_for_beta course_overview.mobile_available = course.mobile_available course_overview.visible_to_staff_only = course.visible_to_staff_only course_overview._pre_requisite_courses_json = json.dumps( course.pre_requisite_courses) course_overview.enrollment_start = course.enrollment_start course_overview.enrollment_end = course.enrollment_end course_overview.enrollment_domain = course.enrollment_domain course_overview.invitation_only = course.invitation_only course_overview.max_student_enrollments_allowed = max_student_enrollments_allowed course_overview.catalog_visibility = course.catalog_visibility course_overview.short_description = CourseDetails.fetch_about_attribute( course.id, 'short_description') course_overview.effort = CourseDetails.fetch_about_attribute( course.id, 'effort') course_overview.course_video_url = CourseDetails.fetch_video_url( course.id) course_overview.self_paced = course.self_paced if not CatalogIntegration.is_enabled(): course_overview.language = course.language return course_overview @classmethod def load_from_module_store(cls, course_id): """ Load a CourseDescriptor, create or update a CourseOverview from it, cache the overview, and return it. Arguments: course_id (CourseKey): the ID of the course overview to be loaded. Returns: CourseOverview: overview of the requested course. Raises: - CourseOverview.DoesNotExist if the course specified by course_id was not found. - IOError if some other error occurs while trying to load the course from the module store. """ store = modulestore() with store.bulk_operations(course_id): course = store.get_course(course_id) if isinstance(course, CourseDescriptor): course_overview = cls._create_or_update(course) try: with transaction.atomic(): course_overview.save() # Remove and recreate all the course tabs CourseOverviewTab.objects.filter( course_overview=course_overview).delete() CourseOverviewTab.objects.bulk_create([ CourseOverviewTab(tab_id=tab.tab_id, course_overview=course_overview) for tab in course.tabs ]) # Remove and recreate course images CourseOverviewImageSet.objects.filter( course_overview=course_overview).delete() CourseOverviewImageSet.create(course_overview, course) except IntegrityError: # There is a rare race condition that will occur if # CourseOverview.get_from_id is called while a # another identical overview is already in the process # of being created. # One of the overviews will be saved normally, while the # other one will cause an IntegrityError because it tries # to save a duplicate. # (see: https://openedx.atlassian.net/browse/TNL-2854). pass except Exception: # pylint: disable=broad-except log.exception( "CourseOverview for course %s failed!", course_id, ) raise return course_overview elif course is not None: raise IOError( "Error while loading course {} from the module store: {}", unicode(course_id), course.error_msg if isinstance( course, ErrorDescriptor) else unicode(course)) else: raise cls.DoesNotExist() @classmethod def get_from_id(cls, course_id): """ Load a CourseOverview object for a given course ID. First, we try to load the CourseOverview from the database. If it doesn't exist, we load the entire course from the modulestore, create a CourseOverview object from it, and then cache it in the database for future use. Arguments: course_id (CourseKey): the ID of the course overview to be loaded. Returns: CourseOverview: overview of the requested course. Raises: - CourseOverview.DoesNotExist if the course specified by course_id was not found. - IOError if some other error occurs while trying to load the course from the module store. """ try: course_overview = cls.objects.select_related('image_set').get( id=course_id) if course_overview.version < cls.VERSION: # Throw away old versions of CourseOverview, as they might contain stale data. course_overview.delete() course_overview = None except cls.DoesNotExist: course_overview = None # Regenerate the thumbnail images if they're missing (either because # they were never generated, or because they were flushed out after # a change to CourseOverviewImageConfig. if course_overview and not hasattr(course_overview, 'image_set'): CourseOverviewImageSet.create(course_overview) return course_overview or cls.load_from_module_store(course_id) @classmethod def get_from_ids_if_exists(cls, course_ids): """ Return a dict mapping course_ids to CourseOverviews, if they exist. This method will *not* generate new CourseOverviews or delete outdated ones. It exists only as a small optimization used when CourseOverviews are known to exist, for common situations like the student dashboard. Callers should assume that this list is incomplete and fall back to get_from_id if they need to guarantee CourseOverview generation. """ return { overview.id: overview for overview in cls.objects.select_related('image_set').filter( id__in=course_ids, version__gte=cls.VERSION) } def clean_id(self, padding_char='='): """ Returns a unique deterministic base32-encoded ID for the course. Arguments: padding_char (str): Character used for padding at end of base-32 -encoded string, defaulting to '=' """ return course_metadata_utils.clean_course_key(self.location.course_key, padding_char) @property def location(self): """ Returns the UsageKey of this course. UsageKeyField has a strange behavior where it fails to parse the "run" of a course out of the serialized form of a Mongo Draft UsageKey. This method is a wrapper around _location attribute that fixes the problem by calling map_into_course, which restores the run attribute. """ if self._location.run is None: self._location = self._location.map_into_course(self.id) return self._location @property def number(self): """ Returns this course's number. This is a "number" in the sense of the "course numbers" that you see at lots of universities. For example, given a course "Intro to Computer Science" with the course key "edX/CS-101/2014", the course number would be "CS-101" """ return course_metadata_utils.number_for_course_location(self.location) @property def url_name(self): """ Returns this course's URL name. """ return block_metadata_utils.url_name_for_block(self) @property def display_name_with_default(self): """ Return reasonable display name for the course. """ return block_metadata_utils.display_name_with_default(self) @property def display_name_with_default_escaped(self): """ DEPRECATED: use display_name_with_default Return html escaped reasonable display name for the course. Note: This newly introduced method should not be used. It was only introduced to enable a quick search/replace and the ability to slowly migrate and test switching to display_name_with_default, which is no longer escaped. """ return block_metadata_utils.display_name_with_default_escaped(self) @property def dashboard_start_display(self): """ Return start date to diplay on learner's dashboard, preferably `Course Advertised Start` """ return self.advertised_start or self.start def has_started(self): """ Returns whether the the course has started. """ return course_metadata_utils.has_course_started(self.start) def has_ended(self): """ Returns whether the course has ended. """ return course_metadata_utils.has_course_ended(self.end) def has_marketing_url(self): """ Returns whether the course has marketing url. """ return settings.FEATURES.get('ENABLE_MKTG_SITE') and bool( self.marketing_url) def has_social_sharing_url(self): """ Returns whether the course has social sharing url. """ is_social_sharing_enabled = getattr(settings, 'SOCIAL_SHARING_SETTINGS', {}).get('CUSTOM_COURSE_URLS') return is_social_sharing_enabled and bool(self.social_sharing_url) def starts_within(self, days): """ Returns True if the course starts with-in given number of days otherwise returns False. """ return course_metadata_utils.course_starts_within(self.start, days) @property def start_date_is_still_default(self): """ Checks if the start date set for the course is still default, i.e. .start has not been modified, and .advertised_start has not been set. """ return course_metadata_utils.course_start_date_is_default( self.start, self.advertised_start, ) @property def sorting_score(self): """ Returns a tuple that can be used to sort the courses according the how "new" they are. The "newness" score is computed using a heuristic that takes into account the announcement and (advertised) start dates of the course if available. The lower the number the "newer" the course. """ return course_metadata_utils.sorting_score(self.start, self.advertised_start, self.announcement) @property def start_type(self): """ Returns the type of the course's 'start' field. """ if self.advertised_start: return u'string' elif self.start != DEFAULT_START_DATE: return u'timestamp' else: return u'empty' @property def start_display(self): """ Returns the display value for the course's start date. """ if self.advertised_start: return self.advertised_start elif self.start != DEFAULT_START_DATE: return defaultfilters.date(self.start, "DATE_FORMAT") else: return None def may_certify(self): """ Returns whether it is acceptable to show the student a certificate download link. """ return course_metadata_utils.may_certify_for_course( self.certificates_display_behavior, self.certificates_show_before_end, self.has_ended(), self.certificate_available_date, self.self_paced) @property def pre_requisite_courses(self): """ Returns a list of ID strings for this course's prerequisite courses. """ return json.loads(self._pre_requisite_courses_json) @classmethod def update_select_courses(cls, course_keys, force_update=False): """ A side-effecting method that updates CourseOverview objects for the given course_keys. Arguments: course_keys (list[CourseKey]): Identifies for which courses to return CourseOverview objects. force_update (boolean): Optional parameter that indicates whether the requested CourseOverview objects should be forcefully updated (i.e., re-synched with the modulestore). """ log.info('Generating course overview for %d courses.', len(course_keys)) log.debug( 'Generating course overview(s) for the following courses: %s', course_keys) action = CourseOverview.load_from_module_store if force_update else CourseOverview.get_from_id for course_key in course_keys: try: action(course_key) except Exception as ex: # pylint: disable=broad-except log.exception( 'An error occurred while generating course overview for %s: %s', unicode(course_key), ex.message, ) log.info('Finished generating course overviews.') @classmethod def get_all_courses(cls, orgs=None, filter_=None): """ Returns all CourseOverview objects in the database. Arguments: orgs (list[string]): Optional parameter that allows case-insensitive filtering by organization. filter_ (dict): Optional parameter that allows custom filtering. """ # Note: If a newly created course is not returned in this QueryList, # make sure the "publish" signal was emitted when the course was # created. For tests using CourseFactory, use emit_signals=True. course_overviews = CourseOverview.objects.all() if orgs: # In rare cases, courses belonging to the same org may be accidentally assigned # an org code with a different casing (e.g., Harvardx as opposed to HarvardX). # Case-insensitive matching allows us to deal with this kind of dirty data. course_overviews = course_overviews.filter(org__iregex=r'(' + '|'.join(orgs) + ')') if filter_: course_overviews = course_overviews.filter(**filter_) return course_overviews @classmethod def get_all_course_keys(cls): """ Returns all course keys from course overviews. """ return CourseOverview.objects.values_list('id', flat=True) def is_discussion_tab_enabled(self): """ Returns True if course has discussion tab and is enabled """ tabs = self.tabs.all() # creates circular import; hence explicitly referenced is_discussion_enabled for tab in tabs: if tab.tab_id == "discussion" and django_comment_client.utils.is_discussion_enabled( self.id): return True return False @property def image_urls(self): """ Return a dict with all known URLs for this course image. Current resolutions are: raw = original upload from the user small = thumbnail with dimensions CourseOverviewImageConfig.current().small large = thumbnail with dimensions CourseOverviewImageConfig.current().large If no thumbnails exist, the raw (originally uploaded) image will be returned for all resolutions. """ # This is either the raw image that the course team uploaded, or the # settings.DEFAULT_COURSE_ABOUT_IMAGE_URL if they didn't specify one. raw_image_url = self.course_image_url # Default all sizes to return the raw image if there is no # CourseOverviewImageSet associated with this CourseOverview. This can # happen because we're disabled via CourseOverviewImageConfig. urls = { 'raw': raw_image_url, 'small': raw_image_url, 'large': raw_image_url, } # If we do have a CourseOverviewImageSet, we still default to the raw # images if our thumbnails are blank (might indicate that there was a # processing error of some sort while trying to generate thumbnails). if hasattr( self, 'image_set') and CourseOverviewImageConfig.current().enabled: urls['small'] = self.image_set.small_url or raw_image_url urls['large'] = self.image_set.large_url or raw_image_url return self.apply_cdn_to_urls(urls) @property def pacing(self): """ Returns the pacing for the course. Potential values: self: Self-paced courses instructor: Instructor-led courses """ return 'self' if self.self_paced else 'instructor' @property def closest_released_language(self): """ Returns the language code that most closely matches this course' language and is fully supported by the LMS, or None if there are no fully supported languages that match the target. """ return get_closest_released_language( self.language) if self.language else None def apply_cdn_to_urls(self, image_urls): """ Given a dict of resolutions -> urls, return a copy with CDN applied. If CDN does not exist or is disabled, just returns the original. The URLs that we store in CourseOverviewImageSet are all already top level paths, so we don't need to go through the /static remapping magic that happens with other course assets. We just need to add the CDN server if appropriate. """ cdn_config = AssetBaseUrlConfig.current() if not cdn_config.enabled: return image_urls base_url = cdn_config.base_url return { resolution: self._apply_cdn_to_url(url, base_url) for resolution, url in image_urls.items() } def _apply_cdn_to_url(self, url, base_url): """ Applies a new CDN/base URL to the given URL. If a URL is absolute, we skip switching the host since it could be a hostname that isn't behind our CDN, and we could unintentionally break the URL overall. """ # The URL can't be empty. if not url: return url _, netloc, path, params, query, fragment = urlparse(url) # If this is an absolute URL, just return it as is. It could be a domain # that isn't ours, and thus CDNing it would actually break it. if netloc: return url return urlunparse((None, base_url, path, params, query, fragment)) def __unicode__(self): """Represent ourselves with the course key.""" return unicode(self.id)
class PersistentSubsectionGrade(TimeStampedModel): """ A django model tracking persistent grades at the subsection level. """ class Meta(object): unique_together = [ # * Specific grades can be pulled using all three columns, # * Progress page can pull all grades for a given (course_id, user_id) # * Course staff can see all grades for a course using (course_id,) ('course_id', 'user_id', 'usage_key'), ] # primary key will need to be large for this table id = UnsignedBigIntAutoField(primary_key=True) # pylint: disable=invalid-name user_id = models.IntegerField(blank=False) course_id = CourseKeyField(blank=False, max_length=255) # note: the usage_key may not have the run filled in for # old mongo courses. Use the full_usage_key property # instead when you want to use/compare the usage_key. usage_key = UsageKeyField(blank=False, max_length=255) # Information relating to the state of content when grade was calculated subtree_edited_timestamp = models.DateTimeField('last content edit timestamp', blank=False) course_version = models.CharField('guid of latest course version', blank=True, max_length=255) # earned/possible refers to the number of points achieved and available to achieve. # graded refers to the subset of all problems that are marked as being graded. earned_all = models.FloatField(blank=False) possible_all = models.FloatField(blank=False) earned_graded = models.FloatField(blank=False) possible_graded = models.FloatField(blank=False) # timestamp for the learner's first attempt at content in # this subsection. If null, indicates no attempt # has yet been made. first_attempted = models.DateTimeField(null=True, blank=True) # track which blocks were visible at the time of grade calculation visible_blocks = models.ForeignKey(VisibleBlocks, db_column='visible_blocks_hash', to_field='hashed') @property def full_usage_key(self): """ Returns the "correct" usage key value with the run filled in. """ if self.usage_key.run is None: # pylint: disable=no-member return self.usage_key.replace(course_key=self.course_id) else: return self.usage_key def __unicode__(self): """ Returns a string representation of this model. """ return ( u"{} user: {}, course version: {}, subsection: {} ({}). {}/{} graded, {}/{} all, first_attempted: {}" ).format( type(self).__name__, self.user_id, self.course_version, self.usage_key, self.visible_blocks_id, self.earned_graded, self.possible_graded, self.earned_all, self.possible_all, self.first_attempted, ) @classmethod def read_grade(cls, user_id, usage_key): """ Reads a grade from database Arguments: user_id: The user associated with the desired grade usage_key: The location of the subsection associated with the desired grade Raises PersistentSubsectionGrade.DoesNotExist if applicable """ return cls.objects.select_related('visible_blocks').get( user_id=user_id, course_id=usage_key.course_key, # course_id is included to take advantage of db indexes usage_key=usage_key, ) @classmethod def bulk_read_grades(cls, user_id, course_key): """ Reads all grades for the given user and course. Arguments: user_id: The user associated with the desired grades course_key: The course identifier for the desired grades """ return cls.objects.select_related('visible_blocks').filter( user_id=user_id, course_id=course_key, ) @classmethod def update_or_create_grade(cls, **kwargs): """ Wrapper for objects.update_or_create. """ cls._prepare_params_and_visible_blocks(kwargs) user_id = kwargs.pop('user_id') usage_key = kwargs.pop('usage_key') grade, _ = cls.objects.update_or_create( user_id=user_id, course_id=usage_key.course_key, usage_key=usage_key, defaults=kwargs, ) return grade @classmethod def create_grade(cls, **kwargs): """ Wrapper for objects.create. """ cls._prepare_params_and_visible_blocks(kwargs) return cls.objects.create(**kwargs) @classmethod def bulk_create_grades(cls, grade_params_iter, course_key): """ Bulk creation of grades. """ if not grade_params_iter: return map(cls._prepare_params, grade_params_iter) VisibleBlocks.bulk_get_or_create([params['visible_blocks'] for params in grade_params_iter], course_key) map(cls._prepare_params_visible_blocks_id, grade_params_iter) return cls.objects.bulk_create([PersistentSubsectionGrade(**params) for params in grade_params_iter]) @classmethod def _prepare_params_and_visible_blocks(cls, params): """ Prepares the fields for the grade record, while creating the related VisibleBlocks, if needed. """ cls._prepare_params(params) params['visible_blocks'] = VisibleBlocks.objects.create_from_blockrecords(params['visible_blocks']) @classmethod def _prepare_params(cls, params): """ Prepares the fields for the grade record. """ if not params.get('course_id', None): params['course_id'] = params['usage_key'].course_key params['course_version'] = params.get('course_version', None) or "" params['visible_blocks'] = BlockRecordList.from_list(params['visible_blocks'], params['course_id']) @classmethod def _prepare_params_visible_blocks_id(cls, params): """ Prepares the visible_blocks_id field for the grade record, using the hash of the visible_blocks field. Specifying the hashed field eliminates extra queries to get the VisibleBlocks record. Use this variation of preparing the params when you are sure of the existence of the VisibleBlock. """ params['visible_blocks_id'] = params['visible_blocks'].hash_value del params['visible_blocks']
class Migration(migrations.Migration): dependencies = [ migrations.swappable_dependency(settings.AUTH_USER_MODEL), ] operations = [ migrations.CreateModel( name='GradedAssignment', fields=[ ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)), ('course_key', CourseKeyField(max_length=255, db_index=True)), ('usage_key', UsageKeyField(max_length=255, db_index=True)), ('lis_result_sourcedid', models.CharField(max_length=255, db_index=True)), ('version_number', models.IntegerField(default=0)), ], ), migrations.CreateModel( name='LtiConsumer', fields=[ ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)), ('consumer_name', models.CharField(unique=True, max_length=255)), ('consumer_key', models.CharField(default=provider.utils.short_token, unique=True, max_length=32, db_index=True)), ('consumer_secret', models.CharField(default=provider.utils.long_token, unique=True, max_length=32)), ('instance_guid', models.CharField(max_length=255, unique=True, null=True, blank=True)), ], ), migrations.CreateModel( name='LtiUser', fields=[ ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)), ('lti_user_id', models.CharField(max_length=255)), ('edx_user', models.OneToOneField(to=settings.AUTH_USER_MODEL)), ('lti_consumer', models.ForeignKey(to='lti_provider.LtiConsumer')), ], ), migrations.CreateModel( name='OutcomeService', fields=[ ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)), ('lis_outcome_service_url', models.CharField(unique=True, max_length=255)), ('lti_consumer', models.ForeignKey(to='lti_provider.LtiConsumer')), ], ), migrations.AddField( model_name='gradedassignment', name='outcome_service', field=models.ForeignKey(to='lti_provider.OutcomeService'), ), migrations.AddField( model_name='gradedassignment', name='user', field=models.ForeignKey(to=settings.AUTH_USER_MODEL), ), migrations.AlterUniqueTogether( name='ltiuser', unique_together=set([('lti_consumer', 'lti_user_id')]), ), migrations.AlterUniqueTogether( name='gradedassignment', unique_together=set([('outcome_service', 'lis_result_sourcedid')]), ), ]
class BlockStructureModel(TimeStampedModel): """ Model for storing Block Structure information. """ VERSION_FIELDS = [ u'data_version', u'data_edit_timestamp', u'transformers_schema_version', u'block_structure_schema_version', ] UNIQUENESS_FIELDS = [u'data_usage_key'] + VERSION_FIELDS class Meta(object): db_table = 'block_structure' data_usage_key = UsageKeyField( u'Identifier of the data being collected.', blank=False, max_length=255, unique=True, ) data_version = models.CharField( u'Version of the data at the time of collection.', blank=True, null=True, max_length=255, ) data_edit_timestamp = models.DateTimeField( u'Edit timestamp of the data at the time of collection.', blank=True, null=True, ) transformers_schema_version = models.CharField( u'Representation of the schema version of the transformers used during collection.', blank=False, max_length=255, ) block_structure_schema_version = models.CharField( u'Version of the block structure schema at the time of collection.', blank=False, max_length=255, ) data = models.FileField( upload_to=_path_name, max_length= 500, # allocate enough for base path + prefix + usage_key + timestamp in filepath ) def get_serialized_data(self): """ Returns the collected data for this instance. """ serialized_data = self.data.read() log.info("BlockStructure: Read data from store; %r, size: %d", unicode(self), len(serialized_data)) return serialized_data @classmethod def get(cls, data_usage_key): """ Returns the entry associated with the given data_usage_key. Raises: BlockStructureNotFound if an entry for data_usage_key is not found. """ try: return cls.objects.get(data_usage_key=data_usage_key) except cls.DoesNotExist: log.info("BlockStructure: Not found in table; %r.", data_usage_key) raise BlockStructureNotFound(data_usage_key) @classmethod def update_or_create(cls, serialized_data, data_usage_key, **kwargs): """ Updates or creates the BlockStructureModel entry for the given data_usage_key in the kwargs, uploading serialized_data as the content data. """ bs_model, created = cls.objects.update_or_create( defaults=kwargs, data_usage_key=data_usage_key) bs_model.data.save('', ContentFile(serialized_data)) log.info( 'BlockStructure: %s in store; %r, size: %d', 'Created' if created else 'Updated', unicode(bs_model), len(serialized_data), ) if not created: cls._prune_files(data_usage_key) return bs_model, created def __unicode__(self): """ Returns a string representation of this model. """ return u', '.join( u'{}: {}'.format(field_name, unicode(getattr(self, field_name))) for field_name in self.UNIQUENESS_FIELDS) @classmethod def _prune_files(cls, data_usage_key, num_to_keep=None): """ Deletes previous file versions for data_usage_key. """ if not config.is_enabled(config.PRUNE_OLD_VERSIONS): return if num_to_keep is None: num_to_keep = config.num_versions_to_keep() try: all_files_by_date = sorted(cls._get_all_files(data_usage_key)) files_to_delete = all_files_by_date[: -num_to_keep] if num_to_keep > 0 else all_files_by_date cls._delete_files(files_to_delete) log.info( 'BlockStructure: Deleted %d out of total %d files in store; data_usage_key: %r, num_to_keep: %d.', len(files_to_delete), len(all_files_by_date), data_usage_key, num_to_keep, ) except Exception as error: # pylint: disable=broad-except log.exception( 'BlockStructure: Exception when deleting old files; data_usage_key: %r, %r', data_usage_key, error, ) @classmethod def _delete_files(cls, files): """ Deletes the given files from storage. """ storage = _bs_model_storage() map(storage.delete, files) @classmethod def _get_all_files(cls, data_usage_key): """ Returns all filenames that exist for the given key. """ directory = _directory_name(data_usage_key) _, filenames = _bs_model_storage().listdir(directory) return [ _create_path(directory, filename) for filename in filenames if filename and not filename.startswith('.') ]
class Migration(migrations.Migration): dependencies = [ ('course_overviews', '0001_initial'), ] operations = [ migrations.DeleteModel("CourseOverview"), migrations.CreateModel( name='CourseOverview', fields=[ ('created', model_utils.fields.AutoCreatedField( default=django.utils.timezone.now, verbose_name='created', editable=False)), ('modified', model_utils.fields.AutoLastModifiedField( default=django.utils.timezone.now, verbose_name='modified', editable=False)), ('version', models.IntegerField()), ('id', CourseKeyField(max_length=255, serialize=False, primary_key=True, db_index=True)), ('_location', UsageKeyField(max_length=255)), ('display_name', models.TextField(null=True)), ('display_number_with_default', models.TextField()), ('display_org_with_default', models.TextField()), ('start', models.DateTimeField(null=True)), ('end', models.DateTimeField(null=True)), ('advertised_start', models.TextField(null=True)), ('course_image_url', models.TextField()), ('facebook_url', models.TextField(null=True)), ('social_sharing_url', models.TextField(null=True)), ('end_of_course_survey_url', models.TextField(null=True)), ('certificates_display_behavior', models.TextField(null=True)), ('certificates_show_before_end', models.BooleanField(default=False)), ('cert_html_view_enabled', models.BooleanField(default=False)), ('has_any_active_web_certificate', models.BooleanField(default=False)), ('cert_name_short', models.TextField()), ('cert_name_long', models.TextField()), ('lowest_passing_grade', models.DecimalField(null=True, max_digits=5, decimal_places=2)), ('days_early_for_beta', models.FloatField(null=True)), ('mobile_available', models.BooleanField(default=False)), ('visible_to_staff_only', models.BooleanField(default=False)), ('_pre_requisite_courses_json', models.TextField()), ('enrollment_start', models.DateTimeField(null=True)), ('enrollment_end', models.DateTimeField(null=True)), ('enrollment_domain', models.TextField(null=True)), ('invitation_only', models.BooleanField(default=False)), ('max_student_enrollments_allowed', models.IntegerField(null=True)), ], ), migrations.CreateModel( name='CourseOverviewTab', fields=[ ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)), ('tab_id', models.CharField(max_length=50)), ('course_overview', models.ForeignKey(related_name='tabs', to='course_overviews.CourseOverview')), ], ), migrations.AddField( model_name='courseoverview', name='announcement', field=models.DateTimeField(null=True), ), migrations.AddField( model_name='courseoverview', name='catalog_visibility', field=models.TextField(null=True), ), migrations.AddField( model_name='courseoverview', name='course_video_url', field=models.TextField(null=True), ), migrations.AddField( model_name='courseoverview', name='effort', field=models.TextField(null=True), ), migrations.AddField( model_name='courseoverview', name='short_description', field=models.TextField(null=True), ), ]
class BlockCompletion(TimeStampedModel, models.Model): """ Track completion of completable blocks. A completion is unique for each (user, course_key, block_key). The block_type field is included separately from the block_key to facilitate distinct aggregations of the completion of particular types of block. The completion value is stored as a float in the range [0.0, 1.0], and all calculations are performed on this float, though current practice is to only track binary completion, where 1.0 indicates that the block is complete, and 0.0 indicates that the block is incomplete. """ id = BigAutoField(primary_key=True) # pylint: disable=invalid-name user = models.ForeignKey(User) course_key = CourseKeyField(max_length=255) block_key = UsageKeyField(max_length=255) block_type = models.CharField(max_length=64) completion = models.FloatField(validators=[validate_percent]) objects = BlockCompletionManager() @classmethod def get_course_completions(cls, user, course_key): """ query all completions for course/user pair Return value: dict[BlockKey] = float """ course_block_completions = cls.objects.filter( user=user, course_key=course_key, ) # will not return if <= 0.0 return { completion.block_key: completion.completion for completion in course_block_completions } @classmethod def get_latest_block_completed(cls, user, course_key): """ query latest completion for course/user pair Return value: obj: block completion """ try: latest_modified_block_completion = cls.objects.filter( user=user, course_key=course_key, ).latest() except cls.DoesNotExist: return return latest_modified_block_completion class Meta(object): index_together = [ ('course_key', 'block_type', 'user'), ('user', 'course_key', 'modified'), ] unique_together = [('course_key', 'block_key', 'user')] get_latest_by = 'modified' def __unicode__(self): return 'BlockCompletion: {username}, {course_key}, {block_key}: {completion}'.format( username=self.user.username, course_key=self.course_key, block_key=self.block_key, completion=self.completion, )
class Migration(migrations.Migration): dependencies = [] operations = [ migrations.CreateModel( name='PersistentSubsectionGrade', fields=[ ('created', model_utils.fields.AutoCreatedField( default=django.utils.timezone.now, verbose_name='created', editable=False)), ('modified', model_utils.fields.AutoLastModifiedField( default=django.utils.timezone.now, verbose_name='modified', editable=False)), ('id', coursewarehistoryextended.fields.UnsignedBigIntAutoField( serialize=False, primary_key=True)), ('user_id', models.IntegerField()), ('course_id', CourseKeyField(max_length=255)), ('usage_key', UsageKeyField(max_length=255)), ('subtree_edited_date', models.DateTimeField( verbose_name=b'last content edit timestamp')), ('course_version', models.CharField( max_length=255, verbose_name=b'guid of latest course version', blank=True)), ('earned_all', models.FloatField()), ('possible_all', models.FloatField()), ('earned_graded', models.FloatField()), ('possible_graded', models.FloatField()), ], ), migrations.CreateModel( name='VisibleBlocks', fields=[ ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)), ('blocks_json', models.TextField()), ('hashed', models.CharField(unique=True, max_length=100)), ], ), migrations.AddField( model_name='persistentsubsectiongrade', name='visible_blocks', field=models.ForeignKey(to='grades.VisibleBlocks', db_column=b'visible_blocks_hash', to_field=b'hashed'), ), migrations.AlterUniqueTogether( name='persistentsubsectiongrade', unique_together=set([('course_id', 'user_id', 'usage_key')]), ), ]