def setUp(self):
"""
Set up a test user and user profile
"""
self.client = Client()
self.user = User.objects.create_user(username='******', email='*****@*****.**', password='******',
first_name='', last_name='')
self.user_profile = UserProfile.objects.create(user=self.user)
# to avoid conflict with a test written before this setup
# append '2' to provider and subject names
self.test_provider = Provider(name='Test provider 2')
self.test_provider.save()
self.test_subject = Subject(name='Test subject 2')
self.test_subject.save()
self.test_course_1 = Course(name='Pottery 1', description="Test description 1", provider=self.test_provider,
instructor="Test instructor 1", url='http://www.example.com/1')
self.test_course_1.save()
self.test_course_1.subjects.add(self.test_subject)
self.test_course_1.save()
self.test_course_2 = Course(name='Pottery 2', description="Test description 2", provider=self.test_provider,
instructor="Test instructor 2", url='http://www.example.com/2')
self.test_course_2.save()
self.test_course_2.subjects.add(self.test_subject)
self.test_course_2.save()
self.test_course_3 = Course(name='Pottery 3', description="Test description 3", provider=self.test_provider,
instructor="Test instructor 3", url='http://www.example.com/3')
self.test_course_3.save()
self.test_course_3.subjects.add(self.test_subject)
self.test_course_3.save()
def course_add(request):
if request.method != 'POST':
return JsonResponse({'status': 402, 'msg': 'Wrong method'})
title = request.POST.get('title')
date_of_start = request.POST.get('date_of_start')
date_of_finish = request.POST.get('date_of_finish')
number_of_lectures = request.POST.get('number_of_lectures')
if date_of_finish < date_of_start:
return JsonResponse({'Warning': 'Finish must be later than Start!'})
try:
number_of_lectures = int(number_of_lectures)
except ValueError:
return JsonResponse({'status': 403, 'msg': 'Number must be a digit'})
if number_of_lectures <= 0:
return JsonResponse({
'status': 403,
'msg': 'Number must be a positive'
})
if not title or not date_of_start or not date_of_finish or not number_of_lectures:
return JsonResponse({'status': 403, 'msg': 'Wrong data'})
course = Course(title=title,
date_of_start=date_of_start,
date_of_finish=date_of_finish,
number_of_lectures=number_of_lectures)
try:
course.save()
except ValidationError:
return JsonResponse({'status': 403, 'msg': 'Wrong data'})
return JsonResponse({'status': 200, 'msg': 'OK'})
def save(self):
if self.cleaned_data['school']:
school = self.cleaned_data['school']
else:
# Obtain and save the new school
s_name = self.cleaned_data['school_name']
s_url = self.cleaned_data['school_url']
s_email = self.cleaned_data['school_email']
s_phone = self.cleaned_data['school_phone']
s_address = self.cleaned_data['school_address']
s_city = self.cleaned_data['school_city']
s_country = self.cleaned_data['school_country']
new_s = School(name=s_name, url=s_url, email=s_email,
phone=s_phone, address=s_address,
city=s_city, country=s_country)
new_s.save()
school = new_s
# Get all the information
name = self.cleaned_data['name']
url = self.cleaned_data['url']
description = self.cleaned_data['description']
language = self.cleaned_data['language']
level = self.cleaned_data['level']
type = self.cleaned_data['type']
lecturer = self.cleaned_data['lecturer']
# Save the new course
new_c = Course(name=name, url=url, description=description, language=language,
level=level, type=type, school=school, lecturer=lecturer)
new_c.save()
def setUp(self):
self.user1 = User.objects.create_user('bertie', '*****@*****.**', 'bertword')
self.user1.is_active = True
self.user1.save()
self.user2 = User.objects.create_user('Van Gogh', '*****@*****.**', 'vancode')
self.user2.is_active = True
self.user2.save()
self.user3 = User.objects.create_user('Chuck Norris', '*****@*****.**', 'dontask')
self.user3.is_active = True
self.user3.save()
self.user4 = User.objects.create_user('James Maxwell', 'em@c', 'pdq')
self.user4.is_active = True
self.user4.save()
self.course1 = Course(**course1_data)
self.course1.organiser = self.user1
self.course1.instructor = self.user1
self.course1.save()
self.course2 = Course(**course2_data)
self.course2.organiser = self.user2
self.course2.instructor = self.user2
self.course2.save()
self.uc = UserCourse(course=self.course1, user=self.user2)
self.uc.save()
self.lesson1 = Lesson(name="Test Lesson 1", course = self.course1)
self.lesson1.save()
self.ul = UserLesson(user=self.user2, lesson=self.lesson1)
self.ul.save()
class DeleteCourseViewTest(TestCase):
def setUp(self):
self.new_course = Course(
id='c0001',
name='test_course',
college='CS',
classroom='Z2101',
score=2.0,
max_student_number=50,
remark='',
)
self.new_course.save()
manager_user = User.objects.create_user(username='******', password='')
self.test_manager = Manager.objects.create(
id='m0001',
name='test_manager',
user=manager_user,
)
manager_user.user_permissions = MANAGER_PERMISSION
def test_manager_can_delete_a_exists_course(self):
self.client.login(username=self.test_manager.id, password='')
self.client.post('/courses/delete/', {'id': self.new_course.id, 'name': self.new_course.name})
with self.assertRaises(exceptions.ObjectDoesNotExist):
Course.objects.get(id=self.new_course.id)
def course_add(request):
#POST request signifies that someone is trying to add a course
if request.method == 'POST':
errors = []
#add/edit the course to the db
short_name = request.POST['short_name']
name = request.POST['name']
description = request.POST.get('description', '')
c = Course(short_name=short_name, name=name, description=description)
c.save()
try:
course_order = CourseOrder.objects.get(course=c)
except CourseOrder.DoesNotExist:
course_order = CourseOrder(course=c)
course_orders = CourseOrder.objects.order_by('-order')[:1]
if course_orders:
course_order.order = course_orders[0].order + 1
else:
course_order.order=0
course_order.save()
return render_to_response('course/add.html', {'errors': errors}, context_instance=RequestContext(request))
#GET request signifies that someone is asking for the form to add courses
elif request.method == 'GET':
return render_to_response('course/add.html', {}, context_instance=RequestContext(request))
#We cannot process any request besides GET and POST
else:
logging.error("%s requested" % (request.method))
def setUp(self):
self.user1 = User.objects.create_user('bertie', '*****@*****.**',
'bertword')
self.user1.is_active = True
self.user1.save()
self.user2 = User.objects.create_user('flo', '*****@*****.**', 'flo')
self.user2.is_active = True
self.user2.save()
self.course1 = Course(**course1_data)
self.course1.organiser = self.user1
self.course1.instructor = self.user1
self.course1.save()
self.course2 = Course(**course2_data)
self.course2.organiser = self.user1
self.course2.instructor = self.user1
self.course2.save()
self.course3 = Course(**course3_data)
self.course3.instructor = self.user1
self.course3.organiser = self.user1
self.course3.save()
self.course4 = Course(**course4_data)
self.course4.instructor = self.user1
self.course4.organiser = self.user1
self.course4.save()
self.uc = UserCourse(course=self.course1, user=self.user2)
self.uc.save()
self.uc2 = UserCourse(course=self.course2, user=self.user2)
self.uc2.save()
self.uc3 = UserCourse(course=self.course3, user=self.user2)
self.uc3.save()
def create_test_course(name, owner, instructors=(), students=()):
course = Course()
course.name = name
course.owner = owner
course.save()
course.instructors.add(*instructors)
course.students.add(*students)
def test_get_quiz_feedback_with_only_subjects_and_no_linked_resource(self):
# fill database
course = Course(pk=159,
name="Test_course1",
courseId=1,
version_time=datetime.datetime(2020, 1, 28))
course.save()
Quiz.objects.create(course_id=159,
name="Test_quiz1",
external_id=18,
subjects_id=1,
version_time=datetime.datetime(2020, 1, 28))
resource = Resource(
course_id=159,
name="Book 1",
target="http://localhost:4000/mod/book/view.php?id=12",
type="book",
external=False,
external_id=12,
version_time=datetime.datetime(2020, 1, 28))
resource.save()
subject = Subject(course=course, name="Test_subject1")
subject.save()
self.assertEqual(feedback_manager.get_quiz_feedback_link(18),
"the course resource")
def test_lecture_cant_have_not_youtube_url(self):
course = Course()
course.title = "Yet another title"
course.save()
week = Week()
week.number = 1
week.course = course
week.save()
data = {"title": "My lecture", "week": week, "order_id": 1,
"embed_video_url": "https://www.youtube.com/embed/lXn7XKLA6Vg", }
# For easy use
_assert_true = self.assertTrue
_assert_false = self.assertFalse
urls = (
("http://habrahabr.ru", _assert_false), ("https://www.google.com.ua/", _assert_false),
("https://www.youtube.com/watch?v=lXn7XKLA6Vg", _assert_true)
)
for url, suggested_func in urls:
data["video_url"] = url
lecture = NewLectureForm(data=data)
suggested_func(lecture.is_valid())
def setUp(self):
self.user1 = User.objects.create_user(
'bertie', '*****@*****.**', 'bertword')
self.user1.is_active = True
self.user1.save()
self.user2 = User.objects.create_user('dave', '*****@*****.**', 'dave')
self.user2.is_active = True
self.user2.save()
self.user3 = User.objects.create_user(
'Chuck Norris', '*****@*****.**', 'dontask')
self.user3.is_active = True
self.user3.save()
self.course1 = Course(**course1_data)
self.course1.organiser = self.user1
self.course1.instructor = self.user1
self.course1.save()
self.uc = UserCourse(course=self.course1, user=self.user2)
self.uc.save()
self.lesson1 = Lesson(name="Test Lesson 1", course = self.course1)
self.lesson1.save()
#att1 attached to course
self.att1 = Attachment(course=self.course1, **self.att1_data)
self.att1.save()
#att2 attached to lesson
self.att2 = Attachment(lesson=self.lesson1, **self.att1_data)
self.att2.save()
with open('media/attachments/empty_attachment_test.txt', 'w') as f:
f.write('test')
def setUp(self):
#set up courses, one user, enrol the user on course1, but not course2
self.user1 = User.objects.create_user('bertie', '*****@*****.**',
'bertword')
self.user1.is_active = True
self.user1.save()
self.user2 = User.objects.create_user('flo', '*****@*****.**', 'flo')
self.user2.is_active = True
self.user2.save()
self.course1 = Course(**course1_data)
self.course1.organiser = self.user1
self.course1.instructor = self.user1
self.course1.save()
self.course2 = Course(**course2_data)
self.course2.organiser = self.user1
self.course2.instructor = self.user1
self.course2.save()
self.uc = UserCourse(course=self.course1, user=self.user2)
self.uc.save()
self.lesson1 = Lesson(name="Test Lesson 1", course = self.course1)
self.lesson1.save()
self.ul = UserLesson(user=self.user2, lesson=self.lesson1)
self.ul.save()
self.lesson2 = Lesson(name="Test Lesson 2", course = self.course1)
self.lesson2.save()
self.ul2 = UserLesson(user=self.user2, lesson=self.lesson2)
self.ul2.save()
self.lesson3 = Lesson(name="Test Lesson 3", course = self.course1)
self.lesson3.save()
self.ul3 = UserLesson(user=self.user2, lesson=self.lesson3)
self.ul3.save()
self.lesson4 = Lesson(name="Test Lesson 4, in course 2", course = self.course2)
self.lesson4.save()
def create_dont_save(course_code, semester, iter_num):
dept_code = course_code.split("-")[0]
if iter_num == 0:
if dept_code not in department_obs:
dept = Department(code=dept_code, name=dept_code)
department_obs[dept_code] = dept
departments_to_save.append(dept)
elif iter_num == 1:
dept_id = department_obs[dept_code]
course = Course(
code=course_code.split("-")[1],
semester=semester,
full_code=course_code,
description=test_descriptions[course_code],
)
course.department_id = dept_id
courses_to_save.append(course)
elif iter_num == 2:
course_id = course_obs[course_code, semester]
section = Section(
code="001",
full_code=course_code + "-001",
credits=1,
status="O",
activity="LEC",
)
section.course_id = course_id
sections_to_save.append(section)
def test_get_quiz_feedback_with_only_subjects_and_linked_resource(self):
# fill database
course = Course(pk=159,
name="Test_course1",
courseId=1,
version_time=datetime.datetime(2020, 1, 28))
course.save()
quiz = Quiz.objects.create(course_id=159,
name="Test_quiz1",
external_id=18,
subjects_id=1,
version_time=datetime.datetime(2020, 1, 28))
quiz.save()
resource = Resource(
course_id=159,
name="Book 1",
target="http://localhost:4000/mod/book/view.php?id=12",
type="book",
external=False,
external_id=12,
version_time=datetime.datetime(2020, 1, 28))
resource.save()
subject = Subject(course=course, name="Test_subject1")
subject.save()
# add the link between subjects and resources
subject.resources.add(resource)
message = '\r\n- <a href="http://localhost:4000/mod/book/view.php?id=12">Book 1</a>'
self.assertEqual(feedback_manager.get_quiz_feedback_link(18), message)
def import_data():
"""使用Django ORM导入数据"""
# 讲师数据 create()
Teacher.objects.create(nickname="Jack", introduction="Python工程师", fans=666)
Teacher.objects.create(nickname="Allen", introduction="Java工程师", fans=123)
Teacher.objects.create(nickname="Henry", introduction="Golang工程师", fans=818)
# 课程数据 bulk_create()
Course.objects.bulk_create([Course(title=f"Python系列教程{i}", teacher=Teacher.objects.get(nickname="Jack"),
type=random.choice((0, 1, 2)),
price=random.randint(200, 300), volume=random.randint(100, 10000),
online=date(2018, 10, 1))
for i in range(1, 5)])
Course.objects.bulk_create([Course(title=f"Java系列教程{i}", teacher=Teacher.objects.get(nickname="Allen"),
type=random.choice((0, 1, 2)),
price=random.randint(200, 300), volume=random.randint(100, 10000),
online=date(2018, 6, 4))
for i in range(1, 4)])
Course.objects.bulk_create([Course(title=f"Golang系列教程{i}", teacher=Teacher.objects.get(nickname="Henry"),
type=random.choice((0, 1, 2)),
price=random.randint(200, 300), volume=random.randint(100, 10000),
online=date(2018, 1, 1))
for i in range(1, 3)])
# 学生数据 update_or_create()
Student.objects.update_or_create(nickname="A同学", defaults={"age": random.randint(18, 58),
"gender": random.choice((0, 1, 2)),
"study_time": random.randint(9, 999)})
Student.objects.update_or_create(nickname="B同学", defaults={"age": random.randint(18, 58),
"gender": random.choice((0, 1, 2)),
"study_time": random.randint(9, 999)})
Student.objects.update_or_create(nickname="C同学", defaults={"age": random.randint(18, 58),
"gender": random.choice((0, 1, 2)),
"study_time": random.randint(9, 999)})
Student.objects.update_or_create(nickname="D同学", defaults={"age": random.randint(18, 58),
"gender": random.choice((0, 1, 2)),
"study_time": random.randint(9, 999)})
# 正向添加
# 销量大于等于1000的课程
Student.objects.get(nickname="A同学").course.add(*Course.objects.filter(volume__gte=1000))
# 销量大于5000的课程
Student.objects.get(nickname="B同学").course.add(*Course.objects.filter(volume__gt=5000))
# 反向添加
# 学习时间大于等于500小时的同学
Course.objects.get(title="Python系列教程1").student_set.add(*Student.objects.filter(study_time__gte=500))
# 学习时间小于等于500小时的同学
Course.objects.get(title="Python系列教程2").student_set.add(*Student.objects.filter(study_time__lte=500))
# 助教数据 get_or_create()
TeacherAssistant.objects.get_or_create(nickname="助教1", defaults={"hobby": "慕课网学习", "teacher":
Teacher.objects.get(nickname="Jack")})
TeacherAssistant.objects.get_or_create(nickname="助教2", defaults={"hobby": "追慕女神", "teacher":
Teacher.objects.get(nickname="Allen")})
TeacherAssistant.objects.get_or_create(nickname="助教3", defaults={"hobby": "减肥减肥", "teacher":
Teacher.objects.get(nickname="Henry")})
return True
def test_auto_save_for_course_slug(self):
course = Course(title='B A C',
overview='overview',
creator=self.user,
subject=self.subject,
grade=200)
course.save()
self.assertEqual(course.slug, 'b-a-c')
class AttachmentViewTests(TestCase):
"""Test views for user interaction with attachments"""
course1_data = {
'code': 'EDU02',
'name': 'A Course of Leeches',
'abstract': 'Learn practical benefits of leeches',
}
lesson1_data = {
'name': 'Introduction to Music',
'abstract': 'A summary of what we cover',
}
att1_data = {
'name': 'Reading List',
'desc': 'Useful stuff you might need',
'seq': 3,
'attachment': 'empty_attachment_test.txt',
}
att2_data = {
'name': 'Grammar Guide',
'desc': 'How do you even spell grammer?',
'seq': 2,
'attachment': 'empty_attachment_test.txt',
}
def setUp(self):
self.user1 = User.objects.create_user(
'bertie', '*****@*****.**', 'bertword')
self.user1.is_active = True
self.user1.save()
self.user2 = User.objects.create_user('dave', '*****@*****.**', 'dave')
self.user2.is_active = True
self.user2.save()
self.course1 = Course(**self.course1_data)
self.course1.organiser = self.user1
self.course1.instructor = self.user1
self.course1.save()
self.lesson1 = Lesson(course=self.course1, **self.lesson1_data)
self.lesson1.save()
self.uc = UserCourse(course=self.course1, user=self.user2)
self.uc.save()
self.att1 = Attachment(course=self.course1, **self.att1_data)
self.att2 = Attachment(lesson=self.lesson1, **self.att2_data)
self.att1.save()
self.att2.save()
def test_view_metadata(self):
"""Verify that the relevant metadata get rendered"""
response = self.client.get(self.att1.get_metadata_url())
self.assertEqual(response.status_code, 200)
self.assertTrue(x in response.context
for x in ['attachment'])
self.assertIn("Reading List", response.content,
u"detail missing from response")
def testFetch(self):
"""
Test fetching of correct values from the course entry
"""
course = Course(name="TestCourse", courseId=2, inactivity=False, deadline=True, hours_before=10, inactivity_time=20, version_time=datetime.datetime(2020, 1, 28))
course.save()
validationTuple = (False, 20)
returnTuple = fetchInactivityParams(2)
self.assertEqual(returnTuple, validationTuple)
def test_json_courses(self):
"""
Test the /api/courses/ endpoint
"""
temp_course = Course(name='Advanced Pottery III')
temp_course.save()
response = self.client.get('/api/courses/')
self.assertEqual(response.status_code, 200)
self.assertTrue('Advanced Pottery III' in response.content)
def get_course_by_slug(cls, slug: str) -> Course:
qs = Course.objects.filter(slug=slug)
if qs.exists():
if not qs.filter(published=True).exists():
logger.warning(
f"There was an attempt to get an unpublished course with slug - {slug}"
)
raise Course.DoesNotExist()
return qs.first()
raise Course.DoesNotExist()
def setUp(self):
self.user = User.objects.create_user(username='******',
password='******')
self.subject = Subject.objects.create(title='first subject')
self.course = Course(title='B A C',
overview='overview',
creator=self.user,
subject=self.subject,
grade=200)
self.course.save()
def setUp(self):
self.c = Course(
department=Department.objects.get_or_create(code="PSCI")[0],
code="131",
semester=TEST_SEMESTER,
title="American Foreign Policy",
)
self.c.save()
self.s = Section(code="001", course=self.c)
self.s.save()
def setUp(self):
# Create three fake users and two fake courses
self.subject_math = Subject()
self.subject_math.name = 'math'
self.subject_math.save()
self.subject_english = Subject()
self.subject_english.name = 'english'
self.subject_english.save()
self.subject_math2 = Subject()
self.subject_math2.name = 'math-calculus'
self.subject_math2.save()
self.course_math = Course()
self.course_math.name = 'intro to math'
self.course_math.description = 'this is a introduction to math'
self.course_math.save()
self.course_math.subjects.add(self.subject_math)
self.course_math.save()
self.course_english = Course()
self.course_english.name = 'Literature 100'
self.course_english.description = 'Learn how to read!'
self.course_english.save()
self.course_english.subjects.add(self.subject_english)
self.course_english.save()
self.user1 = User.objects.create(username='******')
self.user_profile_1 = UserProfile.objects.create(user=self.user1)
self.user_profile_1.save()
self.user_profile_1.interests.add(self.subject_math2)
self.user_profile_1.disliked.add(self.course_math)
self.user_profile_1.disliked.add(self.course_english)
self.user_profile_1.completed.add(self.course_math)
self.user_profile_1.completed.add(self.course_english)
self.user_profile_1.save()
self.user_2 = User.objects.create(username='******')
self.user_profile_2 = UserProfile.objects.create(user=self.user_2)
self.user_profile_2.save()
self.user_profile_2.interests.add(self.subject_math2)
self.user_profile_2.disliked.add(self.course_english)
self.user_profile_2.disliked.add(self.course_math)
self.user_profile_2.save()
self.user_3 = User.objects.create(username='******')
self.user_profile_3 = UserProfile.objects.create(user=self.user_3)
self.user_profile_3.save()
self.user_profile_3.interests.add(self.subject_english)
self.user_profile_3.disliked.add(self.course_math)
self.user_profile_3.completed.add(self.course_math)
self.user_profile_3.completed.add(self.course_english)
self.user_profile_3.save()
def setUp(self):
"""Sets up the test case by creating a sample text and user"""
self.u = User.objects.create_user("Mittens", "*****@*****.**", "meow")
self.u.save()
c = Course()
c.save()
l = Lesson(course=c)
l.save()
self.s = Section(lesson=l)
self.s.save()
def testUpdate(self):
"""
Test updating deadline settings
"""
course = Course(name="TestCourse", courseId=2, inactivity=False, deadline=True, hours_before=10, inactivity_time=20, version_time=datetime.datetime(2020, 1, 28))
course.save()
updateDeadlineParams(2, False, 30)
course = Course.objects.get(courseId=2)
self.assertEqual(course.deadline, False)
self.assertEqual(course.hours_before, 30)
def create(request, course_name):
exists = Course.objects.filter(name=course_name)
if len(exists) > 0:
return HttpResponse('Class already exists')
try:
des = request.GET['description']
except:
des = "Class for " + course_name
c = Course(name=course_name,description=des)
c.save()
return HttpResponse('Course ' + c.name + ' created.')
class UserLessonViewTests(TestCase):
"""Test userlesson views"""
def setUp(self):
self.user1 = User.objects.create_user('bertie', '*****@*****.**', 'bertword')
self.user1.is_active = True
self.user1.save()
self.user2 = User.objects.create_user('Van Gogh', '*****@*****.**', 'vancode')
self.user2.is_active = True
self.user2.save()
self.user3 = User.objects.create_user('Chuck Norris', '*****@*****.**', 'dontask')
self.user3.is_active = True
self.user3.save()
self.user4 = User.objects.create_user('James Maxwell', 'em@c', 'pdq')
self.user4.is_active = True
self.user4.save()
self.course1 = Course(**course1_data)
self.course1.organiser = self.user1
self.course1.instructor = self.user1
self.course1.save()
self.course2 = Course(**course2_data)
self.course2.organiser = self.user2
self.course2.instructor = self.user2
self.course2.save()
self.uc = UserCourse(course=self.course1, user=self.user2)
self.uc.save()
self.lesson1 = Lesson(name="Test Lesson 1", course = self.course1)
self.lesson1.save()
self.ul = UserLesson(user=self.user2, lesson=self.lesson1)
self.ul.save()
def test_userlesson_single(self):
"""View contains correct context variables"""
u2 = self.user2.id
l1 = self.lesson1.id
url1 = "/interaction/user/{0}/lesson/{1}/".format(u2,l1)
#Not logged in
response = self.client.get(url1)
self.assertEqual(response.status_code, 302)
#Now logged in
self.client.login(username='******', password='******')
response = self.client.get(url1)
self.assertEqual(response.status_code, 200)
self.assertTrue(x in response.context
for x in ['ul', 'history'])
#non existent record
response = self.client.get('/interaction/user/2/lesson/4000/')
self.assertEqual(response.status_code, 404)
def handle(self, *args, **kwargs):
file_name = kwargs['file_name']
with open(f'{file_name}.txt') as file:
for row in file:
title = row
gen_short_content = generate_short_content()
gen_category_name = generate_category_name()
gen_course_date = generate_course_date()
gen_duration = generate_duration()
gen_price = generate_price()
gen_title = generate_about()
gen_content = generate_about()
gen_requirements = generate_requirements()
gen_apply = generate_apply()
gen_fees_and_funding = generate_fees_and_funding()
gen_teacher = generate_teacher_name()
gen_discount_price = generate_discount_price()
category = Category.objects.get_or_create(
category_name=gen_category_name)
course = Course(title=title,
short_content=gen_short_content,
category=Category.objects.get(
category_name=gen_category_name),
course_date=gen_course_date,
duration=gen_duration,
price=gen_price,
about_title=gen_title,
content=gen_content,
discount_price=gen_discount_price)
course.save()
requirements = Requirements.objects.get_or_create(
requirement=gen_requirements)
course.requirements.add(
Requirements.objects.get(requirement=gen_requirements))
apply = Apply.objects.get_or_create(apply=gen_apply)
course.apply.add(Apply.objects.get(apply=gen_apply))
fees_and_funding = FeesAndFunding.objects.get_or_create(
fees_and_funding=gen_fees_and_funding)
course.fees_and_funding.add(
FeesAndFunding.objects.get(
fees_and_funding=gen_fees_and_funding))
course.teacher.add(UserProfile.objects.get(name=gen_teacher))
self.stdout.write(
self.style.SUCCESS('Courses Data imported successfully'))
def populate_courses():
prereq_map = {}
sec_map = {}
def clean(string):
return unicode(string.strip().replace('\n',''))
def lookup_section(name):
return Section.objects.get(abbreviation=name)
def add_prereqs():
patstr = '(?:%s) \d{3}' % '|'.join(s.abbreviation for s in Section.objects.all())
pat = re.compile(patstr)
for course_id, prereqs in prereq_map.items():
course = Course.objects.get(pk=course_id)
for cstr in pat.findall(prereqs):
sec, num = cstr.strip().rsplit(' ', 1)
if sec not in sec_map:
try:
sec_map[sec] = Section.objects.get(abbreviation=sec)
except:
print 'EXITING:', cstr
exit()
try:
prereq = Course.objects.get(section=sec_map[sec], number=num)
course.prereqs.add(prereq)
except:
print 'ERROR: ', sec, num
#remove old courses
for course in Course.objects.all():
#print 'course %s %s is being deleted' % (course.section.abbreviation, course.number)
course.delete()
with open('data/courses.csv', 'r') as f:
for line in f:
line = line.replace('", "', '|').replace('"', '').replace('\n', '')
section_name, number, title, descr, prereqs, credits = line.split('|')
section = lookup_section(clean(section_name))
if section is None:
print 'Unknown section: %s' % section_name
exit()
course = Course(title = clean(title),
section = section,
number = int(clean(number)),
description = descr,
credits = int(clean(credits)))
course.save()
prereq_map[course.id] = prereqs
add_prereqs()
def setUp(self):
super(ResourceTest, self).setUp()
self.semester = Semester(name='Spring',
year='2012',
start=datetime.date(2012, 1, 1),
end=datetime.date(2012, 5, 1))
self.semester.save()
self.course = Course(title='Test Course',
number='101',
section='001',
description='Test description of a course',
semester=self.semester)
self.course.save()
def handle(self, *args, **options):
# getting the DRPS page which list all the schools
schools_index = requests.get(DRPS_URL + 'cx_schindex.htm')
schools_index_tree = html.fromstring(schools_index.text)
# After view-page-source we notice that school links share cx_s_su start
schools_index_nodes = schools_index_tree.xpath('//a[starts-with(@href, "cx_s_su")]')
for school_index_node in schools_index_nodes:
school_title = re.search("^([^\(]+)", school_index_node.text).groups()[0]
school_url = DRPS_URL + school_index_node.attrib['href']
print school_title, school_index_node.attrib['href']
old_school_set = School.objects.filter(title=school_title)
# if school already exists update its URL
if old_school_set:
current_school = old_school_set.first()
current_school.url = school_url
else:
current_school = School(title=school_title, url=school_url)
current_school.save()
school_detail = requests.get(school_url)
school_detail_tree = html.fromstring(school_detail.text)
# After view-page-source we notice that school subschools links share cx_sb start
schools_detail_nodes = school_detail_tree.xpath('//a[starts-with(@href, "cx_sb")]')
for school_detail_node in schools_detail_nodes:
print "-----", school_detail_node.text, school_detail_node.attrib['href']
course_index = requests.get(DRPS_URL + school_detail_node.attrib['href'])
course_index_tree = html.fromstring(course_index.text)
# After view-page-source we notice that school courses links pattern can be found by
# looking at the schools url and extracting its initials with regex.
course_code_prefix = re.search("cx_sb_([^\.]+).htm", school_detail_node.attrib['href'])
if course_code_prefix:
prefix = course_code_prefix.groups()[0]
course_index_nodes = course_index_tree.xpath(('//a[starts-with(@href, "cx%s")]' % prefix))
for course_index_node in course_index_nodes:
td_node = course_index_node.getparent()
tr_node = td_node.getparent()
td_code_node = tr_node.getchildren()[0]
course_title = course_index_node.text
course_url = DRPS_URL + course_index_node.attrib['href']
course_code = td_code_node.text
old_course_set = Course.objects.filter(school=current_school, title=course_title)
if old_course_set:
current_course = old_course_set.first()
current_course.url = course_url
current_course.code = course_code
course_status = "OLD"
else:
current_course = Course(school=current_school, title=course_title, url=course_url,
code=course_code)
course_status = "NEW"
print "----------", course_status, course_title, course_index_node.attrib['href'], course_code
current_course.save()
class ResourceTest(test_utils.AuthenticatedTest):
def setUp(self):
super(ResourceTest, self).setUp()
self.semester = Semester(name='Spring', year = '2012', start = datetime.date(2012, 1, 1), end = datetime.date(2012, 5, 1))
self.semester.save()
self.course = Course(title='Test Course', number = '101', section = '001', description = 'Test description of a course', semester = self.semester)
self.course.save()
def tearDown(self):
super(ResourceTest, self).tearDown()
self.course.delete()
self.semester.delete()
def test_create(self):
# Add client user as faculty member
self.course.faculty.add(self.user)
self.course.save()
# Test we get the form
response = self.c.get(reverse('courses:resource_create', kwargs = {'pk':self.course.id}))
self.assertEquals(response.status_code, 200)
response = self.c.post(reverse('courses:resource_create', kwargs = {'pk':self.course.id}), {'course':self.course.id,
'title':'Test Resource',
'description':'Test of the description <b>HERE</b>',
'due_date': (datetime.date.today() + one_week).isoformat()})
self.assertEquals(response.status_code, 302)
# Remove user
self.course.faculty.remove(self.user)
def test_list(self):
resource = Resource(course = self.course, title = "Test Resource", description = 'Test of the description <b>HERE</b>', link = 'http://example.com')
resource.save()
# Add client user as faculty member
self.course.faculty.add(self.user)
self.course.save()
response = self.c.get(reverse('courses:resources', kwargs = {'pk':self.course.id}))
self.assertEquals(response.status_code, 200)
self.assertEquals(response.context['resources'][0], resource)
# Remove user
self.course.faculty.remove(self.user)
def test_delete_resource(self):
# We overrode the delete, so we should be testing it
self.course.faculty.add(self.user)
resource = Resource(course = self.course, title = "Test Resource", description = 'Test of the description <b>HERE</b>', link = 'http://example.com')
resource.save()
resource_id = resource.id
response = self.c.post(reverse('courses:delete_resource'), {'id': resource.id})
self.assertRaises(Resource.DoesNotExist, Resource.objects.get, pk = resource_id)
def make_test_course(course_id=2, hours_before=24):
if len(Course.objects.filter(courseId=course_id)) > 0:
return
c = Course(courseId=course_id,
hours_before=hours_before,
name='Test Course',
platform='Moodle',
inactivity=False,
inactivity_time=7,
deadline=False,
version_time=datetime.datetime.today())
c.save()
return c
def post(cls, request):
course_form = CreateCourseForm(request.POST, request.FILES)
if course_form.is_valid():
name = course_form.cleaned_data['name']
image = course_form.cleaned_data['image']
teacher = Teacher.objects.get(userprofile=request.user)
course = Course()
course.name = name
course.image = image
course.college_org = teacher.college_org
course.teacher = teacher
course.save()
courses = Course.objects.filter(teacher=teacher)
lessons = []
for course in courses:
lessons.extend(Lesson.objects.filter(course=course))
return render(request, 'user_lecturer_course.html', {
'courses': courses,
'lessons': lessons,
})
else:
return HttpResponse('{"status":"fail"}',
content_type='application/json')
def test_retriving_courses_ordered_by_title(self):
course1 = Course(title='B A C',
slug='first_course',
overview='overview',
creator=self.user,
subject=self.subject,
grade=200)
course1.save()
course1.instructors.add(self.user)
course1.students.add(self.user)
course2 = Course(title='A B C',
slug='second_course',
overview='overview',
creator=self.user,
subject=self.subject,
grade=200)
course2.save()
course2.instructors.add(self.user)
course2.students.add(self.user)
courses = Course.objects.all()
f_course = courses[0]
s_course = courses[1]
self.assertEqual(f_course, course2)
self.assertEqual(s_course, course1)
def get_courses():
org = Org.objects.create(
name="Peiking University",
located=Location.objects.create(name="Beijing"),
)
python_intro = Course(
name="Introduction to Python",
desc="A introduction and tutorial to Python language.",
detail="A brief introduction didn't dive into the language details.",
degree="junior",
duration_mins=100,
enrolled_nums=1200,
favorite_nums=8000,
image="media/courses/2018/04",
hits=35889,
org=org,
add_time=timezone.now(),
)
algorithms = Course(
name="Algorithms",
desc="The fundamental of computer science",
detail="Step by step, taught yourself the essential of the algorithms.",
degree="senior",
duration_mins=300,
enrolled_nums=800,
favorite_nums=9000,
image="media/courses/2018/04",
hits=22000,
org=org,
add_time=timezone.now(),
)
python_intro.save()
algorithms.save()
return python_intro, algorithms
def test_number_of_sql_queries_all_courses(client, django_assert_num_queries):
fake = Faker()
author_name = fake.name()
author = Author(name=author_name)
author.save()
course_title = fake.sentence(nb_words=4)
course = Course(title=course_title, author=author)
course.save()
with django_assert_num_queries(1):
res = client.get("/courses/")
data = json.loads(res.content)
assert res.status_code == 200
assert len(data) == 1
author_name = fake.name()
author = Author(name=author_name)
author.save()
course_title = fake.sentence(nb_words=4)
course = Course(title=course_title, author=author)
course.save()
res = client.get("/courses/")
data = json.loads(res.content)
assert res.status_code == 200
assert len(data) == 2
def test_saving_and_retrieving_courses(self):
course1 = Course(title='First Course',
slug='first_course',
overview='overview',
creator=self.user,
subject=self.subject,
grade=50)
course1.save()
course1.instructors.add(self.user)
course1.students.add(self.user)
self.assertIsNotNone(course1)
f_course = Course.objects.first()
self.assertEqual(f_course, course1)
course2 = Course(title='Second Course',
slug='second_course',
overview='overview',
creator=self.user,
subject=self.subject,
grade=200)
course2.save()
course2.instructors.add(self.user)
course2.students.add(self.user)
s_course = Course.objects.all()[1]
courses = Course.objects.all()
self.assertEqual(courses.count(), 2)
self.assertEqual(f_course.slug, course1.slug)
self.assertEqual(s_course.title, course2.title)
def test_json_complete_course(self):
"""
Test the /api/complete_course/ endpoint for a logged in user
"""
login_successful = self.client.login(username='******', password='******')
self.assertTrue(login_successful)
temp_course = Course(name='Pottery')
temp_course.save()
response = self.client.post('/api/complete_course/', data={'completed_course': temp_course.id})
self.assertEqual(response.status_code, 200)
self.assertEqual('{"success": true}', response.content)
response = self.client.post('/api/complete_course/', data={'completed_course': 1234567890})
self.assertEqual(response.status_code, 200)
self.assertEqual('{"success": false}', response.content)
def mutate(root, info, input=None):
ok = True
students = []
teacher = User.objects.get(pk=input.teacher.id)
for student_input in input.students:
student = User.objects.get(pk=student_input.id)
if student is None:
return CreateCourse(ok=False, course=None)
students.append(student)
course_instance = Course(course_name=input.course_name,
course_description=input.course_description,
teacher=teacher)
course_instance.save()
course_instance.students.set(students)
return CreateCourse(ok=ok, course=course_instance)
def setUp(self):
self.user1 = User.objects.create_user('bertie', '*****@*****.**',
'bertword')
self.user1.is_active = True
self.user1.save()
self.user2 = User.objects.create_user('Van Gogh', '*****@*****.**', 'vancode')
self.user2.is_active = True
self.user2.save()
self.user3 = User.objects.create_user('Chuck Norris', '*****@*****.**', 'dontask')
self.user3.is_active = True
self.user3.save()
self.course1 = Course(**course1_data)
self.course1.instructor = self.user2
self.course1.organiser = self.user2
self.course1.save()
self.uc = UserCourse(course=self.course1, user=self.user1)
self.uc.save()
self.lesson = Lesson(name="Test Lesson 1", course = self.course1)
self.lesson.save()
self.li = LearningIntention(lesson=self.lesson, text="Intend...")
self.li.save()
self.uli = UserLearningIntention(user=self.user1,
learning_intention = self.li)
self.lid1 = LearningIntentionDetail(
learning_intention=self.li,
text ="LID A",
lid_type=LearningIntentionDetail.SUCCESS_CRITERION)
self.lid2 = LearningIntentionDetail(
learning_intention=self.li,
text ="LID B",
lid_type=LearningIntentionDetail.SUCCESS_CRITERION)
self.lid3 = LearningIntentionDetail(
learning_intention=self.li,
text ="LID C",
lid_type=LearningIntentionDetail.LEARNING_OUTCOME)
self.lid1.save()
self.lid2.save()
self.lid3.save()
self.ulid1 = UserLearningIntentionDetail(user=self.user1,
learning_intention_detail=self.lid1)
self.ulid1.save()
self.ulid2 = UserLearningIntentionDetail(user=self.user1,
learning_intention_detail=self.lid2)
self.ulid2.save()
self.ulid3 = UserLearningIntentionDetail(user=self.user1,
learning_intention_detail=self.lid3)
self.ulid3.save()
def course_page(request):
if request.method == 'POST':
urlstring = request.build_absolute_uri()
# I'm not positive how to do a correct ternary statement here in python so I'm taking the long route
course_id_test = 0
if request.POST['course_id']:
course_id_test = request.POST['course_id']
print(course_id_test)
if Course.objects.filter(course_id=course_id_test).exists():
Course.objects.filter(course_id=course_id_test).update(
course_number=request.POST['course_number'],
course_name=request.POST['course_name'],
semester=request.POST['semester'],
instructor=request.POST['instructor'])
else:
Course.objects.create(
course_id = random.randint(10000,99999),
course_number=request.POST['course_number'],
course_name=request.POST['course_name'],
semester=request.POST['semester'],
instructor=request.POST['instructor'])
return redirect('/')
course = Course()
courses = Course.objects.all()
course_id_edit = 0
if request.method == 'GET':
if request.GET.get('id') is not None:
course_id_edit = request.GET.get('id')
course = Course.objects.filter(course_id=course_id_edit).first()
return render(request, 'course.html', {'courses': courses, 'course': course})
def import_(request):
"""Generates and accepts GET and POST requests for importing courses
If the request is get or an invalid POST, uses the template export/import.html, if valid then redirect to the newly
uploaded course.
"""
ctx = {}
if request.method == "GET":
# Return an empty form
ctx["form"] = ImportForm()
return render(request, "export/import.html", ctx)
else:
with atomic():
# Try to import the course
ctx["form"] = ImportForm(request.POST)
if not ctx["form"].is_valid():
# Form invalid? Send it right back to the user
return render(request, "export/import.html", ctx)
try:
# Attempt decode
data = decode(ctx["form"].cleaned_data["text"].replace("\r\n", "\n"))
if data is None:
raise RuntimeError("No data could be extracted from the import")
new = Course.from_dict(data, ctx["form"].cleaned_data["mode"], ctx["form"].cleaned_data["user_mode"])
return redirect(new.get_absolute_url())
except RuntimeError as e:
# Any error? Add it as an error and then show the form again
ctx["import_error"] = "Sorry, that failed to import, the error was: {}".format(e)
return render(request, "export/import.html", ctx)
def get_queryset(self):
user = self.request.user
self.course = Course.get_or_fail(self.kwargs['course_id'], user=user, check_student=False, only_id=False)
self.users = self.course.students.select_related('profile').order_by('last_name', 'first_name', 'profile__middle_name')
return self.users
def show_courses_selected_for_comparison(courses_list, request, language):
courses_array = []
if courses_list:
# Ignore anything more than 7 (avoid malicious activity)
for course in courses_list[0:7]:
if course:
course = course.split('/')
course, error = Course.find(institution_id=course[0], course_id=course[1], mode=course[2],
language=language)
if error:
logger.warning(f"Failed to fetch course, Error fetching course: {error} for {course}")
redirect_page = get_new_landing_page_for_language(language)
# TODO: Update how errors ar handled as simply redirecting to the home page in this content is not the right answer at all
# return redirect(redirect_page + '?load_error=true&error_type=0')
courses_array.append(course)
courses = renderer.dataset_for_comparison_view(courses_array, language)
context = dict(
courses=courses_array,
courses_data=courses,
)
return render_with_language_context(request, 'courses/comparison/comparison_has_courses.html', context, language)
def setUp(self):
self.user1 = User.objects.create_user('bertie', '*****@*****.**',
'bertword')
self.user1.is_active = True
self.user1.save()
self.course1 = Course(**self.course1_data)
self.course1.organiser = self.user1
self.course1.instructor = self.user1
self.course1.save()
self.lesson1 = Lesson(course=self.course1, **self.lesson1_data)
self.lesson1.save()
self.learningintention1 = LearningIntention(lesson = self.lesson1,
text = "Practise")
self.learningintention1.save()
self.lid1 = LearningIntentionDetail(
learning_intention = self.learningintention1,
text = "Choose",
lid_type = LearningIntentionDetail.SUCCESS_CRITERION
)
self.lid1.save()
self.lid2 = LearningIntentionDetail(
learning_intention = self.learningintention1,
text = "Calculate",
lid_type = LearningIntentionDetail.LEARNING_OUTCOME
)
self.lid2.save()
def create_test_certificate(course, course_key, university):
"""
Generate the pdf certicate, save it on disk
"""
if university.certificate_logo:
logo_path = os.path.join(university.certificate_logo.url, university.certificate_logo.path)
else:
logo_path = None
teachers = get_teachers_list_from_course(course_key)
certificate_language = Course.get_course_language(unicode(course_key))
key = make_hashkey(random.random())
filename = "TEST_attestation_suivi_%s_%s.pdf" % (
course.id.to_deprecated_string().replace('/', '_'), key
)
certificate = CertificateInfo(settings.STUDENT_NAME_FOR_TEST_CERTIFICATE,
course.display_name, university.name, logo_path, filename, teachers,
language=certificate_language
)
certificate.generate()
return certificate
def courses_detail(request, institution_id, course_id, kis_mode, language=enums.languages.ENGLISH):
course, error = Course.find(institution_id, course_id, kis_mode, language)
if error:
return render(request, '500.html')
page = get_page_for_language(language, CourseDetailPage.objects.all())
page.uni_site_links_header = page.uni_site_links_header.replace('{{institution_name}}',
course.institution.pub_ukprn_name)
comparison_page = get_page_for_language(language, CourseComparisonPage.objects.all())
bookmark_page = get_page_for_language(language, CourseManagePage.objects.all())
if not page:
return render(request, '404.html')
full_path = '%s?%s' % (request.path, request.environ.get('QUERY_STRING'))
welsh_url = '/cy' + full_path if language == enums.languages.ENGLISH else full_path
english_url = full_path.replace('/cy/', '/')
context = {
'page': page,
'course': course,
'comparison_link': comparison_page.url if comparison_page else '#',
'manage_link': bookmark_page.url if bookmark_page else '#',
'english_url': english_url,
'welsh_url': welsh_url,
'cookies_accepted': request.COOKIES.get('discoverUniCookies')
}
return render(request, 'courses/course_detail_page.html', context)
def get_certificate_params(course_key):
"""Returns required information to pass to CertificateInfo
to create certificate.
Args:
course_key (CourseKey)
returns:
course_display_name: course name
university: University model or None
teachers: queryset of certificate teachers
certificate_language: language
"""
course = modulestore().get_course(course_key, depth=2)
course_display_name = unicode(course.display_name).encode('utf-8')
try:
university = get_university_attached_to_course(course_key)
except University.DoesNotExist:
# Note: this is probably a very bad idea, since we are going to use the
# university.name attribute in the rest of the certificate generation.
university = None
teachers = get_teachers_list_from_course(course_key)
certificate_language = Course.get_course_language(unicode(course_key))
return (course_display_name, university, teachers, certificate_language)
def get_certificate_params(course_key):
"""Returns required information to pass to CertificateInfo
to create certificate.
Args:
course_key (CourseKey)
returns:
course_display_name: course name
university: University model or None
teachers: queryset of certificate teachers
certificate_language: language
"""
course = modulestore().get_course(course_key, depth=2)
course_display_name = unicode(course.display_name).encode('utf-8')
try:
university = get_university_attached_to_course(course_key)
except University.DoesNotExist:
# Note: this is probably a very bad idea, since we are going to use the
# university.name attribute in the rest of the certificate generation.
university = None
teachers = get_teachers_list_from_course(course_key)
certificate_language = Course.get_course_language(unicode(course_key))
return (course_display_name, university, teachers, certificate_language)
def test_json_enrolled_courses(self):
"""
Test the /api/enrolled_courses/ endpoint for a logged in user
"""
temp_course = Course(name='Advanced Pottery III', description='Learn pottery like you never imagined possible.',
instructor='Bob Smith')
temp_course.save()
self.user_profile.enrolled.add(temp_course)
self.user_profile.save()
login_successful = self.client.login(username='******', password='******')
self.assertTrue(login_successful)
response = self.client.get('/api/enrolled_courses/')
self.assertEqual(response.status_code, 200)
self.assertEqual('["Advanced Pottery III"]', response.content)
def test_listing(self):
semester = Semester(name='Spring', year = '2012', start = datetime.date(2012, 1, 1), end = datetime.date(2012, 5, 15))
semester.save()
course = Course(title='Test Course', number = '101', section = '001', description = 'Test description of a course', semester = semester)
course.save()
course = Course(title='Test Course2', number = '101', section = '002', description = 'Test description of a course', semester = semester)
course.save()
course = Course(title='Test Course3', number = '102', section = '001', description = 'Test description of a course', semester = semester)
course.save()
response = self.c.get(reverse('courses:by_semester', args = [semester.id]))
courses = Course.objects.filter(semester = semester)
self.assertEquals([course.id for course in response.context['courses']], [course.id for course in courses])
def setUp(self):
"""Set up test cases, this creates users, a task and user on task instances"""
self.m = User.objects.create_user("Mittens", "*****@*****.**", "meow")
self.m.save()
self.f = User.objects.create_user("Fido", "*****@*****.**", "woof")
self.f.save()
c = Course()
c.save()
l = Lesson(course=c)
l.save()
s = Section(lesson=l)
s.save()
self.t = Task(section=s, model_answer="replaced", language="dummy")
self.t.save()
self.muot = self.t.get_uot(self.m)
self.fuot = self.t.get_uot(self.f)
def update(request,course_id):
cid=int(course_id)
course=Course.get_by_id(cid)
course_form=CourseForm(request.POST,instance=course)
if course_form.is_valid():
course=course_form.save()
return HttpResponseRedirect(reverse('course_path',args=[cid]))
else:
return render_to_response('courses/edit.html',{'form':course_form,'user':users.get_current_user()})
def course_file(request,course_key):
key=Key(encoded=course_key)
course=Course.get(key)
course.downtimes=course.downtimes+1
course.put()
response = HttpResponse(mimetype='text')
response['Content-Disposition'] = 'attachment; filename='+course_key+'.cou'
response.write(course.content_blob)
return response
