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)
