def test_get_courses_by_org(self):
"""
Verify that org filtering performs as expected, and that an empty result
is returned if the org passed by the caller does not match the designated
org.
"""
primary = 'primary'
alternate = 'alternate'
def _fake_get_value(value, default=None):
"""Used to stub out site_configuration.helpers.get_value()."""
if value == 'course_org_filter':
return alternate
return default
user = UserFactory.create()
# Pass `emit_signals=True` so that these courses are cached with CourseOverviews.
primary_course = CourseFactory.create(org=primary, emit_signals=True)
alternate_course = CourseFactory.create(org=alternate, emit_signals=True)
self.assertNotEqual(primary_course.org, alternate_course.org)
unfiltered_courses = get_courses(user)
for org in [primary_course.org, alternate_course.org]:
self.assertTrue(
any(course.org == org for course in unfiltered_courses)
)
filtered_courses = get_courses(user, org=primary)
self.assertTrue(
all(course.org == primary_course.org for course in filtered_courses)
)
with mock.patch(
'openedx.core.djangoapps.site_configuration.helpers.get_value',
autospec=True,
) as mock_get_value:
mock_get_value.side_effect = _fake_get_value
# Request filtering for an org distinct from the designated org.
no_courses = get_courses(user, org=primary)
self.assertEqual(no_courses, [])
# Request filtering for an org matching the designated org.
site_courses = get_courses(user, org=alternate)
self.assertTrue(
all(course.org == alternate_course.org for course in site_courses)
)
def test_get_courses_by_org(self):
"""
Verify that org filtering performs as expected, and that an empty result
is returned if the org passed by the caller does not match the designated
org.
"""
primary = 'primary'
alternate = 'alternate'
def _fake_get_value(value, default=None):
"""Used to stub out site_configuration.helpers.get_value()."""
if value == 'course_org_filter':
return alternate
return default
user = UserFactory.create()
# Pass `emit_signals=True` so that these courses are cached with CourseOverviews.
primary_course = CourseFactory.create(org=primary, emit_signals=True)
alternate_course = CourseFactory.create(org=alternate,
emit_signals=True)
self.assertNotEqual(primary_course.org, alternate_course.org)
unfiltered_courses = get_courses(user)
for org in [primary_course.org, alternate_course.org]:
self.assertTrue(
any(course.org == org for course in unfiltered_courses))
filtered_courses = get_courses(user, org=primary)
self.assertTrue(
all(course.org == primary_course.org
for course in filtered_courses))
with mock.patch(
'openedx.core.djangoapps.site_configuration.helpers.get_value',
autospec=True,
) as mock_get_value:
mock_get_value.side_effect = _fake_get_value
# Request filtering for an org distinct from the designated org.
no_courses = get_courses(user, org=primary)
self.assertEqual(list(no_courses), [])
# Request filtering for an org matching the designated org.
site_courses = get_courses(user, org=alternate)
self.assertTrue(
all(course.org == alternate_course.org
for course in site_courses))
def search_courses(request):
"""
Render "find courses" page. The course selection work is done in courseware.courses.
"""
courses = get_courses1(request,request.user, request.META.get('HTTP_HOST'))
courses = sort_by_announcement(courses)
c_list=[]
c_num=[]
c_len=CourseCategory.objects.all().count()
for i in range(1,c_len+1):
c_name=CourseCategory.objects.get(id = i).category_name
c_list.append(c_name)
all_courses = get_courses(request.user, request.META.get('HTTP_HOST'))
all_c_num = len(all_courses)
for j in range(1,17):
c_num.append(0)
for c in all_courses:
c_category = c.display_number_with_default[0:2]
c_category_no = int(c_category)
num_t=c_num[c_category_no-1]
c_num[c_category_no-1]=num_t+1
name_list=[]
category_list=[]
category_num=[]
for i in range (0,len(c_num)):
if c_num[i]!=0:
if i<9:
num='0'+str(int(i+1))
name_list.append(num)
else:
name_list.append(i+1)
category_list.append(c_list[i])
category_num.append(c_num[i])
none_zero=len(category_num)
return render_to_response("courseware/courses.html", {'courses': courses,'name_list':name_list,'category_list':category_list,'category_num':category_num,'all_c_num':all_c_num,'none_zero':none_zero})
def courses_search(request):
"""
Render "find courses" page. The course selection work is done in courseware.courses.
"""
if request.is_ajax():
query_string = ""
courses = []
query_string = request.GET['search_string']
if query_string is not None:
print "----------------------------------" + query_string + "\n"
entry_query = normalize_query(query_string)
allCourses = get_courses(request.user,
request.META.get('HTTP_HOST'))
for course in allCourses:
title = get_course_about_section(course, 'title').lower()
flag = True
for query in entry_query:
if not query.lower() in title:
flag = False
break
if flag:
courses.append(course)
courses = sort_by_announcement(courses)
if courses:
return render_to_response("courseware/courses_search.html",
{'courses': courses})
else:
return HttpResponse("No Courses Found")
def index(request, extra_context=None, user=AnonymousUser()):
"""
Render the edX main page.
extra_context is used to allow immediate display of certain modal windows, eg signup,
as used by external_auth.
"""
if extra_context is None:
extra_context = {}
courses = get_courses(user)
if configuration_helpers.get_value(
"ENABLE_COURSE_SORTING_BY_START_DATE",
settings.FEATURES["ENABLE_COURSE_SORTING_BY_START_DATE"],
):
courses = sort_by_start_date(courses)
else:
courses = sort_by_announcement(courses)
context = {'courses': courses}
context['homepage_overlay_html'] = configuration_helpers.get_value(
'homepage_overlay_html')
# This appears to be an unused context parameter, at least for the master templates...
context['show_partners'] = configuration_helpers.get_value(
'show_partners', True)
# TO DISPLAY A YOUTUBE WELCOME VIDEO
# 1) Change False to True
context['show_homepage_promo_video'] = configuration_helpers.get_value(
'show_homepage_promo_video', False)
# Maximum number of courses to display on the homepage.
context['homepage_course_max'] = configuration_helpers.get_value(
'HOMEPAGE_COURSE_MAX', settings.HOMEPAGE_COURSE_MAX)
# 2) Add your video's YouTube ID (11 chars, eg "123456789xX"), or specify via site configuration
# Note: This value should be moved into a configuration setting and plumbed-through to the
# context via the site configuration workflow, versus living here
youtube_video_id = configuration_helpers.get_value(
'homepage_promo_video_youtube_id', "your-youtube-id")
context['homepage_promo_video_youtube_id'] = youtube_video_id
# allow for theme override of the courses list
context['courses_list'] = theming_helpers.get_template_path(
'courses_list.html')
# Insert additional context for use in the template
context.update(extra_context)
# Add marketable programs to the context.
context['programs_list'] = get_programs_with_type(request.site,
include_hidden=False)
# TODO: Course Listing Plugin required
context['journal_info'] = get_journals_context(request)
return render_to_response('index.html', context)
def get_search_category(request):
courses = get_courses2(request,request.user, request.META.get('HTTP_HOST'))
courses = sort_by_announcement(courses)
json_list=json_courses(request,courses)
decodejson = json.loads(json_list)
c_list=[]
c_num=[]
c_len=CourseCategory.objects.all().count()
for i in range(1,c_len+1):
c_name=CourseCategory.objects.get(id = i).category_name
c_list.append(c_name)
all_courses = get_courses(request.user, request.META.get('HTTP_HOST'))
all_c_num = len(all_courses)
for j in range(1,17):
c_num.append(0)
for c in all_courses:
c_category = c.display_number_with_default[0:2]
c_category_no = int(c_category)
num_t=c_num[c_category_no-1]
c_num[c_category_no-1]=num_t+1
decodejson.append(c_list)
decodejson.append(c_num)
decodejson.append(all_c_num)
decodejson.append(c_len)
return JsonResponse(decodejson)
def search_category(request):
courses = get_courses2(request, request.user,
request.META.get('HTTP_HOST'))
courses = sort_by_announcement(courses)
c_list = []
c_num = []
c_len = CourseCategory.objects.all().count()
for i in range(1, c_len + 1):
c_name = CourseCategory.objects.get(id=i).category_name
c_list.append(c_name)
all_courses = get_courses(request.user, request.META.get('HTTP_HOST'))
all_c_num = len(all_courses)
for j in range(1, 17):
c_num.append(0)
for c in all_courses:
c_category = c.display_number_with_default[0:2]
c_category_no = int(c_category)
num_t = c_num[c_category_no - 1]
c_num[c_category_no - 1] = num_t + 1
return render_to_response(
"courseware/courses.html", {
'courses': courses,
'c_list': c_list,
'c_num': c_num,
'all_c_num': all_c_num
})
def get_recommended_xmodule_courses(user):
"""
Helper function to get recommended courses based on the user interests and add details from xmodule to
the recommended courses
"""
recommended_courses = []
all_courses = get_courses(user)
user_interests = user.extended_profile.get_user_selected_interests()
if not user_interests:
return []
for course in all_courses:
settings = CustomSettings.objects.filter(id=course.id).first()
if not settings:
continue
tags = settings.tags
if not tags:
continue
tags = tags.split('|')
tags = [tag.strip() for tag in tags]
matched_interests = set(user_interests) & set(tags)
if matched_interests and not CourseEnrollment.is_enrolled(user, course.id):
detailed_course = modulestore().get_course(course.id)
detailed_course.short_description = course.short_description
detailed_course.interests = '/ '.join(list(matched_interests))
recommended_courses.append(detailed_course)
return recommended_courses
def courses_search(request):
"""
Render "find courses" page. The course selection work is done in courseware.courses.
"""
if request.is_ajax():
query_string=""
courses=[]
query_string = request.GET['search_string']
if query_string is not None:
print "----------------------------------"+query_string+"\n"
entry_query=normalize_query(query_string)
allCourses = get_courses(request.user, request.META.get('HTTP_HOST'))
for course in allCourses:
title=get_course_about_section(course,'title').lower()
flag=True
for query in entry_query:
if not query.lower() in title:
flag=False
break
if flag:
courses.append(course)
courses = sort_by_announcement(courses)
if courses:
return render_to_response("courseware/courses_search.html", {'courses': courses})
else:
return HttpResponse("No Courses Found")
def get_search_category(request):
courses = get_courses2(request, request.user,
request.META.get('HTTP_HOST'))
courses = sort_by_announcement(courses)
json_list = json_courses(request, courses)
decodejson = json.loads(json_list)
c_list = []
c_num = []
c_len = CourseCategory.objects.all().count()
for i in range(1, c_len + 1):
c_name = CourseCategory.objects.get(id=i).category_name
c_list.append(c_name)
all_courses = get_courses(request.user, request.META.get('HTTP_HOST'))
all_c_num = len(all_courses)
for j in range(1, 17):
c_num.append(0)
for c in all_courses:
c_category = c.display_number_with_default[0:2]
c_category_no = int(c_category)
num_t = c_num[c_category_no - 1]
c_num[c_category_no - 1] = num_t + 1
decodejson.append(c_list)
decodejson.append(c_num)
decodejson.append(all_c_num)
decodejson.append(c_len)
return JsonResponse(decodejson)
def course_kinds_about(request, course_kind):
"""this is to show the kinds of course page"""
#print course_kind
global s_plist
global s_mlist
global s_slist
courses = get_courses(request.user, request.META.get('HTTP_HOST'))
plist = get_primary_course(courses, course_kind)
s_plist = plist
mlist = get_Intermediate_course(courses, course_kind)
s_mlist = mlist
slist = get_senior_course(courses, course_kind)
s_slist = slist
plen = len(plist)
mlen = len(mlist)
slen = len(slist)
content = {
'course_kind': course_kind,
'slist': slist,
'plist': plist,
'mlist': mlist,
'plen': plen,
'mlen': mlen,
'slen': slen,
}
return render_to_response('courseware/course_kinds.html', content)
def drop_courses(request):
r = list()
courses = get_courses(None)
for course in courses:
course = course_from_id(course.id)
r.append({"id": course.id, "name": str(course.display_coursenumber) + ' ' + course.display_name})
r.sort(key=lambda x: x['name'], reverse=False)
return HttpResponse(json.dumps(r), content_type="application/json")
def courses(request):
"""
Render "find courses" page. The course selection work is done in courseware.courses.
"""
courses = get_courses(request.user, request.META.get('HTTP_HOST'))
courses = sort_by_announcement(courses)
return render_to_response("courseware/courses.html", {'courses': courses})
def courses(request):
"""
Render "find courses" page. The course selection work is done in courseware.courses.
"""
courses = get_courses(request.user, request.META.get('HTTP_HOST'))
courses = sort_by_announcement(courses)
return render_to_response("courseware/courses.html", {'courses': courses})
def courses(request):
"""
Render "find courses" page. The course selection work is done in courseware.courses.
"""
courses = get_courses(request.user, request.META.get('HTTP_HOST'))[:9]
courses = sort_by_announcement(courses)
return render_to_response("courseware/courses.html", {'courses': courses, 'homepage_promo_video_youtube_id': 'yY2gsC8bL3U'})
def courses_list_handler(request, action):
"""
Return courses based on request params
"""
try:
user = request.user
except:
user = AnonymousUser()
if action not in ["homefalls", "all", "hot", "latest", "my", "search", "rolling", "sync"]:
return JsonResponse({"success": False, "errmsg": "not support other actions except homefalls all hot latest rolling and my"})
def get_courses_depend_action(courses):
"""
Return courses depend on action
action: [homefalls, hot, lastest, my, search]
homefalls: get all courses
hot: Number of attended people > ?
lastest: News last week
my: I registered
all: like 'homefalls'
"""
courses = sort_and_audited_items(courses)
courses_list = []
if action == "latest":
default_count = 20
if len(courses) < default_count:
default_count = len(courses)
courses_list = courses[0:default_count]
elif action == "my":
# filter my registered courses
for course in courses:
if registered_for_course(course, user):
courses_list.append(course)
elif action == "rolling":
default_count = 5
courses_list = courses[0:default_count]
elif action == 'search':
keyword = request.GET.get("keyword")
if keyword:
for c in courses:
if keyword in c.org or keyword in c.id or keyword in c.display_name_with_default:
courses_list.append(c)
else:
courses_list = courses
return courses_list
courses = get_courses(user, request.META.get('HTTP_HOST'))
if action != "sync":
courses = get_courses_depend_action(courses)
return return_fixed_courses(request, courses, action)
def audit_courses(request, user=AnonymousUser()):
# The course selection work is done in courseware.courses.
domain = settings.FEATURES.get('FORCE_UNIVERSITY_DOMAIN') # normally False
# do explicit check, because domain=None is valid
if domain is False:
domain = request.META.get('HTTP_HOST')
courses = get_courses(user, domain=domain)
return filter_audited_items(sort_by_announcement(courses))
def get_filtered_course_infos(request):
course_infos = get_course_infos(get_courses(request.user))
pattern = request.GET.get('search')
if pattern:
course_infos = [course for course in course_infos
if pattern in course.title
or pattern in course.course.id.to_deprecated_string()]
return course_infos, pattern
def index(request, extra_context=None, user=AnonymousUser()):
"""
Render the edX main page.
extra_context is used to allow immediate display of certain modal windows, eg signup,
as used by external_auth.
"""
if extra_context is None:
extra_context = {}
courses = get_courses(user)
if configuration_helpers.get_value(
"ENABLE_COURSE_SORTING_BY_START_DATE",
settings.FEATURES["ENABLE_COURSE_SORTING_BY_START_DATE"],
):
courses = sort_by_start_date(courses)
else:
courses = sort_by_announcement(courses)
context = {'courses': courses}
context['homepage_overlay_html'] = configuration_helpers.get_value('homepage_overlay_html')
# This appears to be an unused context parameter, at least for the master templates...
context['show_partners'] = configuration_helpers.get_value('show_partners', True)
# TO DISPLAY A YOUTUBE WELCOME VIDEO
# 1) Change False to True
context['show_homepage_promo_video'] = configuration_helpers.get_value('show_homepage_promo_video', False)
# Maximum number of courses to display on the homepage.
context['homepage_course_max'] = configuration_helpers.get_value(
'HOMEPAGE_COURSE_MAX', settings.HOMEPAGE_COURSE_MAX
)
# 2) Add your video's YouTube ID (11 chars, eg "123456789xX"), or specify via site configuration
# Note: This value should be moved into a configuration setting and plumbed-through to the
# context via the site configuration workflow, versus living here
youtube_video_id = configuration_helpers.get_value('homepage_promo_video_youtube_id', "your-youtube-id")
context['homepage_promo_video_youtube_id'] = youtube_video_id
# allow for theme override of the courses list
context['courses_list'] = theming_helpers.get_template_path('courses_list.html')
# Insert additional context for use in the template
context.update(extra_context)
# Add marketable programs to the context.
context['programs_list'] = get_programs_with_type(request.site, include_hidden=False)
# TODO: Course Listing Plugin required
context['journal_info'] = get_journals_context(request)
return render_to_response('index.html', context)
def jump_to(request, school_key_string):
org = school_key_string
course_list = []
courses = get_courses(request.user, request.META.get('HTTP_HOST'))
for course in courses:
if course.display_org_with_default == org:
course_list.append(course)
return render_to_response("colleges/school_about.html", {
"course_list": course_list,
"org": org,
})
def jump_to(request, school_key_string):
org = school_key_string
course_list = []
courses = get_courses(request.user, request.META.get('HTTP_HOST'))
for course in courses:
if course.display_org_with_default == org:
course_list.append(course)
return render_to_response("colleges/school_about.html", {
"course_list": course_list,
"org": org,
})
def courses(request):
"""
Render "find courses" page. The course selection work is done in courseware.courses.
"""
courses = get_courses(request.user, request.META.get('HTTP_HOST'))
if microsite.get_value("ENABLE_COURSE_SORTING_BY_START_DATE",
settings.FEATURES["ENABLE_COURSE_SORTING_BY_START_DATE"]):
courses = sort_by_start_date(courses)
else:
courses = sort_by_announcement(courses)
return render_to_response("courseware/courses.html", {'courses': courses})
def courses(request):
"""
Render "find courses" page. The course selection work is done in courseware.courses.
"""
courses = get_courses(request.user, request.META.get('HTTP_HOST'))
courses = sort_by_announcement(courses)
universities = []
for course in courses:
university = get_course_about_section(course,'university')
if not university in universities:
universities.append(university)
universities.sort()
return render_to_response("courseware/courses.html", {'courses': courses,'universities':universities})
def courses(request):
"""
Render "find courses" page. The course selection work is done in courseware.courses.
"""
courses = get_courses(request.user, request.META.get('HTTP_HOST'))
if microsite.get_value("ENABLE_COURSE_SORTING_BY_START_DATE",
settings.FEATURES["ENABLE_COURSE_SORTING_BY_START_DATE"]):
courses = sort_by_start_date(courses)
else:
courses = sort_by_announcement(courses)
return render_to_response("courseware/courses.html", {'courses': courses})
def get_featured_courses(user):
featured_courses = []
courses = get_courses(user)
featured_custom_settings = CustomSettings.objects.filter(is_featured=True).values_list('id', flat=True)
for course in courses:
if unicode(course.id) in featured_custom_settings:
course_details = modulestore().get_course(course.id)
instructors = course_details.instructor_info.get('instructors')
course.instructors = instructors if instructors else []
featured_courses += [course]
return featured_courses
def university_search(request,org_id=""):
if request.is_ajax():
query_university=org_id
courses = []
allCourses = get_courses(request.user, request.META.get('HTTP_HOST'))
if query_university is not None:
for course in allCourses:
university=get_course_about_section(course,'university')
if (query_university.lower() in university.lower()) and (university.lower() in query_university.lower()):
courses.append(course)
if courses:
return render_to_response("courseware/courses_search.html",{'courses':courses})
else:
return HttpResponse("No Courses Found")
def course_list(request, extra_context={}, user=AnonymousUser()):
def course_filter(course,org='ncepu',subject=''):
#print request
if course.org == org:
return True
return False
domain = settings.FEATURES.get('FORCE_UNIVERSITY_DOMAIN')
if domain is False:
domain = request.META.get('HTTP_HOST')
courses = get_courses(user, domain=domain)
courses = filter(course_filter,courses)
courses = sort_by_announcement(courses)
context = {'courses': courses,'request':request}
#return render_to_response('murp/selects.html',context)
return render_to_response('murp/mytest.html',context)
def get_university_courses(user, university_code):
"""
Returns an array containing courses object for the given
organization.
"""
courses = get_courses(user)
if university_code == "other":
# "other" courses that are associated to organizations that are not
# listed in the university page.
university_codes = University.objects.values_list('code', flat=True)
courses = [c for c in courses if c.org not in university_codes]
else:
courses = [c for c in courses if c.org == university_code]
courses = sort_by_announcement(courses)
return courses
def university_search(request, org_id=""):
if request.is_ajax():
query_university = org_id
courses = []
allCourses = get_courses(request.user, request.META.get('HTTP_HOST'))
if query_university is not None:
for course in allCourses:
university = get_course_about_section(course, 'university')
if (query_university.lower() in university.lower()) and (
university.lower() in query_university.lower()):
courses.append(course)
if courses:
return render_to_response("courseware/courses_search.html",
{'courses': courses})
else:
return HttpResponse("No Courses Found")
def course_attr_list_handler(request, course_category, course_level=None):
courses = get_courses(request.user, request.META.get('HTTP_HOST'))
courses = sort_and_audited_items(courses)
courses_list = []
for course in courses:
if course_level:
if course.course_level == course_level and course.course_category == course_category:
courses_list.append(course)
elif course.course_category == course_category:
courses_list.append(course)
else:
continue
return return_fixed_courses(request, courses_list, None)
def courses(request):
"""
Render "find courses" page. The course selection work is done in courseware.courses.
"""
courses = get_courses(request.user, request.META.get('HTTP_HOST'))
courses = sort_by_announcement(courses)
universities = []
for course in courses:
university = get_course_about_section(course, 'university')
if not university in universities:
universities.append(university)
universities.sort()
return render_to_response("courseware/courses.html", {
'courses': courses,
'universities': universities
})
def course_attr_list_handler(request, course_category, course_level=None):
courses = get_courses(request.user, request.META.get('HTTP_HOST'))
courses = sort_and_audited_items(courses)
courses_list = []
for course in courses:
if course_level:
if course.course_level == course_level and course.course_category == course_category:
courses_list.append(course)
elif course.course_category == course_category:
courses_list.append(course)
else:
continue
return return_fixed_courses(request, courses_list, None)
def major_search(request):
major_result = request.POST
major_s = major_result.get('search').lower()
major_m = major_result.get('major_name').lower()#choise major
major_g = major_result.get('grade').lower()#choice grade
course_select=[]
courses_L = get_courses(request.user, request.META.get('HTTP_HOST'))
courses_L = sort_by_announcement(courses_L)
if major_s==None:
return render_to_response("courseware/courses.html", {'courses': courses_L})
else:
for course in courses_L:
major_title=get_course_about_section(course, 'title').lower()
if major_s in major_title:
course_select.append(course)
return render_to_response("courseware/courses.html", {'courses': course_select})
def search_courses(request):
"""
Render "find courses" page. The course selection work is done in courseware.courses.
"""
courses = get_courses1(request, request.user,
request.META.get('HTTP_HOST'))
courses = sort_by_announcement(courses)
c_list = []
c_num = []
c_len = CourseCategory.objects.all().count()
for i in range(1, c_len + 1):
c_name = CourseCategory.objects.get(id=i).category_name
c_list.append(c_name)
all_courses = get_courses(request.user, request.META.get('HTTP_HOST'))
all_c_num = len(all_courses)
for j in range(1, 17):
c_num.append(0)
for c in all_courses:
c_category = c.display_number_with_default[0:2]
c_category_no = int(c_category)
num_t = c_num[c_category_no - 1]
c_num[c_category_no - 1] = num_t + 1
name_list = []
category_list = []
category_num = []
for i in range(0, len(c_num)):
if c_num[i] != 0:
if i < 9:
num = '0' + str(int(i + 1))
name_list.append(num)
else:
name_list.append(i + 1)
category_list.append(c_list[i])
category_num.append(c_num[i])
none_zero = len(category_num)
return render_to_response(
"courseware/courses.html", {
'courses': courses,
'name_list': name_list,
'category_list': category_list,
'category_num': category_num,
'all_c_num': all_c_num,
'none_zero': none_zero
})
def test_get_courses_with_filter(self):
"""
Verify that filtering performs as expected.
"""
user = UserFactory.create()
non_mobile_course = CourseFactory.create(emit_signals=True)
mobile_course = CourseFactory.create(mobile_available=True, emit_signals=True)
test_cases = (
(None, {non_mobile_course.id, mobile_course.id}),
(dict(mobile_available=True), {mobile_course.id}),
(dict(mobile_available=False), {non_mobile_course.id}),
)
for filter_, expected_courses in test_cases:
self.assertEqual(
{course.id for course in get_courses(user, filter_=filter_)},
expected_courses,
"testing get_courses with filter_={}".format(filter_),
)
def courses(request):
"""
Render "find courses" page. The course selection work is done in courseware.courses.
"""
courses = sort_by_announcement(get_courses(request.user, request.META.get('HTTP_HOST')))
course_list = []
for course in courses:
course_item = {
"display_number": course.display_number_with_default,
"course_title": get_course_about_section(course, 'title'),
"course_description": get_course_about_section(course, 'short_description'),
"display_organization": get_course_about_section(course, 'university'),
"course_image_url": course_image_url(course),
"course_start": course.start,
"course_id": course.id.to_deprecated_string(),
}
course_list.append(course_item)
return JsonResponse(course_list)
def get_recommended_courses(user):
"""
Helper function to get recommended courses for a user based on his interests
"""
recommended_courses = []
all_courses = get_courses(user)
try:
user_interests = user.extended_profile.get_user_selected_interests()
for course in all_courses:
try:
tags = CustomSettings.objects.filter(id=course.id).first().tags
tags = tags.split('|')
tags = [tag.strip() for tag in tags]
if set(user_interests) & set(tags) and not CourseEnrollment.is_enrolled(user, course.id):
recommended_courses.append(course)
except AttributeError:
pass
except ObjectDoesNotExist:
pass
return recommended_courses
def search_category(request):
courses = get_courses2(request,request.user, request.META.get('HTTP_HOST'))
courses = sort_by_announcement(courses)
c_list=[]
c_num=[]
c_len=CourseCategory.objects.all().count()
for i in range(1,c_len+1):
c_name=CourseCategory.objects.get(id = i).category_name
c_list.append(c_name)
all_courses = get_courses(request.user, request.META.get('HTTP_HOST'))
all_c_num = len(all_courses)
for j in range(1,17):
c_num.append(0)
for c in all_courses:
c_category = c.display_number_with_default[0:2]
c_category_no = int(c_category)
num_t=c_num[c_category_no-1]
c_num[c_category_no-1]=num_t+1
return render_to_response("courseware/courses.html", {'courses': courses,'c_list':c_list,'c_num':c_num,'all_c_num':all_c_num})
def major_search(request):
major_result = request.POST
major_s = major_result.get('search').lower()
major_m = major_result.get('major_name').lower() #choise major
major_g = major_result.get('grade').lower() #choice grade
course_select = []
courses_L = get_courses(request.user, request.META.get('HTTP_HOST'))
courses_L = sort_by_announcement(courses_L)
if major_s == None and major_g == None and major_m == None:
return render_to_response("courseware/courses.html",
{'courses': courses_L})
elif major_s is not None:
for course in courses_L:
major_title = get_course_about_section(course, 'title').lower()
if major_s in major_title:
course_select.append(course)
return render_to_response("courseware/courses.html",
{'courses': course_select})
def index(request, extra_context={}, user=None):
'''
Render the edX main page.
extra_context is used to allow immediate display of certain modal windows, eg signup,
as used by external_auth.
'''
# The course selection work is done in courseware.courses.
domain = settings.MITX_FEATURES.get('FORCE_UNIVERSITY_DOMAIN') # normally False
# do explicit check, because domain=None is valid
if domain == False:
domain = request.META.get('HTTP_HOST')
courses = get_courses(None, domain=domain)
courses = sort_by_announcement(courses)
context = {'courses': courses}
context.update(extra_context)
return render_to_response('index.html', context)
def courses_list(request, status = "all", subject="all", destiny="all"):
all_courses = get_courses(request.user)
courses = []
for course in all_courses:
if (status == "new"):
if (not course.is_newish): continue
elif (status == "past"):
if (not course.has_ended()): continue
elif (status == "current"):
if (not course.has_started()): continue
elif (status != "all"):
continue
if (subject != "all"):
if not (subject in course.tags or dict(SUBJECTS).get(subject, '') in course.tags): continue
if (destiny != "all"):
if not (destiny in course.tags or dict(DESTINY).get(destiny, '') in course.tags): continue
courses += [course]
courses = sort_by_announcement(courses)
context = {'courses': courses, 'destiny': destiny, 'subject': subject}
return render_to_response("courses_list.html", context)
def get_courses_depend_action():
"""
Return courses depend on action
action: [homefalls, hot, lastest, my, search]
homefalls: get all courses
hot: Number of attended people > ?
lastest: News last week
my: I registered
all: like 'homefalls'
"""
courses = get_courses(user, request.META.get('HTTP_HOST'))
courses = sort_by_announcement(courses)
courses_list = []
if action == "latest":
default_count = 20
if len(courses) < default_count:
default_count = len(courses)
courses_list = courses[0:default_count]
elif action == "my":
# filter my registered courses
for course in courses:
if registered_for_course(course, user):
courses_list.append(course)
elif action == "rolling":
default_count = 5
courses_list = courses[0:default_count]
elif action == 'search':
keyword = request.GET.get("keyword")
if keyword:
for c in courses:
print (keyword in c.org or keyword in c.id or keyword in c.display_name_with_default)
if keyword in c.org or keyword in c.id or keyword in c.display_name_with_default:
courses_list.append(c)
else:
courses_list = courses
return courses_list
def get_courses_depend_action():
"""
Return courses depend on action
action: [homefalls, hot, lastest, my, search]
homefalls: get all courses
hot: Number of attended people > ?
lastest: News last week
my: I registered
all: like 'homefalls'
"""
courses = get_courses(user, request.META.get('HTTP_HOST'))
courses = sort_by_announcement(courses)
courses_list = []
if action == "latest":
default_count = 20
if len(courses) < default_count:
default_count = len(courses)
courses_list = courses[0:default_count]
elif action == "my":
# filter my registered courses
for course in courses:
if registered_for_course(course, user):
courses_list.append(course)
elif action == "rolling":
default_count = 5
courses_list = courses[0:default_count]
elif action == 'search':
keyword = request.GET.get("keyword")
if keyword:
for c in courses:
print (keyword in c.org or keyword in c.id or keyword in c.display_name_with_default)
if keyword in c.org or keyword in c.id or keyword in c.display_name_with_default:
courses_list.append(c)
else:
courses_list = courses
return courses_list
def grade_report_generation(request):
"""
For generating the reports of all the courses.
"""
user = User.objects.get(pk=1)
courses_list = []
courses_list = get_courses(user)
for course in courses_list:
course_key =course.id
try:
instructor_task.api.submit_calculate_grades_csv(request, course_key)
success_status = ("The grade report is being created."
" To view the status of the report, see Pending Tasks below.")
except Exception as e:
already_running_status = ("The grade report is currently being created."
" To view the status of the report, see Pending Tasks below."
" You will be able to download the report when it is complete.")
print e.message
merge_reports()
return JsonResponse({"Reports Merged":"TRUE"})
def test_get_courses_with_filter(self):
"""
Verify that filtering performs as expected.
"""
user = UserFactory.create()
mobile_course = CourseFactory.create(emit_signals=True)
non_mobile_course =\
CourseFactory.create(mobile_available=False, emit_signals=True)
test_cases = (
(None, {non_mobile_course.id, mobile_course.id}),
(dict(mobile_available=True), {mobile_course.id}),
(dict(mobile_available=False), {non_mobile_course.id}),
)
for filter_, expected_courses in test_cases:
self.assertEqual(
{course.id
for course in get_courses(user, filter_=filter_)},
expected_courses,
u"testing get_courses with filter_={}".format(filter_),
)
def courses_index(request):
courses = [_dates_description(course) for course in get_courses(request.user)]
form = CourseFilteringForm(request.GET or None)
by = request.GET.get('by', COURSES_BY_PAGE) # override default page size
if form.is_valid():
if form.cleaned_data['university']:
university = University.objects.get(code=form.cleaned_data['university'])
children = [child.code for child in university.children.all()]
courses = [c for c in courses if c.org == form.cleaned_data['university'] or c.org in children]
if form.cleaned_data['state']:
now = timezone.make_aware(datetime.datetime.utcnow(), timezone.get_current_timezone())
if form.cleaned_data['state'] == 'future':
courses = [c for c in courses if c.start and c.start > now]
elif form.cleaned_data['state'] == 'current':
courses = [c for c in courses if c.start and c.start < now and c.end and c.end > now]
elif form.cleaned_data['state'] == 'past':
courses = [c for c in courses if c.end and c.end < now]
elif form.errors:
return redirect(course_index)
courses = _sort_courses(courses)
# paginate courses
paginator = Paginator(courses, by, orphans=3)
page = request.GET.get('page')
try:
courses = paginator.page(page)
except PageNotAnInteger:
courses = paginator.page(1)
except EmptyPage:
courses = paginator.page(paginator.num_pages)
return render(request, 'courses/index.html', {
'form': form,
'courses': courses,
'current_language': translation.get_language(),
})
def index(request, extra_context={}, user=None):
'''
Render the edX main page.
extra_context is used to allow immediate display of certain modal windows, eg signup,
as used by external_auth.
'''
# The course selection work is done in courseware.courses.
domain = settings.MITX_FEATURES.get('FORCE_UNIVERSITY_DOMAIN') # normally False
# do explicit check, because domain=None is valid
if domain == False:
domain = request.META.get('HTTP_HOST')
courses = get_courses(None, domain=domain)
courses = sort_by_announcement(courses)
# Get the 3 most recent news
top_news = _get_news(top=3)
context = {'courses': courses, 'news': top_news}
context.update(extra_context)
return render_to_response('index.html', context)
def course_kinds_about(request, course_kind):
"""this is to show the kinds of course page"""
#print course_kind
courses = get_courses(request.user, request.META.get('HTTP_HOST'))
plist = get_primary_course(courses, course_kind)
mlist = get_Intermediate_course(courses, course_kind)
slist = get_senior_course(courses, course_kind)
plen = len(plist)
mlen = len(mlist)
slen = len(slist)
content = {
'course_kind': course_kind,
'slist': slist,
'plist': plist,
'mlist': mlist,
'plen': plen,
'mlen': mlen,
'slen': slen,
}
return render_to_response('courseware/course_kinds.html', content)
def index_list(request):
state_temp = []
district_temp = []
district_name = {}
district_list = []
courses = get_courses(request.user, request.META.get('HTTP_HOST'))
courses = sort_by_custom(courses)
for course in courses:
if request.user.is_superuser is False:
if request.user.profile.district.state.name in course.display_state:
state_temp.append(request.user.profile.district.state.name)
if request.user.profile.district.code in course.display_district:
district = District.objects.filter(code=request.user.profile.district.code)[0]
district_temp.append(request.user.profile.district.code)
district_name[request.user.profile.district.code] = district.name
else:
if len(course.display_state) > 0 and is_all(course, 'state') is False:
state_temp.extend(course.display_state)
if len(course.display_district) > 0 and is_all(course, 'district') is False:
districts = District.objects.filter(code__in=course.display_district)
district_temp.extend(course.display_district)
for district in districts:
district_name[district.code] = district.name
state_list = sorted(set(state_temp), key=lambda x: x[0])
district_temp = sorted(set(district_temp), key=lambda x: x[0])
for dl in district_temp:
district_list.append({'id': dl, 'name': district_name[dl]})
return render_to_response('access_resource_library_list.html', {
"states": state_list,
"districts": district_list})
def all_courses(request, extra_context={}, user=AnonymousUser()):
"""
Render the edX main page.
extra_context is used to allow immediate display of certain modal windows, eg signup,
as used by external_auth.
"""
# The course selection work is done in courseware.courses.
domain = settings.FEATURES.get('FORCE_UNIVERSITY_DOMAIN') # normally False
# do explicit check, because domain=None is valid
if domain is False:
domain = request.META.get('HTTP_HOST')
# Hardcoded `AnonymousUser()` to hide unpublished courses always
courses = get_courses(AnonymousUser(), domain=domain)
courses = sort_by_announcement(courses)
courses = edraak_courses_logic(courses)
context = {'courses': courses}
context.update(extra_context)
return render_to_response('all_courses.html', context)
def tma_users_registered(self):
context = {}
enrolled_to_current_course = False
user_email = self.request.POST['user_email']
if User.objects.filter(email=user_email).exists():
user = User.objects.get(email=user_email)
#Get preprofile info
userprofile = UserProfile.objects.get(user=user)
try:
custom_field = json.loads(user.profile.custom_field)
first_name = custom_field['first_name']
last_name = custom_field['last_name']
except:
custom_field = {}
last_name = 'Undefined'
first_name = 'Undefined'
#Get courses enrollments
microsite_courses = get_courses(
user=user,
org=configuration_helpers.get_value('course_org_filter'))
user_ms_course_list = {}
for course in microsite_courses:
if CourseEnrollment.objects.filter(
user=user, course_id=course.id).exists():
user_ms_course_list[str(course.id)] = {
'course_name':
course.display_name_with_default,
'course_grades':
'/courses/' + str(course.id) + '/progress/' +
str(user.id),
'opened_enrollments':
is_enrollment_opened(course),
'opened_course':
is_course_opened(course),
'on_invitation':
course.invitation_only,
}
#Get user grade for this course
course_key = SlashSeparatedCourseKey.from_deprecated_string(
self.course_id)
current_course = get_course_by_id(course_key)
grade = CourseGradeFactory().create(user, current_course)
#User dates
if user.last_login is not None:
last_login = user.date_joined.strftime("%d-%b-%Y %H:%M:%S")
else:
last_login = _('User has not logged in yet')
context = {
'email': str(user_email),
'id': str(user.id),
'inscription':
str(user.date_joined.strftime("%d-%b-%Y %H:%M:%S")),
'last_login': last_login,
'first_name': first_name,
'last_name': last_name,
'user_ms_course_list': user_ms_course_list,
'custom_field': custom_field,
'grade': grade.grade_value['percent'],
'passed': grade.grade_value['grade'],
'active': user.is_active,
'login_failure': LoginFailures.is_user_locked_out(user),
}
#Check if user is registered to this course
course_key = SlashSeparatedCourseKey.from_deprecated_string(
self.course_id)
if CourseEnrollment.objects.filter(user=user,
course_id=course_key,
is_active=1).exists():
current_course_grades = '/courses/' + str(
self.course_id) + '/progress/' + str(user.id)
context['enrolled_to_current_course'] = True
context['current_course_grades'] = current_course_grades
else:
context['enrolled_to_current_course'] = False
else:
context = {
'error':
'Le participant n\'a pas de compte sur nos plateformes.'
}
return context
def student_dashboard(request):
"""
Provides the LMS dashboard view
TODO: This is lms specific and does not belong in common code.
Arguments:
request: The request object.
Returns:
The dashboard response.
"""
user = request.user
userNewData = UserProfile.objects.filter(user=user)
if not UserProfile.objects.filter(user=user).exists():
return redirect(reverse('account_settings'))
platform_name = configuration_helpers.get_value("platform_name",
settings.PLATFORM_NAME)
enable_verified_certificates = configuration_helpers.get_value(
'ENABLE_VERIFIED_CERTIFICATES',
settings.FEATURES.get('ENABLE_VERIFIED_CERTIFICATES'))
display_course_modes_on_dashboard = configuration_helpers.get_value(
'DISPLAY_COURSE_MODES_ON_DASHBOARD',
settings.FEATURES.get('DISPLAY_COURSE_MODES_ON_DASHBOARD', True))
activation_email_support_link = configuration_helpers.get_value(
'ACTIVATION_EMAIL_SUPPORT_LINK',
settings.ACTIVATION_EMAIL_SUPPORT_LINK) or settings.SUPPORT_SITE_LINK
hide_dashboard_courses_until_activated = configuration_helpers.get_value(
'HIDE_DASHBOARD_COURSES_UNTIL_ACTIVATED',
settings.FEATURES.get('HIDE_DASHBOARD_COURSES_UNTIL_ACTIVATED', False))
empty_dashboard_message = configuration_helpers.get_value(
'EMPTY_DASHBOARD_MESSAGE', None)
# Get the org whitelist or the org blacklist for the current site
site_org_whitelist, site_org_blacklist = get_org_black_and_whitelist_for_site(
)
course_enrollments = list(
get_course_enrollments(user, site_org_whitelist, site_org_blacklist))
# Get the entitlements for the user and a mapping to all available sessions for that entitlement
# If an entitlement has no available sessions, pass through a mock course overview object
(course_entitlements, course_entitlement_available_sessions,
unfulfilled_entitlement_pseudo_sessions
) = get_filtered_course_entitlements(user, site_org_whitelist,
site_org_blacklist)
# Record how many courses there are so that we can get a better
# understanding of usage patterns on prod.
monitoring_utils.accumulate('num_courses', len(course_enrollments))
# Sort the enrollment pairs by the enrollment date
course_enrollments.sort(key=lambda x: x.created, reverse=True)
# Retrieve the course modes for each course
enrolled_course_ids = [
enrollment.course_id for enrollment in course_enrollments
]
__, unexpired_course_modes = CourseMode.all_and_unexpired_modes_for_courses(
enrolled_course_ids)
course_modes_by_course = {
course_id: {mode.slug: mode
for mode in modes}
for course_id, modes in iteritems(unexpired_course_modes)
}
# Check to see if the student has recently enrolled in a course.
# If so, display a notification message confirming the enrollment.
enrollment_message = _create_recent_enrollment_message(
course_enrollments, course_modes_by_course)
course_optouts = Optout.objects.filter(user=user).values_list('course_id',
flat=True)
# Display activation message
activate_account_message = ''
if not user.is_active:
activate_account_message = Text(
_("Check your {email_start}{email}{email_end} inbox for an account activation link from {platform_name}. "
"If you need help, contact {link_start}{platform_name} Support{link_end}."
)
).format(
platform_name=platform_name,
email_start=HTML("<strong>"),
email_end=HTML("</strong>"),
email=user.email,
link_start=HTML(
"<a target='_blank' href='{activation_email_support_link}'>").
format(
activation_email_support_link=activation_email_support_link, ),
link_end=HTML("</a>"),
)
enterprise_message = get_dashboard_consent_notification(
request, user, course_enrollments)
recovery_email_message = recovery_email_activation_message = None
if is_secondary_email_feature_enabled_for_user(user=user):
try:
account_recovery_obj = AccountRecovery.objects.get(user=user)
except AccountRecovery.DoesNotExist:
recovery_email_message = Text(
_("Add a recovery email to retain access when single-sign on is not available. "
"Go to {link_start}your Account Settings{link_end}.")
).format(link_start=HTML(
"<a target='_blank' href='{account_setting_page}'>").format(
account_setting_page=reverse('account_settings'), ),
link_end=HTML("</a>"))
else:
if not account_recovery_obj.is_active:
recovery_email_activation_message = Text(
_("Recovery email is not activated yet. "
"Kindly visit your email and follow the instructions to activate it."
))
# Disable lookup of Enterprise consent_required_course due to ENT-727
# Will re-enable after fixing WL-1315
consent_required_courses = set()
enterprise_customer_name = None
# Account activation message
account_activation_messages = [
message for message in messages.get_messages(request)
if 'account-activation' in message.tags
]
# Global staff can see what courses encountered an error on their dashboard
staff_access = False
errored_courses = {}
if has_access(user, 'staff', 'global'):
# Show any courses that encountered an error on load
staff_access = True
errored_courses = modulestore().get_errored_courses()
show_courseware_links_for = {
enrollment.course_id: has_access(request.user, 'load',
enrollment.course_overview)
for enrollment in course_enrollments
}
# Find programs associated with course runs being displayed. This information
# is passed in the template context to allow rendering of program-related
# information on the dashboard.
meter = ProgramProgressMeter(request.site,
user,
enrollments=course_enrollments)
ecommerce_service = EcommerceService()
inverted_programs = meter.invert_programs()
urls, programs_data = {}, {}
bundles_on_dashboard_flag = WaffleFlag(
WaffleFlagNamespace(name=u'student.experiments'),
u'bundles_on_dashboard')
# TODO: Delete this code and the relevant HTML code after testing LEARNER-3072 is complete
if bundles_on_dashboard_flag.is_enabled(
) and inverted_programs and inverted_programs.items():
if len(course_enrollments) < 4:
for program in inverted_programs.values():
try:
program_uuid = program[0]['uuid']
program_data = get_programs(request.site,
uuid=program_uuid)
program_data = ProgramDataExtender(program_data,
request.user).extend()
skus = program_data.get('skus')
checkout_page_url = ecommerce_service.get_checkout_page_url(
*skus)
program_data[
'completeProgramURL'] = checkout_page_url + '&bundle=' + program_data.get(
'uuid')
programs_data[program_uuid] = program_data
except: # pylint: disable=bare-except
pass
# Construct a dictionary of course mode information
# used to render the course list. We re-use the course modes dict
# we loaded earlier to avoid hitting the database.
course_mode_info = {
enrollment.course_id: complete_course_mode_info(
enrollment.course_id,
enrollment,
modes=course_modes_by_course[enrollment.course_id])
for enrollment in course_enrollments
}
# Determine the per-course verification status
# This is a dictionary in which the keys are course locators
# and the values are one of:
#
# VERIFY_STATUS_NEED_TO_VERIFY
# VERIFY_STATUS_SUBMITTED
# VERIFY_STATUS_APPROVED
# VERIFY_STATUS_MISSED_DEADLINE
#
# Each of which correspond to a particular message to display
# next to the course on the dashboard.
#
# If a course is not included in this dictionary,
# there is no verification messaging to display.
verify_status_by_course = check_verify_status_by_course(
user, course_enrollments)
cert_statuses = {
enrollment.course_id: cert_info(request.user,
enrollment.course_overview)
for enrollment in course_enrollments
}
# only show email settings for Mongo course and when bulk email is turned on
show_email_settings_for = frozenset(
enrollment.course_id for enrollment in course_enrollments
if (BulkEmailFlag.feature_enabled(enrollment.course_id)))
# Verification Attempts
# Used to generate the "you must reverify for course x" banner
verification_status = IDVerificationService.user_status(user)
verification_errors = get_verification_error_reasons_for_display(
verification_status['error'])
# Gets data for midcourse reverifications, if any are necessary or have failed
statuses = ["approved", "denied", "pending", "must_reverify"]
reverifications = reverification_info(statuses)
block_courses = frozenset(
enrollment.course_id for enrollment in course_enrollments
if is_course_blocked(
request,
CourseRegistrationCode.objects.filter(
course_id=enrollment.course_id,
registrationcoderedemption__redeemed_by=request.user),
enrollment.course_id))
enrolled_courses_either_paid = frozenset(
enrollment.course_id for enrollment in course_enrollments
if enrollment.is_paid_course())
# If there are *any* denied reverifications that have not been toggled off,
# we'll display the banner
denied_banner = any(item.display for item in reverifications["denied"])
# Populate the Order History for the side-bar.
order_history_list = order_history(user,
course_org_filter=site_org_whitelist,
org_filter_out_set=site_org_blacklist)
# get list of courses having pre-requisites yet to be completed
courses_having_prerequisites = frozenset(
enrollment.course_id for enrollment in course_enrollments
if enrollment.course_overview.pre_requisite_courses)
courses_requirements_not_met = get_pre_requisite_courses_not_completed(
user, courses_having_prerequisites)
if 'notlive' in request.GET:
redirect_message = _(
"The course you are looking for does not start until {date}."
).format(date=request.GET['notlive'])
elif 'course_closed' in request.GET:
redirect_message = _(
"The course you are looking for is closed for enrollment as of {date}."
).format(date=request.GET['course_closed'])
elif 'access_response_error' in request.GET:
# This can be populated in a generalized way with fields from access response errors
redirect_message = request.GET['access_response_error']
else:
redirect_message = ''
valid_verification_statuses = [
'approved', 'must_reverify', 'pending', 'expired'
]
display_sidebar_on_dashboard = (
len(order_history_list)
or (verification_status['status'] in valid_verification_statuses
and verification_status['should_display']))
# Filter out any course enrollment course cards that are associated with fulfilled entitlements
for entitlement in [
e for e in course_entitlements
if e.enrollment_course_run is not None
]:
course_enrollments = [
enr for enr in course_enrollments
if entitlement.enrollment_course_run.course_id != enr.course_id
]
context = {
'journal_info':
get_journals_context(request), # TODO: Course Listing Plugin required
'courses':
get_courses(user),
'urls':
urls,
'programs_data':
programs_data,
'enterprise_message':
enterprise_message,
'consent_required_courses':
consent_required_courses,
'enterprise_customer_name':
enterprise_customer_name,
'enrollment_message':
enrollment_message,
'redirect_message':
Text(redirect_message),
'account_activation_messages':
account_activation_messages,
'activate_account_message':
activate_account_message,
'course_enrollments':
course_enrollments,
'course_entitlements':
course_entitlements,
'course_entitlement_available_sessions':
course_entitlement_available_sessions,
'unfulfilled_entitlement_pseudo_sessions':
unfulfilled_entitlement_pseudo_sessions,
'course_optouts':
course_optouts,
'staff_access':
staff_access,
'errored_courses':
errored_courses,
'show_courseware_links_for':
show_courseware_links_for,
'all_course_modes':
course_mode_info,
'cert_statuses':
cert_statuses,
'credit_statuses':
_credit_statuses(user, course_enrollments),
'show_email_settings_for':
show_email_settings_for,
'reverifications':
reverifications,
'verification_display':
verification_status['should_display'],
'verification_status':
verification_status['status'],
'verification_status_by_course':
verify_status_by_course,
'verification_errors':
verification_errors,
'block_courses':
block_courses,
'denied_banner':
denied_banner,
'billing_email':
settings.PAYMENT_SUPPORT_EMAIL,
'user':
user,
'logout_url':
reverse('logout'),
'platform_name':
platform_name,
'enrolled_courses_either_paid':
enrolled_courses_either_paid,
'provider_states': [],
'order_history_list':
order_history_list,
'courses_requirements_not_met':
courses_requirements_not_met,
'nav_hidden':
True,
'inverted_programs':
inverted_programs,
'show_program_listing':
ProgramsApiConfig.is_enabled(),
'show_journal_listing':
journals_enabled(), # TODO: Dashboard Plugin required
'show_dashboard_tabs':
True,
'disable_courseware_js':
True,
'display_course_modes_on_dashboard':
enable_verified_certificates and display_course_modes_on_dashboard,
'display_sidebar_on_dashboard':
display_sidebar_on_dashboard,
'display_sidebar_account_activation_message':
not (user.is_active or hide_dashboard_courses_until_activated),
'display_dashboard_courses':
(user.is_active or not hide_dashboard_courses_until_activated),
'empty_dashboard_message':
empty_dashboard_message,
'recovery_email_message':
recovery_email_message,
'recovery_email_activation_message':
recovery_email_activation_message,
'data':
userNewData,
}
if ecommerce_service.is_enabled(request.user):
context.update({
'use_ecommerce_payment_flow':
True,
'ecommerce_payment_page':
ecommerce_service.payment_page_url(),
})
# Gather urls for course card resume buttons.
resume_button_urls = ['' for entitlement in course_entitlements]
for url in _get_urls_for_resume_buttons(user, course_enrollments):
resume_button_urls.append(url)
# There must be enough urls for dashboard.html. Template creates course
# cards for "enrollments + entitlements".
context.update({'resume_button_urls': resume_button_urls})
response = render_to_response('dashboard.html', context)
set_logged_in_cookies(request, response, user)
return response
def items(self, request):
return courses.utils.sort_courses(get_courses(None))[:16]
def colleges(request):
courses = get_courses(request.user, request.META.get('HTTP_HOST'))
return render_to_response("colleges/schools.html", {"courses": courses})
def courses_list_handler(request, action):
"""
Return courses based on request params
"""
try:
user = request.user
except:
user = AnonymousUser()
if action not in [
"homefalls", "all", "hot", "latest", "my", "search", "rolling",
"sync"
]:
return JsonResponse({
"success":
False,
"errmsg":
"not support other actions except homefalls all hot latest rolling and my"
})
def get_courses_depend_action(courses):
"""
Return courses depend on action
action: [homefalls, hot, lastest, my, search]
homefalls: get all courses
hot: Number of attended people > ?
lastest: News last week
my: I registered
all: like 'homefalls'
"""
courses = sort_and_audited_items(courses)
courses_list = []
if action == "latest":
default_count = 20
if len(courses) < default_count:
default_count = len(courses)
courses_list = courses[0:default_count]
elif action == "my":
# filter my registered courses
for course in courses:
if registered_for_course(course, user):
courses_list.append(course)
elif action == "rolling":
default_count = 5
courses_list = courses[0:default_count]
elif action == 'search':
keyword = request.GET.get("keyword")
if keyword:
for c in courses:
if keyword in c.org or keyword in c.id or keyword in c.display_name_with_default:
courses_list.append(c)
else:
courses_list = courses
return courses_list
courses = get_courses(user, request.META.get('HTTP_HOST'))
if action != "sync":
courses = get_courses_depend_action(courses)
return return_fixed_courses(request, courses, action)