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 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