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_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 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 __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 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 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]
