def load_single_user_time(request): user = User.objects.get(id=request.POST.get('user_id')) row = {} rts = record_time_store() external_time = 0 all_external_time = 0 user_id = str(user.id) course_id = str(request.POST.get('course_id', None)) if course_id: for enrollment in CourseEnrollment.enrollments_for_user(user): try: course = course_from_id(enrollment.course_id) all_external_time += rts.get_external_time(user_id, course.id) except ItemNotFoundError: #log.error("User {0} enrolled in non-existent course {1}".format(p.user.username, enrollment.course_id)) pass all_course_time, all_discussion_time, portfolio_time = rts.get_stats_time(user_id) adjustment_time_totle = rts.get_adjustment_time(user_id, 'total', None) external_time = rts.get_external_time(user_id, course_id) course_time = rts.get_course_time(user_id, course_id, 'courseware') discussion_time = rts.get_course_time(user_id, course_id, 'discussion') collaboration_time = all_discussion_time + portfolio_time all_course_time = all_course_time + all_external_time total_time = all_course_time + collaboration_time + adjustment_time_totle else: for enrollment in CourseEnrollment.enrollments_for_user(user): try: course = course_from_id(enrollment.course_id) external_time += rts.get_external_time(user_id, course.id) except ItemNotFoundError: #log.error("User {0} enrolled in non-existent course {1}".format(p.user.username, enrollment.course_id)) pass adjustment_time_totle = rts.get_adjustment_time(user_id, 'total', None) course_time, discussion_time, portfolio_time = rts.get_stats_time(user_id) all_course_time = course_time + external_time collaboration_time = discussion_time + portfolio_time total_time = all_course_time + collaboration_time + adjustment_time_totle row = {"id": user_id, "total_time": study_time_format(total_time, True), "collaboration_time": study_time_format(collaboration_time, True), "discussion_time": study_time_format(discussion_time, True), "portfolio_time": study_time_format(portfolio_time, True), "external_time": study_time_format(external_time, True), "course_time": study_time_format(course_time, True) } return HttpResponse(json.dumps({'row': row}), content_type="application/json")
def midcourse_reverify_dash(request): """ Shows the "course reverification dashboard", which displays the reverification status (must reverify, pending, approved, failed, etc) of all courses in which a student has a verified enrollment. """ user = request.user course_enrollment_pairs = [] for enrollment in CourseEnrollment.enrollments_for_user(user): try: course_enrollment_pairs.append((modulestore().get_course(enrollment.course_id), enrollment)) except ItemNotFoundError: log.error("User {0} enrolled in non-existent course {1}" .format(user.username, enrollment.course_id)) statuses = ["approved", "pending", "must_reverify", "denied"] reverifications = reverification_info(course_enrollment_pairs, user, statuses) context = { "user_full_name": user.profile.name, 'reverifications': reverifications, 'referer': request.META.get('HTTP_REFERER'), 'billing_email': settings.PAYMENT_SUPPORT_EMAIL, } return render_to_response("verify_student/midcourse_reverify_dash.html", context)
def get(self, request): context = { 'platform_name': configuration_helpers.get_value('platform_name', settings.PLATFORM_NAME), 'zendesk_api_host': settings.ZENDESK_URL, 'access_token': 'DUMMY_ACCESS_TOKEN', # LEARNER-3450 'custom_fields': settings.ZENDESK_CUSTOM_FIELDS } # Tag all issues with LMS to distinguish channel in Zendesk; requested by student support team zendesk_tags = ['LMS'] # Per edX support, we would like to be able to route feedback items by site via tagging current_site_name = configuration_helpers.get_value("SITE_NAME") if current_site_name: current_site_name = current_site_name.replace(".", "_") zendesk_tags.append( "site_name_{site}".format(site=current_site_name)) if request.user.is_authenticated(): context[ 'user_enrollments'] = CourseEnrollment.enrollments_for_user( request.user) enterprise_learner_data = enterprise_api.get_enterprise_learner_data( site=request.site, user=request.user) if enterprise_learner_data: zendesk_tags.append('enterprise_learner') context['zendesk_tags'] = zendesk_tags return render_to_response("support/contact_us.html", context)
def midcourse_reverify_dash(request): """ Shows the "course reverification dashboard", which displays the reverification status (must reverify, pending, approved, failed, etc) of all courses in which a student has a verified enrollment. """ user = request.user course_enrollment_pairs = [] for enrollment in CourseEnrollment.enrollments_for_user(user): try: course_enrollment_pairs.append( (modulestore().get_course(enrollment.course_id), enrollment)) except ItemNotFoundError: log.error("User {0} enrolled in non-existent course {1}".format( user.username, enrollment.course_id)) statuses = ["approved", "pending", "must_reverify", "denied"] reverifications = reverification_info(course_enrollment_pairs, user, statuses) context = { "user_full_name": user.profile.name, 'reverifications': reverifications, 'referer': request.META.get('HTTP_REFERER'), 'billing_email': settings.PAYMENT_SUPPORT_EMAIL, } return render_to_response("verify_student/midcourse_reverify_dash.html", context)
def __init__(self, site, user, enrollments=None, uuid=None): self.site = site self.user = user self.enrollments = enrollments or list( CourseEnrollment.enrollments_for_user(self.user)) self.enrollments.sort(key=lambda e: e.created, reverse=True) self.enrolled_run_modes = {} self.course_run_ids = [] for enrollment in self.enrollments: # enrollment.course_id is really a CourseKey (╯ಠ_ಠ)╯︵ ┻━┻ enrollment_id = unicode(enrollment.course_id) mode = enrollment.mode if mode == CourseMode.NO_ID_PROFESSIONAL_MODE: mode = CourseMode.PROFESSIONAL self.enrolled_run_modes[enrollment_id] = mode # We can't use dict.keys() for this because the course run ids need to be ordered self.course_run_ids.append(enrollment_id) self.entitlements = list( CourseEntitlement.unexpired_entitlements_for_user(self.user)) self.course_uuids = [ str(entitlement.course_uuid) for entitlement in self.entitlements ] self.course_grade_factory = CourseGradeFactory() if uuid: self.programs = [get_programs(self.site, uuid=uuid)] else: self.programs = attach_program_detail_url(get_programs(self.site))
def __init__(self, site, user, enrollments=None, uuid=None, mobile_only=False): self.site = site self.user = user self.mobile_only = mobile_only self.enrollments = enrollments or list(CourseEnrollment.enrollments_for_user(self.user)) self.enrollments.sort(key=lambda e: e.created, reverse=True) self.enrolled_run_modes = {} self.course_run_ids = [] for enrollment in self.enrollments: # enrollment.course_id is really a CourseKey (╯ಠ_ಠ)╯︵ ┻━┻ enrollment_id = unicode(enrollment.course_id) mode = enrollment.mode if mode == CourseMode.NO_ID_PROFESSIONAL_MODE: mode = CourseMode.PROFESSIONAL self.enrolled_run_modes[enrollment_id] = mode # We can't use dict.keys() for this because the course run ids need to be ordered self.course_run_ids.append(enrollment_id) self.entitlements = list(CourseEntitlement.unexpired_entitlements_for_user(self.user)) self.course_uuids = [str(entitlement.course_uuid) for entitlement in self.entitlements] self.course_grade_factory = CourseGradeFactory() if uuid: self.programs = [get_programs(uuid=uuid)] else: self.programs = attach_program_detail_url(get_programs(self.site), self.mobile_only)
def get_course_enrollment_pairs(user, course_org_filter, org_filter_out_set): """ Get the relevant set of (Course, CourseEnrollment) pairs to be displayed on a student's dashboard. """ for enrollment in CourseEnrollment.enrollments_for_user(user): try: course = course_from_id(enrollment.course_id) # if we are in a Microsite, then filter out anything that is not # attributed (by ORG) to that Microsite if course_org_filter and course_org_filter != course.location.org: continue # Conversely, if we are not in a Microsite, then let's filter out any enrollments # with courses attributed (by ORG) to Microsites elif course.location.org in org_filter_out_set: continue ## offline course filter elif course.course_audit == 0: continue yield (course, enrollment) except ItemNotFoundError: log.error("User {0} enrolled in non-existent course {1}" .format(user.username, enrollment.course_id))
def _listen_for_id_verification_status_changed(sender, user, **kwargs): # pylint: disable=unused-argument """ Catches a track change signal, determines user status, calls fire_ungenerated_certificate_task for passing grades """ if not auto_certificate_generation_enabled(): return user_enrollments = CourseEnrollment.enrollments_for_user(user=user) grade_factory = CourseGradeFactory() expected_verification_status = IDVerificationService.user_status(user) expected_verification_status = expected_verification_status['status'] for enrollment in user_enrollments: if grade_factory.read(user=user, course=enrollment.course_overview).passed: if fire_ungenerated_certificate_task(user, enrollment.course_id, expected_verification_status): message = ( u'Certificate generation task initiated for {user} : {course} via track change ' + u'with verification status of {status}' ) log.info(message.format( user=user.id, course=enrollment.course_id, status=expected_verification_status ))
def get(self, request): context = { 'platform_name': configuration_helpers.get_value('platform_name', settings.PLATFORM_NAME), 'zendesk_api_host': settings.ZENDESK_URL, 'access_token': 'DUMMY_ACCESS_TOKEN', # LEARNER-3450 'custom_fields': settings.ZENDESK_CUSTOM_FIELDS } # Tag all issues with LMS to distinguish channel in Zendesk; requested by student support team zendesk_tags = ['LMS'] # Per edX support, we would like to be able to route feedback items by site via tagging current_site_name = configuration_helpers.get_value("SITE_NAME") if current_site_name: current_site_name = current_site_name.replace(".", "_") zendesk_tags.append("site_name_{site}".format(site=current_site_name)) if request.user.is_authenticated(): context['user_enrollments'] = CourseEnrollment.enrollments_for_user(request.user) enterprise_learner_data = enterprise_api.get_enterprise_learner_data(site=request.site, user=request.user) if enterprise_learner_data: zendesk_tags.append('enterprise_learner') context['zendesk_tags'] = zendesk_tags return render_to_response("support/contact_us.html", context)
def my_courses_command(self, bot, update): chat_id = update.message.chat_id telegram_id = update.message.from_user.id telegram_user = EdxTelegramUser.objects.filter( telegram_id=telegram_id).first() bot.sendChatAction(chat_id=chat_id, action=ChatAction.TYPING) results = CourseEnrollment.enrollments_for_user(telegram_user.student) if not results: bot.sendSticker(chat_id=chat_id, sticker='BQADBAADMwIAAmONagABu635srr8N-0C') msg = "I can't find any courses for you. Sorry" bot.sendMessage(chat_id=chat_id, text=msg) else: bot.sendSticker(chat_id=chat_id, sticker='BQADBAADCwIAAmONagABF1QQKl9NWncC') msg = "Just have a look what I've found for you" keyboard = [ InlineKeyboardButton(text=modulestore().get_course( course.course_id).display_name_with_default, callback_data=json.dumps({ 'method': 'get_course_description', 'kwargs': { 'enroll': course.id } })) for course in results ] reply_markup = InlineKeyboardMarkup([[each] for each in keyboard]) bot.sendMessage(chat_id=chat_id, text=msg, reply_markup=reply_markup)
def handle(self, *args, **options): if len(args) != 1: raise CommandError('Must called with arguments: {}'.format( self.args)) try: user = get_user_by_username_or_email(args[0]) except: raise CommandError('No user exists [ {} ]'.format(args[0])) course_id = options['course_id'] reactivate = options['reactivate'] if course_id: try: course_id = CourseLocator.from_string(course_id) except InvalidKeyError: raise CommandError( "'{}' is an invalid course_id".format(course_id)) if not modulestore().get_course(course_id): raise CommandError("The specified course does not exist.") self.change_optout_state(user, course_id, reactivate) else: course_enrollments = CourseEnrollment.enrollments_for_user(user) for enrollment in course_enrollments: course_id = enrollment.course_id self.change_optout_state(user, course_id, reactivate)
def test_success(self): serialized = CourseEnrollmentSerializer( CourseEnrollment.enrollments_for_user(self.user)[0], context={"request": self.request} ).data self.assertEqual(serialized["course"]["name"], self.course.display_name) self.assertEqual(serialized["course"]["number"], self.course.id.course) self.assertEqual(serialized["course"]["org"], self.course.id.org)
def validate_adjustment_time(rts, user_id, type, adjustment_time, course_id): type_time = 0 external_time = 0 adjustment_time = int(adjustment_time) if adjustment_time < 0: if type == 'total': user = User.objects.get(id=user_id) for enrollment in CourseEnrollment.enrollments_for_user(user): try: course = course_from_id(enrollment.course_id) external_time += rts.get_external_time(user_id, course.id) except ItemNotFoundError: log.error("User {0} enrolled in non-existent course {1}".format(user.username, enrollment.course_id)) course_time, discussion_time, portfolio_time = rts.get_stats_time(user_id) adjustment_time_totle = rts.get_adjustment_time(user_id, 'total', None) type_time = course_time + discussion_time + portfolio_time + external_time + adjustment_time_totle else: if type == 'external': type_time = rts.get_external_time(user_id, course_id) else: type_time = rts.get_course_time(user_id, course_id, type) if type_time + adjustment_time < 0: return False return True
def get(self, request): context = { 'platform_name': configuration_helpers.get_value('platform_name', settings.PLATFORM_NAME), 'support_email': configuration_helpers.get_value('CONTACT_EMAIL', settings.CONTACT_EMAIL), 'custom_fields': settings.ZENDESK_CUSTOM_FIELDS } # Tag all issues with LMS to distinguish channel which received the request tags = ['LMS'] # Per edX support, we would like to be able to route feedback items by site via tagging current_site_name = configuration_helpers.get_value("SITE_NAME") if current_site_name: current_site_name = current_site_name.replace(".", "_") tags.append("site_name_{site}".format(site=current_site_name)) if request.user.is_authenticated(): context[ 'user_enrollments'] = CourseEnrollment.enrollments_for_user( request.user) enterprise_learner_data = enterprise_api.get_enterprise_learner_data( site=request.site, user=request.user) if enterprise_learner_data: tags.append('enterprise_learner') context['tags'] = tags return render_to_response("support/contact_us.html", context)
def _set_email_expiry_date(self, verification, user, email_config): """ If already DEFAULT Number of emails are sent, then verify that user is enrolled in at least one verified course run for which the course has not ended else stop sending emails Setting email_expiry_date to None will prevent from sending any emails in future to the learner :param user: User for which course enrollments will be fetched :param email_config: Contains configurations like resend_days and default_emails value """ send_expiry_email_again = True email_duration = email_config['resend_days'] * (email_config['default_emails'] - 1) days_since_expiry = (now() - verification.expiry_date).days if days_since_expiry >= email_duration: send_expiry_email_again = False enrollments = CourseEnrollment.enrollments_for_user(user=user) for enrollment in enrollments: if CourseMode.VERIFIED == enrollment.mode and not enrollment.course.has_ended(): send_expiry_email_again = True break verification_qs = SoftwareSecurePhotoVerification.objects.filter(pk=verification.pk) email_date = now().replace(hour=0, minute=0, second=0, microsecond=0) if send_expiry_email_again else None verification_qs.update(expiry_email_date=email_date)
def get_course_enrollment_pairs(user, course_org_filter, org_filter_out_set): """ Get the relevant set of (Course, CourseEnrollment) pairs to be displayed on a student's dashboard. """ for enrollment in CourseEnrollment.enrollments_for_user(user): try: course = course_from_id(enrollment.course_id) # if we are in a Microsite, then filter out anything that is not # attributed (by ORG) to that Microsite if course_org_filter and course_org_filter != course.location.org: continue # Conversely, if we are not in a Microsite, then let's filter out any enrollments # with courses attributed (by ORG) to Microsites elif course.location.org in org_filter_out_set: continue ## offline course filter elif course.course_audit == 0: continue yield (course, enrollment) except ItemNotFoundError: log.error("User {0} enrolled in non-existent course {1}".format( user.username, enrollment.course_id))
def users(self, request, pk): """ Add a User to an Organization """ if request.method == 'GET': include_course_counts = request.QUERY_PARAMS.get('include_course_counts', None) users = User.objects.filter(organizations=pk) response_data = [] if users: for user in users: serializer = UserSerializer(user) user_data = serializer.data if str2bool(include_course_counts): enrollments = CourseEnrollment.enrollments_for_user(user).count() user_data['course_count'] = enrollments response_data.append(user_data) return Response(response_data, status=status.HTTP_200_OK) else: user_id = request.DATA.get('id') try: user = User.objects.get(id=user_id) except ObjectDoesNotExist: message = 'User {} does not exist'.format(user_id) return Response({"detail": message}, status.HTTP_400_BAD_REQUEST) organization = self.get_object() organization.users.add(user) organization.save() return Response({}, status=status.HTTP_201_CREATED)
def test_course_serializer(self): self.client.login(username=self.username, password=self.password) self._enroll(self.course) serialized = CourseEnrollmentSerializer(CourseEnrollment.enrollments_for_user(self.user)[0]).data # pylint: disable=E1101 self.assertEqual(serialized['course']['video_outline'], None) self.assertEqual(serialized['course']['name'], self.course.display_name) self.assertEqual(serialized['course']['number'], self.course.id.course) self.assertEqual(serialized['course']['org'], self.course.id.org)
def test_success(self): serialized = CourseEnrollmentSerializer( CourseEnrollment.enrollments_for_user(self.user)[0], context={'request': self.request}, ).data self.assertEqual(serialized['course']['name'], self.course.display_name) self.assertEqual(serialized['course']['number'], self.course.id.course) self.assertEqual(serialized['course']['org'], self.course.id.org)
def get(self, request): context = {} if request.user.is_authenticated(): context[ 'user_enrollments'] = CourseEnrollment.enrollments_for_user( request.user) return render_to_response("support/contact_us.html", context)
def test_success(self): self.login_and_enroll() serialized = CourseEnrollmentSerializer(CourseEnrollment.enrollments_for_user(self.user)[0]).data # pylint: disable=no-member self.assertEqual(serialized['course']['video_outline'], None) self.assertEqual(serialized['course']['name'], self.course.display_name) self.assertEqual(serialized['course']['number'], self.course.id.course) self.assertEqual(serialized['course']['org'], self.course.id.org)
def get(self, request): context = { 'platform_name': helpers.get_value('platform_name', settings.PLATFORM_NAME) } if request.user.is_authenticated(): context['user_enrollments'] = CourseEnrollment.enrollments_for_user(request.user) return render_to_response("support/contact_us.html", context)
def post(self, request): telname = request.POST.get('telname') user = TeleramReg.objects.filter(telname=telname).first() if user: courses = CourseEnrollment.enrollments_for_user(user) return JsonResponse({'courses': courses}) else: return JsonResponse({'courses': 'none'})
def get(self, request): """GET /api/team/v0/team_membership""" specified_username_or_team = False username = None team_id = None requested_course_id = None requested_course_key = None accessible_course_ids = None if 'course_id' in request.QUERY_PARAMS: requested_course_id = request.QUERY_PARAMS['course_id'] try: requested_course_key = CourseKey.from_string(requested_course_id) except InvalidKeyError: return Response(status=status.HTTP_404_NOT_FOUND) if 'team_id' in request.QUERY_PARAMS: specified_username_or_team = True team_id = request.QUERY_PARAMS['team_id'] try: team = CourseTeam.objects.get(team_id=team_id) except CourseTeam.DoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND) if requested_course_key is not None and requested_course_key != team.course_id: return Response(status=status.HTTP_400_BAD_REQUEST) if not has_team_api_access(request.user, team.course_id): return Response(status=status.HTTP_404_NOT_FOUND) if 'username' in request.QUERY_PARAMS: specified_username_or_team = True username = request.QUERY_PARAMS['username'] if not request.user.is_staff: enrolled_courses = ( CourseEnrollment.enrollments_for_user(request.user).values_list('course_id', flat=True) ) staff_courses = ( CourseAccessRole.objects.filter(user=request.user, role='staff').values_list('course_id', flat=True) ) accessible_course_ids = [item for sublist in (enrolled_courses, staff_courses) for item in sublist] if requested_course_id is not None and requested_course_id not in accessible_course_ids: return Response(status=status.HTTP_400_BAD_REQUEST) if not specified_username_or_team: return Response( build_api_error(ugettext_noop("username or team_id must be specified.")), status=status.HTTP_400_BAD_REQUEST ) course_keys = None if requested_course_key is not None: course_keys = [requested_course_key] elif accessible_course_ids is not None: course_keys = [CourseKey.from_string(course_string) for course_string in accessible_course_ids] queryset = CourseTeamMembership.get_memberships(username, course_keys, team_id) page = self.paginate_queryset(queryset) serializer = self.get_pagination_serializer(page) return Response(serializer.data) # pylint: disable=maybe-no-member
def __init__(self, user, enrollments=None): self.user = user self.enrollments = enrollments or list(CourseEnrollment.enrollments_for_user(self.user)) self.enrollments.sort(key=lambda e: e.created, reverse=True) # enrollment.course_id is really a CourseKey (╯ಠ_ಠ)╯︵ ┻━┻ self.course_run_ids = [unicode(e.course_id) for e in self.enrollments] self.programs = attach_program_detail_url(get_programs())
def test_course_serializer_with_display_overrides(self): self.course.display_coursenumber = "overridden_number" self.course.display_organization = "overridden_org" modulestore().update_item(self.course, self.user.id) self.client.login(username=self.username, password=self.password) self._enroll(self.course) serialized = CourseEnrollmentSerializer(CourseEnrollment.enrollments_for_user(self.user)[0]).data # pylint: disable=E1101 self.assertEqual(serialized['course']['number'], self.course.display_coursenumber) self.assertEqual(serialized['course']['org'], self.course.display_organization)
def field_dictionary(self, **kwargs): """ add course if provided otherwise add courses in which the user is enrolled in """ field_dictionary = super(LmsSearchFilterGenerator, self).field_dictionary(**kwargs) if not kwargs.get('user'): field_dictionary['course'] = [] elif not kwargs.get('course_id'): user_enrollments = CourseEnrollment.enrollments_for_user(kwargs['user']) field_dictionary['course'] = [unicode(enrollment.course_id) for enrollment in user_enrollments] return field_dictionary
def test_course_serializer(self): self.client.login(username=self.username, password=self.password) self._enroll(self.course) serialized = CourseEnrollmentSerializer( CourseEnrollment.enrollments_for_user(self.user)[0] ).data # pylint: disable=no-member self.assertEqual(serialized["course"]["video_outline"], None) self.assertEqual(serialized["course"]["name"], self.course.display_name) self.assertEqual(serialized["course"]["number"], self.course.id.course) self.assertEqual(serialized["course"]["org"], self.course.id.org)
def test_with_display_overrides(self): self.course.display_coursenumber = "overridden_number" self.course.display_organization = "overridden_org" self.store.update_item(self.course, self.user.id) serialized = CourseEnrollmentSerializer( CourseEnrollment.enrollments_for_user(self.user)[0], context={"request": self.request} ).data self.assertEqual(serialized["course"]["number"], self.course.display_coursenumber) self.assertEqual(serialized["course"]["org"], self.course.display_organization)
def test_with_display_overrides(self): self.login_and_enroll() self.course.display_coursenumber = "overridden_number" self.course.display_organization = "overridden_org" self.store.update_item(self.course, self.user.id) serialized = CourseEnrollmentSerializer(CourseEnrollment.enrollments_for_user(self.user)[0]).data # pylint: disable=no-member self.assertEqual(serialized['course']['number'], self.course.display_coursenumber) self.assertEqual(serialized['course']['org'], self.course.display_organization)
def get_fulfillable_course_runs_for_entitlement(entitlement, course_runs): """ Takes a list of course runs and returns only the course runs, sorted by start date, that: 1) Are currently running or in the future 2) A user can enroll in 3) A user can upgrade in 4) Are published 5) Are not enrolled in already for an active session These are the only sessions that can be selected for an entitlement. """ enrollable_sessions = [] enrollments_for_user = CourseEnrollment.enrollments_for_user( entitlement.user).filter(mode=entitlement.mode) enrolled_sessions = frozenset( [str(e.course_id) for e in enrollments_for_user]) # Only show published course runs that can still be enrolled and upgraded now = datetime.datetime.now(UTC) for course_run in course_runs: # Only courses that have not ended will be displayed run_start = course_run.get('start') run_end = course_run.get('end') is_running = run_start and (not run_end or datetime_parse(run_end) > now) # Only courses that can currently be enrolled in will be displayed enrollment_start = course_run.get('enrollment_start') enrollment_end = course_run.get('enrollment_end') can_enroll = ( (not enrollment_start or datetime_parse(enrollment_start) < now) and (not enrollment_end or datetime_parse(enrollment_end) > now) and course_run.get('key') not in enrolled_sessions) # Only upgrade-able courses will be displayed can_upgrade = False for seat in course_run.get('seats', []): if seat.get('type') == entitlement.mode: upgrade_deadline = seat.get('upgrade_deadline', None) can_upgrade = not upgrade_deadline or ( datetime_parse(upgrade_deadline) > now) break # Only published courses will be displayed is_published = course_run.get('status') == 'published' if is_running and can_upgrade and can_enroll and is_published: enrollable_sessions.append(course_run) enrollable_sessions.sort(key=lambda session: session.get('start')) return enrollable_sessions
def test_generate_enrollment_status_hash(self): """ Verify the method returns a hash of a user's current enrollments. """ # Return None for anonymous users self.assertIsNone( CourseEnrollment.generate_enrollment_status_hash(AnonymousUser())) # No enrollments expected = hashlib.md5(self.user.username.encode('utf-8')).hexdigest() self.assertEqual( CourseEnrollment.generate_enrollment_status_hash(self.user), expected) self.assert_enrollment_status_hash_cached(self.user, expected) # No active enrollments enrollment_mode = 'verified' course_id = self.course.id # pylint: disable=no-member enrollment = CourseEnrollmentFactory.create(user=self.user, course_id=course_id, mode=enrollment_mode, is_active=False) self.assertEqual( CourseEnrollment.generate_enrollment_status_hash(self.user), expected) self.assert_enrollment_status_hash_cached(self.user, expected) # One active enrollment enrollment.is_active = True enrollment.save() expected = '{username}&{course_id}={mode}'.format( username=self.user.username, course_id=str(course_id).lower(), mode=enrollment_mode.lower()) expected = hashlib.md5(expected.encode('utf-8')).hexdigest() self.assertEqual( CourseEnrollment.generate_enrollment_status_hash(self.user), expected) self.assert_enrollment_status_hash_cached(self.user, expected) # Multiple enrollments CourseEnrollmentFactory.create(user=self.user) enrollments = CourseEnrollment.enrollments_for_user( self.user).order_by(Lower('course_id')) hash_elements = [self.user.username] hash_elements += [ '{course_id}={mode}'.format( course_id=str(enrollment.course_id).lower(), mode=enrollment.mode.lower()) for enrollment in enrollments ] expected = hashlib.md5( '&'.join(hash_elements).encode('utf-8')).hexdigest() self.assertEqual( CourseEnrollment.generate_enrollment_status_hash(self.user), expected) self.assert_enrollment_status_hash_cached(self.user, expected)
def drop_enroll_courses(request): r = list() user = User.objects.get(id=request.GET.get('user_id')) for enrollment in CourseEnrollment.enrollments_for_user(user): try: course = course_from_id(enrollment.course_id) r.append({"id": course.id, "name": str(course.display_coursenumber) + ' ' + course.display_name}) except ItemNotFoundError: log.error("User {0} enrolled in non-existent course {1}".format(user.username, enrollment.course_id)) r.sort(key=lambda x: x['name'], reverse=False) return HttpResponse(json.dumps(r), content_type="application/json")
def test_with_display_overrides(self): self.course.display_coursenumber = "overridden_number" self.course.display_organization = "overridden_org" self.store.update_item(self.course, self.user.id) serialized = CourseEnrollmentSerializer( CourseEnrollment.enrollments_for_user(self.user)[0], context={'request': self.request}, ).data self.assertEqual(serialized['course']['number'], self.course.display_coursenumber) self.assertEqual(serialized['course']['org'], self.course.display_organization)
def get_course_enrollments(user): """ Returns the course enrollments for the passed in user within the context of a microsite, that is filtered by course_org_filter """ enrollments = CourseEnrollment.enrollments_for_user(user) microsite_org = microsite.get_value("course_org_filter") if microsite_org: site_enrollments = [enrollment for enrollment in enrollments if enrollment.course_id.org == microsite_org] else: site_enrollments = [enrollment for enrollment in enrollments] return site_enrollments
def get_serialized_data(self, api_version): ''' Return data from CourseEnrollmentSerializer ''' if api_version == API_V05: serializer = CourseEnrollmentSerializerv05 else: serializer = CourseEnrollmentSerializer return serializer( CourseEnrollment.enrollments_for_user(self.user)[0], context={'request': self.request, 'api_version': api_version}, ).data
def show_load_all_courses_link(user, course_limit, course_enrollments): """ By default dashboard will show limited courses based on the course limit set in configuration. A link would be provided provided at the bottom to load all the courses if there are any courses. """ if course_limit is None: return False total_enrollments = CourseEnrollment.enrollments_for_user(user).count() return len(course_enrollments) < total_enrollments
def dashboard(request): user = request.user # Build our courses list for the user, but ignore any courses that no longer # exist (because the course IDs have changed). Still, we don't delete those # enrollments, because it could have been a data push snafu. courses = [] for enrollment in CourseEnrollment.enrollments_for_user(user): try: courses.append(course_from_id(enrollment.course_id)) except ItemNotFoundError: log.error("User {0} enrolled in non-existent course {1}" .format(user.username, enrollment.course_id)) message = "" if not user.is_active: message = render_to_string('registration/activate_account_notice.html', {'email': user.email}) # Global staff can see what courses errored on their dashboard staff_access = False errored_courses = {} if has_access(user, 'global', 'staff'): # Show any courses that errored on load staff_access = True errored_courses = modulestore().get_errored_courses() show_courseware_links_for = frozenset(course.id for course in courses if has_access(request.user, course, 'load')) cert_statuses = {course.id: cert_info(request.user, course) for course in courses} exam_registrations = {course.id: exam_registration_info(request.user, course) for course in courses} # get info w.r.t ExternalAuthMap external_auth_map = None try: external_auth_map = ExternalAuthMap.objects.get(user=user) except ExternalAuthMap.DoesNotExist: pass context = {'courses': courses, 'message': message, 'external_auth_map': external_auth_map, 'staff_access': staff_access, 'errored_courses': errored_courses, 'show_courseware_links_for': show_courseware_links_for, 'cert_statuses': cert_statuses, 'exam_registrations': exam_registrations, } return render_to_response('dashboard.html', context)
def get_course_enrollments(user): """ Returns the course enrollments for the passed in user within the context of current org, that is filtered by course_org_filter """ enrollments = CourseEnrollment.enrollments_for_user(user) course_org = configuration_helpers.get_value('course_org_filter') if course_org: site_enrollments = [ enrollment for enrollment in enrollments if enrollment.course_id.org == course_org ] else: site_enrollments = [enrollment for enrollment in enrollments] return site_enrollments
def get_course_enrollments(user): """ Returns the course enrollments for the passed in user within the context of a microsite, that is filtered by course_org_filter """ enrollments = CourseEnrollment.enrollments_for_user(user) microsite_org = microsite.get_value('course_org_filter') if microsite_org: site_enrollments = [ enrollment for enrollment in enrollments if enrollment.course_id.org == microsite_org ] else: site_enrollments = [enrollment for enrollment in enrollments] return site_enrollments
def field_dictionary(self, **kwargs): """ add course if provided otherwise add courses in which the user is enrolled in """ field_dictionary = super(LmsSearchFilterGenerator, self).field_dictionary(**kwargs) if not kwargs.get('user'): field_dictionary['course'] = [] elif not kwargs.get('course_id'): user_enrollments = CourseEnrollment.enrollments_for_user(kwargs['user']) field_dictionary['course'] = [unicode(enrollment.course_id) for enrollment in user_enrollments] # if we have an org filter, only include results for this org filter course_org_filter = microsite.get_value('course_org_filter') if course_org_filter: field_dictionary['org'] = course_org_filter return field_dictionary
def field_dictionary(self, **kwargs): """ add course if provided otherwise add courses in which the user is enrolled in """ field_dictionary = super(LmsSearchFilterGenerator, self).field_dictionary(**kwargs) if not kwargs.get('user'): field_dictionary['course'] = [] elif not kwargs.get('course_id'): user_enrollments = CourseEnrollment.enrollments_for_user( kwargs['user']) field_dictionary['course'] = [ unicode(enrollment.course_id) for enrollment in user_enrollments ] return field_dictionary
def test_success(self): serialized = CourseEnrollmentSerializer( CourseEnrollment.enrollments_for_user(self.user)[0], context={'request': self.request}, ).data self.assertEqual(serialized['course']['name'], self.course.display_name) self.assertEqual(serialized['course']['number'], self.course.id.course) self.assertEqual(serialized['course']['org'], self.course.id.org) # Assert utm parameters expected_utm_parameters = { 'twitter': 'utm_campaign=social-sharing&utm_medium=social-post&utm_source=twitter', 'facebook': 'utm_campaign=social-sharing&utm_medium=social-post&utm_source=facebook' } self.assertEqual(serialized['course']['course_sharing_utm_parameters'], expected_utm_parameters)
def get_course_enrollments(user): """ Returns the course enrollments for the passed in user within the context of current org, that is filtered by course_org_filter """ enrollments = CourseEnrollment.enrollments_for_user(user) course_org = configuration_helpers.get_value('course_org_filter') if course_org: site_enrollments = [ enrollment for enrollment in enrollments if enrollment.course_id.org == course_org ] else: site_enrollments = [ enrollment for enrollment in enrollments ] return site_enrollments
def _listen_for_track_change(sender, user, **kwargs): # pylint: disable=unused-argument """ Catches a track change signal, determines user status, calls fire_ungenerated_certificate_task for passing grades """ if (not waffle.waffle().is_enabled(waffle.SELF_PACED_ONLY) and not waffle.waffle().is_enabled(waffle.INSTRUCTOR_PACED_ONLY)): return user_enrollments = CourseEnrollment.enrollments_for_user(user=user) grade_factory = CourseGradeFactory() for enrollment in user_enrollments: if grade_factory.read(user=user, course=enrollment.course).passed: if fire_ungenerated_certificate_task(user, enrollment.course.id): log.info( u'Certificate generation task initiated for {user} : {course} via track change' .format(user=user.id, course=enrollment.course.id))
def _listen_for_track_change(sender, user, **kwargs): # pylint: disable=unused-argument """ Catches a track change signal, determines user status, calls fire_ungenerated_certificate_task for passing grades """ if not auto_certificate_generation_enabled(): return user_enrollments = CourseEnrollment.enrollments_for_user(user=user) grade_factory = CourseGradeFactory() for enrollment in user_enrollments: if grade_factory.read(user=user, course=enrollment.course_overview).passed: if fire_ungenerated_certificate_task(user, enrollment.course_id): log.info( u'Certificate generation task initiated for {user} : {course} via track change' .format(user=user.id, course=enrollment.course_id))
def _listen_for_track_change(sender, user, **kwargs): # pylint: disable=unused-argument """ Catches a track change signal, determines user status, calls fire_ungenerated_certificate_task for passing grades """ if not auto_certificate_generation_enabled(): return user_enrollments = CourseEnrollment.enrollments_for_user(user=user) grade_factory = CourseGradeFactory() for enrollment in user_enrollments: if grade_factory.read(user=user, course=enrollment.course_overview).passed: if fire_ungenerated_certificate_task(user, enrollment.course_id): log.info(u'Certificate generation task initiated for {user} : {course} via track change'.format( user=user.id, course=enrollment.course_id ))
def test_course_about_marketing_url(self): self.register_catalog_course_run_response(self.course_keys, [self.course_run]) catalog_course_runs_against_course_keys = get_course_runs(self.course_keys, self.request.user) enrollment = CourseEnrollment.enrollments_for_user(self.user)[0] serialized = CourseEnrollmentSerializer( enrollment, context={ 'request': self.request, "catalog_course_run": ( catalog_course_runs_against_course_keys[unicode(enrollment.course_id)] if unicode(enrollment.course_id) in catalog_course_runs_against_course_keys else None ) }, ).data self.assertEqual( serialized['course']['course_about'], self.course_run["marketing_url"] )
def test_course_about_lms_url(self): self.register_catalog_course_run_response(self.course_keys, [self.course_run]) catalog_course_runs_against_course_keys = get_course_runs(self.course_keys, self.request.user) enrollment = CourseEnrollment.enrollments_for_user(self.user)[0] serialized = CourseEnrollmentSerializer( enrollment, context={ 'request': self.request, "catalog_course_run": ( catalog_course_runs_against_course_keys[unicode(enrollment.course_id)] if unicode(enrollment.course_id) in catalog_course_runs_against_course_keys else None ) }, ).data self.assertEqual( serialized['course']['course_about'], "http://localhost:8000/courses/{}/about".format(self.course_id_string) )
def prediction(telegram_id): telegram_user = EdxTelegramUser.objects.get(telegram_id=telegram_id) results = CourseEnrollment.enrollments_for_user(telegram_user.student) course_matrix = TfidMatrixAllCourses.objects.all().first().matrix list_of_user_courses_indexes = [MatrixEdxCoursesId.objects.filter(course_key=course.course_id).first().course_index for course in results] user_vector = TfidUserVector.objects.get(telegram_user=telegram_user) cosine_similarities = linear_kernel(user_vector.vector, course_matrix).flatten() # removing courses on which user already enrolled if len(list_of_user_courses_indexes) == len(cosine_similarities): return -1 cosine_similarities[list_of_user_courses_indexes] = -1000 related_docs_indices = cosine_similarities.argsort() little_random = np.random.randint(5,10) return related_docs_indices[-little_random]