def test_lesson_insert(self):
print "in test_lesson_insert"
setup(self)
self.assertEqual(Lesson.objects.count(), 2)
lesson3 = Lesson(course=Course.objects.get(pk=1), name="Lesson3", description="Third lesson", position=3)
lesson3.save()
self.assertEqual(Lesson.objects.count(), 3)
def marksStep3(request, school, grade, subject):
render = {}
render['school'] = school = get_object_or_404(School, id = school)
render['grade'] = grade = get_object_or_404(Grade, id = grade)
render['subject'] = subject = get_object_or_404(Subject, id = subject)
render['dates'] = dates = []
d_st = d_end = None
t = StatForm(request.GET)
if t.is_valid():
d_st, d_end = t.cleaned_data['start'], t.cleaned_data['end']
if not(d_st and d_end):
d_st = date.today() - timedelta(days = 14)
d_end = date.today()
d_end += timedelta(days = 1)
d_start = d_st
while d_st < d_end:
dates.append(d_st)
d_st += timedelta(days = 1)
render['start'], render['end'] = d_start, d_end
render['forms'] = forms = {}
if request.method == 'GET': data = None
else: data = request.POST
for pupil in Pupil.objects.filter(grade = grade).order_by('last_name'):
init = {}
for mark in Mark.objects.filter(lesson__date__range = (d_start, d_end), pupil = pupil, lesson__subject = subject):
init['mark-%d%d%d' % (mark.lesson.date.day, mark.lesson.date.month, mark.lesson.date.year)] = mark.mark
forms[u'%s %s.' % (pupil.last_name, pupil.first_name[0])] = MarksAdminForm(pupil = pupil, dates = dates, init = init, prefix = 'p%d' % pupil.id, data = data)
if request.method == 'POST':
if all([forms[key].is_valid() for key in forms]):
for form in forms.itervalues():
for d in dates:
field = 'mark-%d%d%d' % (d.day, d.month, d.year)
if field in form.cleaned_data:
if form.cleaned_data[field] != '':
lesson_kwargs = {'grade': grade, 'subject': subject, 'date': d}
if Lesson.objects.filter(**lesson_kwargs).count() == 1:
lesson = Lesson.objects.get(**lesson_kwargs)
else:
del lesson_kwargs['grade']
lesson = Lesson(**lesson_kwargs)
lesson.save()
lesson.grade.add(grade)
lesson.save()
if Mark.objects.filter(lesson = lesson, pupil = form.pupil):
mark = Mark.objects.get(lesson = lesson, pupil = form.pupil)
else:
mark = Mark(lesson = lesson, pupil = form.pupil)
mark.mark = form.cleaned_data[field]
mark.save()
return HttpResponseRedirect(reverse('src.marks.views.marksStep2', kwargs = {'grade': grade.id, 'school': school.id}))
return render_to_response('marks/administrator/marksStep3.html', render, context_instance = RequestContext(request))
def add_lesson_to_course(courseID):
"""Adds a lesson to a course"""
form = request.form
course = Course.query.get(courseID)
try:
lesson = Lesson(course_id=courseID,
title=form.get("title"),
num=form.get("num"),
date_due=form.get("date_due"))
db.session.add(lesson)
db.session.commit()
for student in course.students_enrolled:
assignment = Assignment(student_enrollment_id=student.id,
lesson_id=lesson.id,
complete=False,
turned_in=False)
db.session.add(assignment)
db.session.commit()
flash("Successfully added lesson")
except:
flash("Failed to add lesson")
return redirect("/")
def setUp(self):
print('\r')
# drop all tables in the database
db.session.remove()
db.drop_all()
# crete all tables in the database
db.create_all()
# adding users
user = User(
email='*****@*****.**',
encrypted_password=encrypt('password'),
name='john_doe'
)
student = Student(user, 'U1722')
db.session.add(student)
# adding topics
topic = Topic(name='seng')
db.session.add(topic)
# adding lessons
lesson = Lesson(topic_id=1, id=1, name='se', content='test')
db.session.add(lesson)
# adding questions
qn_1 = Question(1, 1,'easy')
db.session.add(qn_1)
qn_2 = Question(1, 1,'medium')
db.session.add(qn_2)
db.session.commit()
def setUp(self):
print('\r')
# drop all tables in the database
db.session.remove()
db.drop_all()
# crete all tables in the database
db.create_all()
# adding users
user_1 = User('*****@*****.**', encrypt('password'), 'student_1')
student_1 = Student(user_1, 'U00000000A')
db.session.add(student_1)
user_2 = User('*****@*****.**', encrypt('password'), 'student_2')
student_2 = Student(user_2, 'U00000000B')
db.session.add(student_2)
user_3 = User('*****@*****.**', encrypt('password'), 'teacher_1')
staff_1 = Staff(user_3)
db.session.add(staff_1)
# adding topics
topic = Topic(name='seng')
db.session.add(topic)
# adding lessons
lesson = Lesson(1, 1, 'lesson_1', 'content')
db.session.add(lesson)
# adding quizzes
quiz = Quiz(3, 'quiz_1', True, '2020-03-30', '2020-03-31')
db.session.add(quiz)
db.session.commit()
def post(self):
_lesson_parser = reqparse.RequestParser()
_lesson_parser.add_argument("class_name",
type=str,
required=True,
help="This field cannot be blank.")
data = _lesson_parser.parse_args()
_class = Lesson(**data)
try:
_class.save_to_db()
except:
return {'message': 'Error trying to make a class'}, 500
return {'message': 'You have made a class!'}, 201
def create_lesson(request, course_id):
""" creates a lesson object and redirects to /edit/ view for that lesson """
try:
course= Course.objects.get(pk=course_id)
except Course.DoesNotExist:
raise Http404
lesson = Lesson(title='',slug='',course=course)
lesson.save()
redirect_to = reverse('courses.lessons.views.edit',
kwargs={ "course_id":course.id,
"lesson_id":lesson.id, } )
return HttpResponseRedirect(redirect_to,)
def save_lesson(day, student, html, verbose=True):
soup = BeautifulSoup(html)
data = [unicode(info.text) for info in soup.find_all('td')]
#print data
existing = student.lessons.filter_by(day=day,
start_min=to_timestamp(
data[0][:5])).first()
if existing != None:
return
if verbose:
print "Lektion sparad dag {}:".format(day)
for info in data:
print info.encode('utf8')
print ""
if len(data) < 6:
data.append('')
lesson = Lesson(day=day,
start_min=to_timestamp(data[0][:5]),
end_min=to_timestamp(data[0][-5:]),
subject=data[1],
info=data[2].strip(),
teachers=data[3],
_class=data[4],
rooms=data[5],
student=student)
db.session.add(lesson)
db.session.commit()
def initializeLesson(topic_id, name, content, url_link):
topic = topicRead(col='id', value=topic_id)
if (topic):
lastLessonID = getLastLessonID(topic_id=topic.id)
return Lesson(topic_id, lastLessonID + 1, name, content, url_link)
else:
return False
def setUp(self):
print('\r')
# drop all tables in the database
db.session.remove()
db.drop_all()
# crete all tables in the database
db.create_all()
# adding users
user = User(
email='*****@*****.**',
encrypted_password=encrypt('password'),
name='john_doe'
)
student = Student(user, 'U1722')
db.session.add(student)
# adding topics
topic = Topic(name='seng')
db.session.add(topic)
# add lessons
lesson = Lesson(topic_id='1', id='3', name='se', content='test')
db.session.add(lesson)
# add questions
qn = Question('1', '3', 'easy')
db.session.add(qn)
# add questionChoice
qc = initializeQuestionChoice(1,'A',False)
db.session.add(qc)
db.session.commit()
def setUp(self):
print('\r')
# drop all tables in the database
db.session.remove()
db.drop_all()
# crete all tables in the database
db.create_all()
# adding topics
topic = Topic(name='seng')
db.session.add(topic)
# adding lessons
lesson = Lesson(topic_id=1, id=1, name='se', content='test')
db.session.add(lesson)
# adding users
user = User('*****@*****.**', encrypt('password'), 'staff_name')
staff = Staff(user)
db.session.add(staff)
# adding quizzes
quiz = Quiz(1, 'quiz_name', True, '2020-03-21', '2020-03-22')
db.session.add(quiz)
db.session.commit()
def handle_add_lesson_form(user_id):
"""Submit New Lesson plan and redirect to user home"""
user = User.query.get(user_id)
if "id" not in session or user.id != session['id']:
flash('Please login to view.')
return redirect('/login')
form = AddLessonForm()
resources = [(resource.title, resource.url) for resource in Resource.query.filter(Resource.user_id == user.id).all()]
form.resources.choices = resources
if form.validate_on_submit():
title = form.title.data
summary = form.summary.data
date = form.add_lesson_date.data.strftime('%Y-%m-%d')
resources = form.resources.data
lesson = Lesson(
title=title,
summary=summary,
date=date,
user_id=user_id
)
db.session.add(lesson)
db.session.commit()
return redirect(f"/users/{user_id}/lessons")
else:
return render_template("lessons/new.html", user=user, form=form)
def test_lessonRead(self):
# create a new Lesson object and add it to the database
lesson = Lesson(topic_id=1, id=3, name='se', content='test')
db.session.add(lesson)
db.session.commit()
# check that the record retrieved is correct (using col='name')
print(
'--- check that the record retrieved is correct (using col=\'name\')'
)
self.assertEqual(
lessonRead(topic_id=1, col='name', value='se').name, 'se')
# check that the record retrieved is correct (using col='id')
print(
'--- check that the record retrieved is correct (using col=\'id\')'
)
self.assertEqual(lessonRead(topic_id=1, col='id', value=3).name, 'se')
# check that no record is retrieved (when value of col is unacceptable
print(
'--- check that no record is retrieved (when value of col is unacceptable'
)
self.assertFalse(lessonRead(topic_id=1, col='wrong_value', value=3))
def lesson_get(id, token: Optional[str] = Header(None), name: str = Form(...), description: str = Form(...), content: str = Form(...), attachment: str = Form(...), homework: str = Form(...), weight: str = Form(...)):
"""
更新课时
"""
user = security.get_current_user(token)
lesson = Lesson.get_lesson_by_id(id)
lesson.update(name, description, user.id, content, attachment)
return lesson
async def lesson_create(token: Optional[str] = Header(None), name: str = Form(...), description: str = Form(...), content: str = Form(...), attachment: str = Form(...), homework: str = Form(...), weight: str = Form(...)):
"""
创建文件
"""
user = security.get_current_user(token)
lesson = Lesson.create(name, description, user.id, content, attachment)
return {"lesson": lesson.id}
def test_lessonUpdate(self):
# create a new Lesson object and add it to the database
lesson = Lesson(topic_id=1, id=3, name='se', content='test')
db.session.add(lesson)
db.session.commit()
# update value of Lesson object
lesson.name = 'softwareEngi'
lessonUpdate()
# fetch updated Lesson object from the database
lesson = Lesson.query.filter_by(topic_id=1).filter_by(id=3).first()
# check if value of Lesson object has been updated
print('--- check if value of Lesson object has been updated')
self.assertEqual(lesson.name, 'softwareEngi')
def create():
form = LessonForm()
if form.validate_on_submit():
print request.form
#4/0
lesson = Lesson()
lesson.title = request.form.get('title')
lesson.time = request.form.get('time')
lesson.audience = request.form.get('audience')
lesson.goals = request.form.get('goals')
lesson.summary = request.form.get('summary')
session.add(lesson)
session.flush()
for index, step_entry in enumerate(form.steps.entries):
step = Step()
step.title = step_entry.title.data
step.body = step_entry.body.data
step.order = index
step.lesson = lesson
session.add(step)
session.flush()
session.commit()
return redirect(url_for('view', uid=lesson.id))
return render_template('create.html', form=form)
def sidebar_widget(context):
user = context.get('user', None)
if not user or not user.is_authenticated():
return ''
if Lesson.disabled():
return ''
return render_to_string('lesson/sidebar.html', {})
def test_asr():
_wt = Lesson()
_wt.wav_path = '/data/audio/001.wav'
_wt.sentences = [
{
"id": 1001,
"text": "Last week my four-year-old daughter Sally was invited to a children's party.",
"asrText": "Last week my four-year-old daughter Sally was invited to a children's party"
},
{
"id": 1002,
"text": "I decided to take her by train.",
"asrText": "I decided to take her by train"
}
]
_asr_result = get_report_by_wt(_wt)
return _asr_result
def test_lesson_model(self):
"""Test basic model"""
l = Lesson(title="Illinois History", date="2021-12-12", user_id=2222)
db.session.add(l)
db.session.commit()
self.assertEqual(len(self.u2.lesson), 1)
def add_lesson():
type1 = request.json['type1']
message = request.json['message']
#initialize lessons with info
new_lesson = Lesson(type1, message)
db.session.add(new_lesson) #open the session
db.session.commit()
return lesson_schema.jsonify(new_lesson)
async def post(self, request, current_user):
try:
req = request.json
user = await Users.get_first('email', req['creator'])
req['creator'] = user.id
lesson = Lesson(**req)
await lesson.create()
return json({'success': True})
except:
logging.exception('err lesson.post')
return json({'msg': 'error creating'}, status=500)
def get_lessons(self):
cursor = self.conn.cursor()
cursor.execute(
'select l.id, l.name, u.id, u.email, u.first_name, u.middle_name, u.last_name, u.password, u.birth_date, u.entry_date, u.role from lessons as l, users as u where teacher_id=u.id;'
)
rows = cursor.fetchall()
lessons = []
for r in rows:
teacher = User(*r[2:])
lessons.append(Lesson(*r[:2], teacher))
return lessons
def setup(self): user1 = User(username="******", email="*****@*****.**", first_name="john", last_name="smith") user2 = User(username="******", email="*****@*****.**", first_name="sally", last_name="smith") user1.save() user2.save() teacher1 = Teacher() teacher1.teacher = user1 teacher1.save() teacher2 = Teacher() teacher2.teacher = user2 teacher2.save() course1 = Course(teacher=teacher1, name="Intro1", position=1) course2 = Course(teacher=teacher2, name="Advanced2", position=2) course1.save() course2.save() lesson1 = Lesson(course=course1, name="Lesson1", description="Intro1 - Lesson1", position=1) lesson2 = Lesson(course=course1, name="Lesson2", description="Intro1 - Lesson2", position=2) lesson1.save() lesson2.save() slide1 = Slide(lesson=lesson1, name="Slide1", content="<h1>Slide1</h1>", position=1, googleStyles=" ") slide2 = Slide(lesson=lesson1, name="Slide2", content="<h1>Slide2</h1>", position=2, googleStyles=" ") slide1.save() slide2.save()
def create():
form = LessonForm()
if form.validate_on_submit():
print request.form
#4/0
lesson = Lesson()
lesson.title = request.form.get('title')
lesson.time = request.form.get('time')
lesson.audience = request.form.get('audience')
lesson.goals = request.form.get('goals')
lesson.summary = request.form.get('summary')
session.add(lesson)
session.flush()
for index,step_entry in enumerate(form.steps.entries):
step = Step()
step.title = step_entry.title.data
step.body = step_entry.body.data
step.order = index
step.lesson = lesson
session.add(step)
session.flush()
session.commit()
return redirect(url_for('view', uid=lesson.id))
return render_template('create.html', form=form)
def test_getLastLessonID(self):
# check that function returns 0 when no record in the table
print('--- check that function returns 0 when no record in the table')
self.assertEqual(getLastLessonID(1), 0)
# create a new Lesson object and add it to the database
lesson = Lesson(topic_id=1, id=1, name='se', content='test')
db.session.add(lesson)
db.session.commit()
# check that function returns 1 when no record in the table
print('--- check that function returns 1 when no record in the table')
self.assertEqual(getLastLessonID(1), 1)
def put(self):
# This method will update a tutorial and its associated lessons
from app import db
from models import Tutorial, Lesson
try:
data = request.json
tutorial = Tutorial.query.get(data['id'])
if tutorial is None:
return jsonify({
"succeed": False,
"info": "There is no tutorial with that id."
})
duplicatedTutorial = Tutorial.query.filter(
Tutorial.title == data['title']).first()
if duplicatedTutorial is not None:
if duplicatedTutorial.id != int(data['id']):
return jsonify({
"succeed":
False,
"info":
"There is already a tutorial with the same title."
})
tutorial.title = data['title']
db.session.commit()
Lesson.query.filter(Lesson.tutorial_id == data['id']).delete()
db.session.commit()
for lesson in data['lessons']:
newLesson = Lesson(data['id'], lesson['title'],
lesson['description'], lesson['link'])
db.session.add(newLesson)
db.session.commit()
return jsonify({"succeed": True})
except:
#db.session.close()
return jsonify({
"succeed":
False,
"info":
"Unexpected error has occured. Please try again."
})
def addLesson(request):
user = request.user
if user.is_authenticated():
lessonForm = LessonForm(request.POST)
if request.method == 'POST':
print(lessonForm)
lesson = Lesson()
if lessonForm.is_valid():
print(lessonForm)
lesson.group = lessonForm.cleaned_data['group']
lesson.discipline = lessonForm.cleaned_data['discipline']
lesson.dateAndTtime = lessonForm.cleaned_data['dateAndTtime']
lesson.room = lessonForm.cleaned_data['room']
lesson.lessonID = lessonForm.cleaned_data['lessonID']
lesson.status = lessonForm.cleaned_data['status']
lesson.user = lessonForm.cleaned_data['user']
lesson.save()
return HttpResponseRedirect('/admin')
return render_to_response('dokladedit.html', { 'form': lessonForm}, context_instance=RequestContext(request))
#text = """<html><body><h1>Hello world</h1><p>asdfgvbasdbg</p></body></html>"""
#text2 = "hello again"
#return HttpResponse(text)
return render(request,'vote/create.html', {})
def get_marks(self):
cursor = self.conn.cursor()
cursor.execute(
'select year, quarter, mark, t.*, s.*, l.id, l.name from journal as j, users as t, users as s, lessons as l where student_id = s.id and j.teacher_id = t.id and lesson_id = l.id'
)
rows = cursor.fetchall()
marks = []
for r in rows:
teacher = User(*r[3:12])
student = User(*r[12:21])
lesson = Lesson(*r[21:], teacher)
mark = Mark(*r[:3], teacher, student, lesson)
marks.append(mark)
return marks
def test_lessonDelete(self):
# create a new Lesson object and add it to the database
lesson = Lesson(topic_id=1, id=3, name='se', content='test')
db.session.add(lesson)
db.session.commit()
# check that record has been deleted (number of record in database -1)
print(
'--- check that record has been deleted (-1 number of record in database)'
)
self.assertEqual(len(Lesson.query.all()), 1)
lessonDelete(topic_id=1, lesson_id=3)
self.assertEqual(len(Lesson.query.all()), 0)
def setUp(self):
print('\r')
# drop all tables in the database
db.session.remove()
db.drop_all()
# crete all tables in the database
db.create_all()
# adding topics
topic = Topic(name='seng')
db.session.add(topic)
# adding lessons
lesson = Lesson(topic_id='1', id='3', name='se', content='test')
db.session.add(lesson)
db.session.commit()
def check(request):
print "Request started. Segmenting..."
body_unicode = request.body
body = json.loads(body_unicode)
data = body['photo']
currtime = int(time.time())
filename = 'files/' + str(currtime) + '.png'
fh = open('files/' + filename, 'wb')
fh.write(data.decode('base64'))
fh.close()
_, _, _, faces_paths, crop_tuples = detect_faces('files/' + filename)
students = Student.objects.all()
ids, matched_crop_tuples = recognize(faces_paths, crop_tuples, students)
present_students = [student.name for student in students if student.pk in ids]
absent_students = [student.name for student in students if student.pk not in ids]
image = cv2.imread('files/' + filename)
for ((xb, yb, xe, ye), _) in matched_crop_tuples:
cv2.rectangle(image, (xb,yb), (xe, ye), (213, 72, 211), 7)
for ((xb, yb, xe, _), sid) in matched_crop_tuples:
xc = (xb + xe) / 2
text = next(stud.name for stud in students if stud.pk == sid)
fontSize = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, fontScale=2, thickness=5)
print fontSize
print xc
offset = fontSize[0][0] / 2
cv2.putText(image, text, (max(0, xc - offset), yb), cv2.FONT_HERSHEY_DUPLEX, 2, (171, 15, 169), 5)
cv2.imwrite('files/' + filename, image)
lesson = Lesson()
lesson.name = "Mathematics"
lesson.img = filename
lesson.save()
for student in students:
if student.pk in ids:
lesson.students.add(student)
lesson.save()
return JsonResponse({'present': present_students, 'absent': absent_students})
def get_lesson():
"""
解析 JSON, 送去评分
:return:
"""
lesson_m = _r.rpop(MQ_LESSON_ANALYZE_INPUT)
if lesson_m:
logging.debug("Get redis[" + MQ_LESSON_ANALYZE_INPUT + "] message:%s" % (lesson_m,))
message = json.loads(lesson_m)
wt = Lesson()
wt.message = lesson_m
wt.lesson_id = message.get('lessonId')
wt.sentences = message.get('sentences')
wt.wav_path = message.get('audioPath')
wt.language = message.get('language')
return wt
return None
def post(self):
_user_parser = reqparse.RequestParser()
_user_parser.add_argument("username",
type=str,
required=True,
help="This field cannot be blank.")
_user_parser.add_argument("password",
type=str,
required=True,
help="This field cannot be blank.")
_user_parser.add_argument("first_name",
type=str,
required=True,
help="This field cannot be blank.")
_user_parser.add_argument("last_name",
type=str,
required=True,
help="This field cannot be blank.")
_user_parser.add_argument("is_teacher",
type=bool,
required=True,
help="This field cannot be blank.")
_user_parser.add_argument("class_id",
type=str,
required=True,
help="This field cannot be blank.")
data = _user_parser.parse_args()
_class = Lesson.find_by_name(
data["class_id"]
) # Need to add parser for ID and then pass this as the argument
if User.find_by_username(data["username"]):
return {'message': 'A user with that name already exists'}
student = Student(username=data['username'],
first_name=data['first_name'],
last_name=data['last_name'],
is_teacher=data['is_teacher'],
class_name=_class)
student.set_password(data['password'])
student.save_to_db()
return {"message": "Student Created!"}, 201
def setUp(self):
print('\r')
# drop all tables in the database
db.session.remove()
db.drop_all()
# crete all tables in the database
db.create_all()
# adding users
user = User(email='*****@*****.**',
encrypted_password=encrypt('password'),
name='john_doe')
student = Student(user, 'U1722')
db.session.add(student)
user = User(email='*****@*****.**',
encrypted_password=encrypt('password'),
name='staff')
staff = Staff(user)
db.session.add(staff)
# adding topics
topic = Topic(name='seng')
db.session.add(topic)
# adding lessons
lesson = Lesson(topic_id='1', id='3', name='se', content='test')
db.session.add(lesson)
# adding questions
qn = Question('1', '3', 'easy')
db.session.add(qn)
# adding quizzes
qz = Quiz(2, 'quiz', True, '2020-03-21', '2020-03-22'
) # staff id is 2 here, as it uses the fk of users table
db.session.add(qz)
# adding courses
course = Course(index='cz3003')
db.session.add(course)
db.session.commit()
def post(self):
_user_parser = reqparse.RequestParser()
_user_parser.add_argument("username",
type=str,
required=True,
help="This field cannot be blank.")
_user_parser.add_argument("password",
type=str,
required=True,
help="This field cannot be blank.")
_user_parser.add_argument("first_name",
type=str,
required=True,
help="This field cannot be blank.")
_user_parser.add_argument("last_name",
type=str,
required=True,
help="This field cannot be blank.")
_user_parser.add_argument("is_teacher",
type=bool,
required=True,
help="This field cannot be blank.")
_user_parser.add_argument("class_name",
type=str,
required=True,
help="This field cannot be blank.")
data = _user_parser.parse_args()
if User.find_by_username(data["username"]):
return {'message': 'A user with that name already exists'}
if not Lesson.find_by_name(data['class_name']):
return {'message': 'There is no class with that name'}
teacher = Teacher(username=data['username'],
first_name=data['first_name'],
last_name=data['last_name'],
is_teacher=data['is_teacher'],
class_name=data['class_name'])
teacher.set_password(data['password'])
teacher.save_to_db()
return {"message": "Teacher Created!"}, 201
def lesson_admin_update(request, lesson_id, prefix):
if request.is_ajax():
form = LessonForm(request.POST) if prefix == 'None' else LessonForm(request.POST, prefix=prefix)
if form.is_valid():
try:
lesson = Lesson.objects.get(pk=lesson_id)
lesson.course = form.cleaned_data['course']
lesson.description = form.cleaned_data['description']
lesson.name = form.cleaned_data['name']
lesson.save()
return HttpResponse('OK')
except ObjectDoesNotExist:
# create new object
position = None
if Lesson.objects.count() > 0:
lesson = Lesson.objects.order_by('-position').all()[0]
position = lesson.position
else:
position = 1
newlesson = Lesson()
newlesson.course = form.cleaned_data['course']
newlesson.name = form.cleaned_data['name']
newlesson.description = form.cleaned_data['description']
newlesson.position = position
newlesson.save()
response = {'created_object_id': newlesson.pk}
return HttpResponse(json.dumps(response), mimetype="application/json")
else:
errors_dict = {}
if form.errors:
for error in form.errors:
e = form.errors[error]
field = prefix+"-"+error;
errors_dict[field] = unicode(e)
print errors_dict
return HttpResponseBadRequest(json.dumps(errors_dict))
else:
return HttpResponseNotFound('You do not have permission to access this page!')
def addlesson():
if request.method == 'GET':
return render_template('add_lesson.html')
newlesson = Lesson()
newlesson.date = request.form.get('lessondate')
newlesson.category = request.form.get('category')
newlesson.teachers = request.form.get('lessonteachers')
newlesson.video_link = request.form.get('videolink')
newlesson.user_id = g.user.id
g.user.lessons.append(newlesson)
db.session.add(newlesson)
db.session.add(g.user)
db.session.commit()
return redirect('/lessonlist')
def index(request):
'''
Очень обширная страница, необходимо сделать разделение.
'''
render = {}
if request.user.type == 'Parent':
start = date.today() - timedelta(weeks = 2)
end = date.today() + timedelta(days = 1)
if request.method == 'GET':
render['form'] = form = StatForm()
else:
render['form'] = form = StatForm(request.POST)
if form.is_valid():
start = form.cleaned_data['start']
end = form.cleaned_data['end']
render.update(request.user.current_pupil.get_all_marks(start, end))
elif request.user.type == 'Teacher':
import demjson
if request.GET.get('set_current_grade', False):
grade = get_object_or_404(Grade,
id = request.GET.get('set_current_grade'))
if grade not in request.user.grades.all():
raise Http404(u'Нет такого класса')
request.user.current_grade = grade
request.user.save()
render['lesson_form'] = LessonForm()
if request.GET.get('set_lesson', False):
lesson = get_object_or_404(Lesson,
id = int(request.GET.get('lesson', 0)),
teacher = request.user)
form = LessonForm(request.GET, instance = lesson)
if form.is_valid():
form.save()
return HttpResponse('ok')
if request.GET.get('get_lesson_info', False):
lesson = get_object_or_404(Lesson,
id = int(request.GET.get('lesson', 0)),
teacher = request.user)
return HttpResponse(demjson.encode({'task': lesson.task or '',
'topic': lesson.topic or ''}))
if request.GET.get('set_mark', False):
from templatetags.marks_chart import get_mark
pupil = get_object_or_404(Pupil,
id = int(request.GET.get('pupil', 0)),
grade = request.user.current_grade)
lesson = get_object_or_404(Lesson,
id = int(request.GET.get('lesson', 0)),
teacher = request.user)
mark = unicode(request.GET.get('mark', 0)).lower()
Mark.objects.filter(pupil = pupil, lesson = lesson).delete()
m = Mark(pupil = pupil, lesson = lesson)
tr_id = 'p-%d-%d' % (pupil.id, lesson.id)
if mark not in ['1', '2', '3', '4', '5', 'n', u'н', '']:
return HttpResponse(demjson.encode({'id': tr_id, 'mark': 'no'}))
if mark == '':
return HttpResponse(demjson.encode({'id': tr_id, 'mark': ''}))
if mark in [u'n', u'н']:
m.absent = True
else:
m.mark = int(mark)
m.save()
return HttpResponse(demjson.encode({'id': tr_id,
'mark': get_mark(pupil, lesson),
'mark_value': str(m).strip(),
'mark_type': m.get_type()
}, encoding = 'utf-8'))
from pytils import dt
if not request.user.current_grade:
if request.user.get_grades():
request.user.current_grade = request.user.get_grades()[0]
request.user.save()
else:
messages.error(request, u'К вам не привязано классов')
return HttpResponseRedirect('/')
request.user.current_grade.get_pupils_for_teacher_and_subject(
request.user, request.user.current_subject
)
try:
day, month, year = request.GET.get('date', '').split('.')
date_start = date(day = day, month = month, year = year)
except ValueError:
date_start = date.today()
lessons_range = []
render['monthes'] = monthes = {}
for i in xrange(1, 13):
monthes[i] = ('', 0)
kwargs = {
'subject': request.user.current_subject,
'grade': request.user.current_grade
}
conn = Connection.objects.filter(teacher = request.user, **kwargs)
if not conn:
raise Http404('No connections')
conn = conn[0]
if conn.connection != '0':
kwargs['group'] = conn.connection
kwargs4lesson = {}
for i in xrange(14, -1, -1):
d = date_start - timedelta(days = i)
kwargs['workday'] = str(d.weekday()+1)
if UsalTimetable.objects.filter(**kwargs):
kwargs4lesson = {'teacher': request.user,
'date': d,
'subject': request.user.current_subject}
groups = {}
for lesson in UsalTimetable.objects.filter(**kwargs):
groups[lesson.group] = groups.get(lesson.group, 0) + 1
groups = groups.values()
if Lesson.objects.filter(grade = request.user.current_grade, **kwargs4lesson).count() != max(groups):
for j in xrange(max(groups) - Lesson.objects.filter(**kwargs4lesson).count()):
t = Lesson(**kwargs4lesson)
t.save()
t.grade.add(request.user.current_grade)
t.save()
resultdates = ResultDate.objects.filter(date = d, grades = request.user.current_grade)
if resultdates:
resultdate = resultdates[0]
kwargs4lesson = {
'resultdate': resultdate,
'grade': request.user.current_grade,
'subject': request.user.current_subject,
'teacher': request.user
}
if not Lesson.objects.filter(**kwargs4lesson):
del kwargs4lesson['grade']
lesson = Lesson(topic = resultdate.name,
date = resultdate.date,
**kwargs4lesson)
lesson.save()
lesson.grade.add(request.user.current_grade)
lesson.save()
if len(kwargs4lesson) == 0:
raise Http404(u'Нет расписания')
del kwargs4lesson['date']
kwargs4lesson['date__gte'] = date_start - timedelta(days = 15)
for lesson in Lesson.objects.filter(**kwargs4lesson).order_by('date'):
monthes[lesson.date.month] = (dt.ru_strftime(u'%B', lesson.date),
monthes[lesson.date.month][1] + 1)
lessons_range.append(lesson)
for i in monthes.keys():
if monthes[i][1] == 0:
del monthes[i]
render['lessons'] = lessons_range
return render_to_response(
'~marks/%s/index.html' % request.user.type.lower(),
render,
context_instance = RequestContext(request))
def admin_save(request, slug):
#request.POST = dict([(x, y[0]) for x, y in request.POST.items()])
#return HttpResponse(str(request.POST))
course = Course.objects.get(slug=slug)
#course.title = request.POST['course_title']
course.save()
course.delete_lessons()
last_lesson = max([int(re.search('\w+_(?P<n>\d+)_\w+', i).group('n')) for i in request.POST.keys() if re.match('\w+_(?P<n>\d+)_\w+', i)])
for lesson_order in range(1, last_lesson + 1):
lesson = Lesson(course=course, order=lesson_order, title='')
lesson.save()
try:
lesson_content = LessonContent(lesson=lesson, type=request.POST['lesson_%s_content_type' % (lesson_order)], content=request.POST['lesson_%s_content' % (lesson_order)])
lesson_content.save()
except:
pass
try:
video = Video(lesson=lesson, url=request.POST['lesson_%s_video_id' % (lesson_order)], provider='youtube')
video.save()
except:
pass
try:
display_after_video = DisplayAfterVideo(lesson=lesson, image=request.POST['lesson_%s_display_after_video' % (lesson_order)])
display_after_video.save()
except:
pass
#last_question = max([int(re.search('\w+_%s_\w+_(?P<n>\d+)' % (lesson_order), i).group('n')) for i in request.POST.keys() if re.match('\w+_%s_\w+_(?P<n>\d+)' % (lesson_order), i)])
#for question_order in range(1, last_question):
#for question_order in list(set([int(re.search('\w+_%s_\w+_(?P<n>\d+)' % (lesson_order), i).group('n')) for i in request.POST.keys() if re.match('\w+_%s_\w+_(?P<n>\d+)' % (lesson_order), i)])):
for question_order in [1]:
try:
#checkboxes
checkbox_question = CheckboxQuestion2()
checkbox_question.save()
checkbox_answer = CheckboxAnswer2()
checkbox_answer.save()
for h, cq in enumerate(sorted([i for i in request.POST.keys() if re.match('\w+_%s_question_%s_answer_choice_\d+' % (lesson_order, question_order), i)])):
checkbox = Checkbox2(order=h, value=request.POST[cq])
checkbox.save()
checkbox_question.checkboxes.add(checkbox)
if cq.replace('answer_choice', 'answer') in request.POST:
checkbox_answer.correct_checkboxes.add(checkbox)
checkbox_question.save()
checkbox_answer.save()
question = QuestionAndAnswer(lesson=lesson, order=question_order,
statement=request.POST['lesson_%s_question_%s' % (lesson_order, question_order)],
question_type=ContentType.objects.get(app_label="interactive_courses", model="CheckboxQuestion2"),
question_id=checkbox_question.id,
answer_type=ContentType.objects.get(app_label="interactive_courses", model="CheckboxAnswer2"),
answer_id=checkbox_answer.id)
#question.statement = request.POST['lesson_%s_question_%s' % (lesson_order, question_order)]
question.save()
except:
pass
#return HttpResponse(str(request.POST))
# get the lessons
#for lesson in course.get_lessons():
# lesson.title = request.POST['lesson_%s_title' % (lesson.order)]
# video = Video.objects.filter(lesson=lesson)[0]
# video.url = request.POST['lesson_%s_video_id' % (lesson.order)]
# video.save()
# question = QuestionAndAnswer.objects.filter(lesson=lesson)[0]
# question.statement = request.POST['lesson_%s_question' % (lesson.order)]
# question.save()
# change answer choices
# for answer_choice in QuestionAndAnswer.objects.filter(lesson=lesson)[0].question_object.checkboxes.all().order_by('order'):
# answer_choice.value = request.POST['lesson_%s_answer_choice_%s' % (lesson.order, answer_choice.order)]
# answer_choice.save()
# lesson.save()
return HttpResponse(str(request.POST))
def get_lessons(user):
lessons = Lesson.query(ancestor=get_parent_key(user)).order(Lesson.topic)
lessons_map = {}
for lesson in lessons:
lessons_map[lesson.key] = lesson.lesson_name
return lessons, lessons_map
