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)
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 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 create_course(self): course = Course() course.title= "just_created" course.description = "course_desc" course.instructor_id = 1 course.save() return course
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_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_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 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 handle(self, *args, **options): lec = db_to_list(2) stud = db_to_list(3) for i in COURSE_NUM: # random names: # c.name = rand_word(12) # some real course names # c.name = random.sample(course_names, 1)[0] # c.save() c = Course(name=rand_word(11), start_date=calc_start_date(), end_date=calc_end_date()) try: c.lecturer = Lecturer.objects.get(id=random.sample(lec, 1)[0]) c.save() list_student_ids = rand_num_students(stud) for j in range(0, len(list_student_ids)): c.student.add(Student.objects.get(id=list_student_ids[j])) c.save() except BaseException: raise CommandError('Could not create course') self.stdout.write( self.style.SUCCESS( 'Successfully created testcourse with name {}'.format( c.name)))
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 new_course(request): if request.method == 'POST': params = request.POST course_code = params.get('course_code', '') name = params.get('name', '') unit = params.get('unit', '') dept_id = params.get('department', '') semester = params.get('semester', '') level = params.get('level', '') lecturers = params.getlist('lecturer', '') department = Department.objects.get(pk=dept_id) try: pay_load = { 'course_code': course_code, 'name': name, 'unit': unit, 'department': department, 'level': level, 'semester': semester, } course = Course(**pay_load) course.added_by = request.user course.save() for i in lecturers: lecturer = Lecturer.objects.get(pk=int(i)) course.lecturers.add(lecturer) course.save() import pdb pdb.set_trace() messages.success(request, "The course: '%s: %s', has been successfully created" %(course.course_code, course.name)) except Exception as e: messages.error(request, e) return HttpResponseRedirect(reverse('courses:course-list'))
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 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 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 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 setUp(self): call_command('migrate') call_command('loadperms', 'groups.yml') self.my_admin = User.objects.create_superuser('admin', '*****@*****.**', 'admin123') self.client.force_login(self.my_admin) # create users to do stuff with in the tests lecturer_form = { 'username': '******', 'first_name': 'Test_fe_lecturer', 'last_name': 'Test_fe_lecturer', 'email': '*****@*****.**', 'password': '******', } response = self.client.post(reverse('createlecturer_admin_iframe'), lecturer_form) self.assertTrue(response.status_code, HTTPStatus.OK) self.assertTrue( Lecturer.objects.filter(username='******').exists()) student_form = { 'username': '******', 'first_name': 'Test_fe_student', 'last_name': 'Test_fe_student', 'email': '*****@*****.**', 'matr_nr': '42069', 'password': '******' } response = self.client.post(reverse('createstudent_admin_iframe'), student_form) self.assertTrue(response.status_code, HTTPStatus.OK) self.assertTrue( Student.objects.filter(username='******').exists()) # create a course to do stuff with in the test c = Course(name='test_course_fe', start_date='2021-08-08', end_date='2021-10-10') c.lecturer = Lecturer.objects.get(username='******') c.save() c.student.add(Student.objects.get(username='******')) c.save() self.assertTrue(Course.objects.filter(name='test_course_fe').exists()) # create an exercise to do stuff with in the tests e = Exercise( description='420 lodern Sie es!', start_time='2021-08-08 14:00:00', work_time_duration=parse_duration('0 days 00:10:00'), submission_deadline='2021-08-08 15:15:00', ) e.course = Course.objects.get(name='test_course_fe') e.save() self.assertTrue( Exercise.objects.filter(description='420 lodern Sie es!').exists())
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')
def open_course(owner, name, short_description=None): course = Course() course.owner = owner course.name = name if short_description is not None: course.short_description = short_description course.save() return course
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 post(self, request): ID = request.POST.get("id", "") type = request.POST.get("type", "") if int(type) > 0: #添加课程 #此处类似于 读者-写者 模型 #添加行级锁,防止改动课程时用户进入读取错误信息 with transaction.atomic(): if ID: lesson = Lesson.objects.select_for_update().get(id=ID) else: lesson = Lesson() lesson.course_id = request.POST.get("cId", "") lesson.name = request.POST.get("name", "") lesson.save() video = Video() video.lesson_id = lesson.id video.name = lesson.name video.url = request.POST.get("url", "") video.save() else: #进行事务处理,保证课程发布可以通知到每个关注者 with transaction.atomic(): if ID: course = Course.objects.select_for_update().get(id=ID) else: course = Course() teacher = Teacher.objects.get(id=request.user.teacher_id) course.name = request.POST.get("name", "") course.tag = request.POST.get("tag", "") course.desc = request.POST.get("desc", "") course.detail = request.POST.get("detail", "") course.degree = request.POST.get("degree", "") course.learn_times = request.POST.get("learn_times", "") course.teacher = teacher course.save() teacher_id = teacher.id users = UserFavorite.objects.filter(fav_id=teacher_id, fav_type=1) if ID: for user in users: sendMsg(user.user_id, teacher.name + "修改了课程:" + course.name, teacher.id) else: for user in users: sendMsg(user.user_id, teacher.name + "发布了新课程:" + course.name, teacher.id) return render(request, 'usercenter-publish-course.html', {})
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 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.')
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)
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 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 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 test_removing_course(self): first_course = Course() first_course.course_number = 'CIDM 1000' first_course.course_name = 'Intro to Computers' first_course.semester = 'Spring 2017' first_course.instructor = 'Dr Doom' first_course.save() saved_courses = Course.objects.all() self.assertEqual(saved_courses.count(), 1) saved_courses_empty = Course.objects.exclude(course_number='CIDM 1000') self.assertEqual(saved_courses_empty.count(), 0)
def create_course_view(request): if request.method == 'POST': form = NewCourseForm(request.POST) if form.is_valid(): new_course = Course() new_course.title = request.POST['title'] new_course.short_description = request.POST['short_desc'] new_course.full_description = request.POST['full_desc'] new_course.save() return redirect(reverse('courses:course_page', args=(new_course.id,))) else: form = NewCourseForm() return render(request, 'new_course.html', {"new_course_form": form})
def test_adding_checkbox_with_course_name_as_value(self): first_course = Course() first_course.course_number = 'CIDM 1000' first_course.course_name = 'Intro to Computers' first_course.semester = 'Spring 2017' first_course.instructor = 'Dr Doom' first_course.save() self.master = Tk() value1 = first_course.course_number first_course_cb = Checkbutton(self.master, text="course", variable=value1)
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()
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 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 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 mit(debug=False): base_url = "http://ocw.mit.edu" r = requests.get(base_url + "/courses/") soup = BeautifulSoup(r.text) for course_list in soup("div",{"class":"course_list"}): category_name = str(course_list("div",{"class":"table_head"})[0]("a")[0].string).lower() for row in course_list("tr",{"class":"row"}) + course_list("tr",{"class":"alt-row"}): course_id = row("td")[2].string school_name = "mit" try: school = School.objects.filter(name__icontains=school_name)[0] except: school = School.objects.create(name=school_name) try: category = Category.objects.get(name=category_name) except: category = Category.objects.create(name=category_name) try: m = Course.objects.filter(type="mit").filter(course_id=str(course_id))[0] except: m = Course() material_names = [a['alt'] for a in row("td")[1]("a")] materials = [] for name in material_names: try: material = Material.objects.get(name=name) except: material = Material.objects.create(name=name) materials.append(material) m.title = row("td")[3]("a")[0]("u")[0].string m.link = base_url + row("td")[3]("a")[0]['href'] m.type = "mit" m.course_id = course_id m.school = school m.save() m.categories = [category] m.materials = materials m.save() if debug: print m
def test_update_courses_valid(self): course = Course() course.title = "just_created" course.description = "course_desc" course.instructor_id = 1 course.save() data = {'title': 'new_title', 'description': 'new desc'} response = self.get_instructor_owner.put(reverse( 'courses_api:course-detail', args=[course.id]), format='json', data=data) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.data['title'], data['title']) self.assertEqual(response.data['description'], data['description'])
def handle(self, *args, **options): token = os.environ.get(token_env_var,"") if not token: raise CommandError(f'no token in "{token_env_var}"') headers = {"Authorization": f"Bearer {token}"} page = 0 results = [] while(True): page += 1 r = requests.get(f"https://canvas.instructure.com/api/v1/courses?per_page={per_page}&page={page}", headers=headers) status = r.status_code xratelimitremaining = float(r.headers['X-Rate-Limit-Remaining']) # be nice if r.status_code == 403 and xratelimitremaining == 0: time.sleep(exponential_backoff_start_ms/1000) exponential_backoff_start_ms *= 2 page -= 1 results.extend(r.json()) if r.links['current']['url'] == r.links['last']['url']: break self.stderr.write(f"there were total {len(results)} results before filtering") for res in results: if options['current']: if res.get("start_at", None) == None: continue timediff = time.time() - dp.parse(res.get("start_at")).timestamp() if timediff > 60*60*24*6: # start_at not within last 6 months continue if options['raw']: self.stdout.write(str(res)) else: self.stdout.write(str({key:res.get(key,"") for key in interesting_fields})) if options['load_db']: record = Course(id = res['id'], data=res, name=res.get('name', None), created_at=res.get('created_at', None), start_at=res.get('start_at', None), end_at=res.get('end_at', None), course_code=res.get('course_code', None), sis_course_id=res.get('sis_course_id', None)) try: record.save() except Exception as e: #print(connection.queries) #reset_queries() raise e
def coursera(debug=False): r = requests.get("https://www.coursera.org/maestro/api/topic/list?full=1") data = json.loads(r.text) for course in data: course_id = course['id'] school_name = course['universities'][0]['name'].lower() category_names = [a['name'].lower() for a in course['categories']] categories = [] try: school = School.objects.filter(name__icontains=school_name)[0] except: school = School.objects.create(name=school_name) for category_name in category_names: try: category = Category.objects.get(name=category_name) except: category = Category.objects.create(name=category_name) categories.append(category) try: m = Course.objects.filter(type="coursera").filter(course_id=course_id)[0] except: m = Course() material_names = ["Assignments and solutions","Projects and examples","Multimedia content","Exams and solutions"] materials = [] for name in material_names: try: material = Material.objects.get(name=name) except: material = Material.objects.create(name=name) materials.append(material) m.title = course['name'] m.link = course['social_link'] m.image_url = course['small_icon'] m.course_id = course_id m.type = "coursera" m.school = school m.save() m.categories = categories m.materials = materials m.save() if debug: print m
class TestCreate(TestCase): def setUp(self): self.user = User.objects.create_user(username="******", password="******") gr = Group.objects.create(name='Teachers') gr.user_set.add(self.user) gr.save() self.user.save() self.newCourse = Course(name='testCourse', professor=self.user) self.newCourse.save() self.newTask = Task(course=self.newCourse, name='testTask', text='hahaha', points='20') self.newTask.save() self.newLabwork = Lab(name='testWork', mark='10', comment='amazing!', file='testFile.txt', task=self.newTask, author=self.user, condition='') self.newLabwork.save() def test_createform_task(self): form_data = {'name': 'formTest', 'text': 'testing form', 'points': '4'} form = TaskForm(data=form_data) self.assertTrue(form.is_valid()) def test_createform_task_invalid(self): form_data = { 'name': 'formTest', 'text': 'testing form', 'points': '4!' } form = TaskForm(data=form_data) self.assertFalse(form.is_valid()) def test_createform_course(self): form_data = {'name': 'testCourse'} form = CourseForm(data=form_data) self.assertTrue(form.is_valid()) def test_createform_course_invalid(self): form_data = {'name': ''} form = CourseForm(data=form_data) self.assertFalse(form.is_valid())
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 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 seed_course(num_entries, overwrite=False): """ Creates num_entries worth a new Course """ institution = list(Institution.objects.all()) count = 0 for _ in range(num_entries): new_obj = Course( course_number=random.randrange(num_entries), parent_institution=random.choice(institution), ) new_obj.save() count += 1 percent_complete = count / num_entries * 100 print("Adding {} new Courses: {:.2f}%".format(num_entries, percent_complete), end='\r', flush=True) print()
def test_course_can_holds_weeks_and_lectures(self): course = Course() course.title = "A little title" course.save() week = Week() week.course = course week.number = 1 week.save() lecture = Lecture() lecture.title = "My lecture" lecture.video_url = "https://www.youtube.com/watch?v=lXn7XKLA6Vg" lecture.week = week lecture.order_id = 1 lecture.save() self.assertEqual(week, Week.objects.get(course=course)) self.assertEqual(lecture, Lecture.objects.get(week=week))
def post(self, request): data = json.loads(request.body.decode()) courseName = data['courseName'] if courseName == '': return sendError(message='Tienes que darle un nombre al curso') if len(courseName) > 100: return sendError(message='El nombre del curso es demasiado grande') newCourse = Course(name=courseName, teacher=request.user.teacher) newCourse.save() data = {'id': newCourse.id, 'name': newCourse.name} return sendResponse(data=data, message='Grupo {} agregado'.format(data['name']), code=201)
def create_course(request): if request.user.groups.all()[0].name == "Teacher": if request.method == 'POST': teacher = Teacher.objects.get(work_id=request.user.username) course_form = create_course_form(request.POST) if course_form.is_valid(): cd = course_form.cleaned_data course_id = cd['course_id'] name = cd['name'] credit = cd['credit'] least_students = cd['least_students'] new_course = Course(course_id=course_id, name=name, credit=credit, least_students=least_students, teacher=teacher) new_course.save() for time in cd['times']: new_course.times.add(time) return HttpResponseRedirect('/teacher/profile/') else: course_form = create_course_form() return render(request, 'teacher/create_course.html', {'course_form': course_form}) else: return render(request, "accounts/login.html")
def edx(debug=False): base_url = "https://www.edx.org" r = requests.get(base_url + "/courses") soup = BeautifulSoup(r.text) for column in soup("section", {"class":"university-column"}): for course in column("article",{"class":"course"}): course_id = "/".join(course['id'].split("/")[:-1]) school_name = course['id'].split("/")[0][:-1].lower() try: school = School.objects.filter(name__icontains=school_name)[0] except: school = School.objects.create(name=school_name) try: m = Course.objects.filter(type="edx").filter(course_id=course_id)[0] except: m = Course() material_names = ["Assignments and solutions","Projects and examples","Multimedia content","Exams and solutions"] materials = [] for name in material_names: try: material = Material.objects.get(name=name) except: material = Material.objects.create(name=name) materials.append(material) m.title = " ".join(course("header")[0]("h2")[0].get_text().split(" ")[1:]) m.link = base_url + course("a")[0]['href'] m.image_url = base_url + course("img")[0]['src'] m.type = "edx" m.course_id = course_id m.school = school m.save() m.materials = materials m.save() if debug: print m
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 test_course_info(self): """ Test the /api/course_info/ endpoint for a logged in user """ login_successful = self.client.login(username='******', password='******') self.assertTrue(login_successful) temp_provider = Provider(name='Test provider') temp_provider.save() temp_subject = Subject(name='Test subject') temp_subject.save() temp_course = Course(name='Pottery', description="Test description", provider=temp_provider, instructor="Test instructor") temp_course.save() temp_course.subjects.add(temp_subject) temp_course.save() helpout_url = 'https://helpouts.google.com/search?q=' for word in temp_course.name.split(' '): helpout_url += word + '%20OR%20' helpout_url = helpout_url[:-8] # remove trailing %20OR%20 course_info = {'description': 'Test description', 'provider': 'Test provider', 'instructor': 'Test instructor', 'name': 'Pottery', 'url': '', 'subjects': ['Test subject'], 'helpouturl': helpout_url, 'similar_courses_names': [], 'similar_courses_links': []} expected_content = {'success': True, 'info': course_info} response = self.client.post('/api/course_info/', data={'course_id': temp_course.id}) self.assertEqual(response.status_code, 200) self.assertEqual(json.dumps(expected_content), response.content) response = self.client.post('/api/complete_course/', data={'course_id': 1234567890}) self.assertEqual(response.status_code, 200) self.assertEqual('{"success": false}', response.content)
def handle(self, **options): course_id = options['course_id'] if course_id: course_id = int(course_id) if not course_id: raise Exception("--course_id is required!") course_src = Course.objects.get(id=course_id) course_dst = Course() course_dst.__dict__ = copy.deepcopy(course_src.__dict__) course_dst.id = None course_dst.name += " copy" course_dst.save() for task_src in Task.objects.filter(course=course_src): if task_src.has_parent(): continue print "Copy task {0}".format(task_src.title.encode("utf-8")) task_dst = Task() task_dst.__dict__ = copy.deepcopy(task_src.__dict__) task_dst.id = None task_dst.course = course_dst task_dst.save() for subtask_src in task_src.get_subtasks(): print ">Copy subtask {0}".format(subtask_src.title.encode("utf-8")) subtask_dst = Task() subtask_dst.__dict__ = copy.deepcopy(subtask_src.__dict__) subtask_dst.id = None subtask_dst.parent_task = task_dst subtask_dst.course = course_dst subtask_dst.save()
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])
class CoursesTest(test_utils.AuthenticatedTest): def setUp(self): super(CoursesTest, 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): self.course.delete() self.semester.delete() def test_create(self): self.assertEquals(self.course.title, 'Test Course') self.assertEquals(self.course.number, '101') self.assertEquals(self.course.section, '001') self.assertEquals(self.course.description, 'Test description of a course') def test_view(self): response = self.c.get(reverse('courses:overview', args = [self.course.id])) self.assertEquals(response.context['course'].title, 'Test Course') self.assertEquals(response.context['course'].number, '101') self.assertEquals(response.context['course'].section, '001') self.assertEquals(response.context['course'].description, 'Test description of a course') def test_access(self): self.course.private = True self.course.save() response = self.c.get(reverse('courses:overview', args = [self.course.id])) self.assertEquals(response.status_code, 403) # Test membership self.course.members.add(self.user) response = self.c.get(reverse('courses:overview', args = [self.course.id])) self.assertEquals(response.status_code, 200) self.course.members.remove(self.user) # Test Faculty self.course.faculty.add(self.user) response = self.c.get(reverse('courses:overview', args = [self.course.id])) self.assertEquals(response.status_code, 200) self.course.faculty.remove(self.user) self.course.private = False self.course.save()
class AssignmentTest(test_utils.AuthenticatedTest): def setUp(self): super(AssignmentTest, 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(AssignmentTest, 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:new_assignment', kwargs = {'pk':self.course.id})) self.assertEquals(response.status_code, 200) response = self.c.post(reverse('courses:new_assignment', kwargs = {'pk':self.course.id}), {'course':self.course.id, 'title':'Test Assignment', '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): assignment = Assignment(course = self.course, title = "Test Assignment", description = 'Test of the description <b>HERE</b>', due_date = (datetime.date.today() + one_week).isoformat()) assignment.save() # Add client user as faculty member self.course.faculty.add(self.user) self.course.save() response = self.c.get(reverse('courses:assignments', kwargs = {'pk':self.course.id})) self.assertEquals(response.status_code, 200) self.assertEquals(response.context['assignments'][0], assignment) # Remove user self.course.faculty.remove(self.user) def test_submit(self): # Add client user as faculty member self.course.faculty.add(self.user) self.course.save() response = self.c.post(reverse('courses:new_assignment', kwargs = {'pk':self.course.id}), {'course':self.course.id, 'title':'Test Assignment', 'description':'Test of the description <b>HERE</b>', 'due_date': (datetime.date.today() + one_week).isoformat()}) # Remove user self.course.faculty.remove(self.user) self.course.members.add(self.user) self.course.save() assignment = Assignment.objects.get(course = self.course, title = 'Test Assignment') # Test submitting solution response = self.c.post(reverse('courses:submit_assignment', kwargs = {'pk':assignment.id}), {'link':'http://www.example.com', 'notes':'Test notes.',}) self.assertEquals(response.status_code, 302) self.course.members.remove(self.user) def test_faculty_see_submissions(self): if not self.users: self.extra_users() # Create an assignment self.assignment = Assignment(course = self.course, title = 'Test Assignment', description = 'Test', due_date = (datetime.date.today() - one_week).isoformat() ) self.assignment.save() # Submit it self.submission = AssignmentSubmission(assignment = self.assignment, link = 'http://example.com', ) self.submission.save() self.submission.users.add(self.users[0]) # Set myself as the faculty for the course. self.course.faculty.add(self.user) self.course.save() response = self.c.get(reverse('courses:assignment_overview', args = [self.assignment.id])) self.assertEquals(len(response.context['submissions']), 1) self.course.faculty.remove(self.user) self.course.save() def test_late(self): self.assignment = Assignment(course = self.course, title = 'Test Assignment', description = 'Test', due_date = (datetime.date.today() - one_week).isoformat() ) self.assignment.save() self.submission = AssignmentSubmission(assignment = self.assignment, link = 'http://example.com') self.submission.save() def test_delete_submission(self): # We overrode the delete, so we should be testing it self.course.members.add(self.user) self.course.save() assignment = Assignment(course = self.course, title = "Test Assignment", description = 'Test of the description <b>HERE</b>', due_date = (datetime.date.today() + one_week).isoformat()) assignment.save() submission = AssignmentSubmission(assignment = assignment, link = "http://www.example.com", notes = "Test notes.") submission.save() submission.users.add(self.user) submission.save() s_id = submission.id response = self.c.post(reverse('courses:delete_submission'), {'id': submission.id}) self.assertEquals(response.content, reverse('courses:assignment_overview', kwargs = {'pk': assignment.id})) self.assertRaises(AssignmentSubmission.DoesNotExist, AssignmentSubmission.objects.get, pk = s_id) def test_team_submit(self): if not self.users: self.extra_users() # Add client user as faculty member self.course.faculty.add(self.user) self.course.save() response = self.c.post(reverse('courses:new_assignment', kwargs = {'pk':self.course.id}), {'course':self.course.id, 'title':'Test Assignment', 'description':'Test of the description <b>HERE</b>', 'due_date': (datetime.date.today() + one_week).isoformat()}) # Remove user self.course.faculty.remove(self.user) self.course.members.add(self.user) self.course.save() for user in self.users: self.course.members.add(user) self.course.save() assignment = Assignment.objects.get(course = self.course, title = 'Test Assignment') # Test submitting solution response = self.c.post(reverse('courses:team_submit_assignment', kwargs = {'pk':assignment.id}), {'link':'http://www.example.com', 'notes':'Test notes.', 'users':[user.id for user in self.users]}) self.assertEquals(response.status_code, 302) self.course.members.remove(self.user) for user in self.users: self.course.members.remove(user)
def coursecreate(request): try: tj=time.time() policy = qiniu.rs.PutPolicy('mzvideoimg') uptoken = policy.token() if 'picture' in request.FILES: pic=request.FILES['picture'] suffix=pic.name.split('.')[-1] pic=Image.open(pic) coordinate=request.POST['coordinate'].split('*') region = (int(round(float(coordinate[0]))+1),int(coordinate[1]),int(coordinate[2]),int(coordinate[3])) #region=(0,0,100,100) cropImg = pic.crop(region) #cropImg=pic.thumbnail((int(coordinate[2]),int(coordinate[3])),Image.ANTIALIAS) cropImg.save(r"/home/tron/Maizhi/templates/picture/course/"+str(tj)+'.'+suffix) #pic.save("/home/tron/Maizhi/templates/picture/course/"+str(tj)+'.'+suffix,suffix) #dirs ='templates/picture/course/'+str(tj) #if os.path.isfile(dirs): # os.remove(dirs) #fp=open(dirs, 'wb') #content=pic.read() #fp.write(content) #fp.flush() #fp.close() domain='http://mzvideoimg.qiniudn.com' if 'method' in request.GET: reward=Reward.objects.get(id=base64.decodestring(request.GET['reward'])) to=base64.decodestring(request.GET['to']) if int(request.session['id']) != int(base64.decodestring(request.GET['user'])): raise Http404 course=Course(name=request.POST['name'],img=str(tj),domain=domain,introduce=request.POST['introduce'],tiny_type_id='',price=reward.price,status=0,over=0,teacher_id=request.session['id'],grade=0) else: course=Course(name=request.POST['name'],img=str(tj),domain=domain,introduce=request.POST['introduce'],tiny_type_id=request.POST['tiny'],price=request.POST['price'],status=0,over=0,teacher_id=request.session['id'],grade=0) course.save() qiniu.io.put_file(uptoken,str(tj),r"/home/tron/Maizhi/templates/picture/course/"+str(tj)+'.'+suffix) status=course.id Post_course(user_id=request.session['id'],post_course_id=course.id,status=1).save() return render(request,'courses/success.html',{'status':status}) #return HttpResponse(str(int(round(float(coordinate[0]))+1))+"---"+str(int(coordinate[1]))+"---"+str(int(coordinate[2]))+"---"+str(int(coordinate[3]))) #return HttpResponse(coordinate) except: m=Message.objects.filter(to=request.session['id']).order_by('-time')[0:5] info=Info.objects.get(user_id=request.session['id']) mess=[] for k in m: each=[] name=Info.objects.get(user_id=k.from_id).user_name content=k.content each.append(name) each.append(content) mess.append(each) havent=0 for n in m: if n.status==1: havent+=1 tag=Types.objects.all() mycourse=Course.objects.filter(teacher_id=request.session['id']).count() if 'method' in request.GET: reward=Reward.objects.get(id=base64.decodestring(request.GET['reward'])) method='1' price=int(reward.price) else: method='0' price='' return render(request,'courses/courseCreate.html',{'message':mess,'havent':havent,'tag':tag,'info':info,'mycourse':mycourse,'method':method,'price':price})
# o looks like a single object but is actually a queryset consisting of one record. # To get the first actual object in it, use o[0] offering = o[0] print print offering # Create a Course record based on that course = Course() course.title = offering.title course.ccn = offering.ccn course.cstring = offering.cstring course.units = offering.units course.type = offering.type course.description = offering.description course.restrictions = offering.restrictions course.save() # Programs is many to many. Loop through and re-create for p in offering.programs.all(): course.programs.add(p) # title = models.CharField(max_length=384) # ccn = models.CharField('CCN',max_length=384, blank=True) # cstring = models.ForeignKey(Cstring,verbose_name='Course String',help_text="e.g. J-200, but without the J") # units = models.IntegerField(choices=constants.UNIT_TYPE_CHOICES) # type = models.IntegerField(choices=constants.COURSE_TYPE_CHOICES) # description = models.TextField() # restrictions = models.TextField(null=True,blank=True) # programs = models.ManyToManyField(Program,blank=True)