Beispiel #1
0
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)
Beispiel #2
0
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)
Beispiel #3
0
def set_lesson(request):
    ids = request.GET.get('lesson', '').split(',')
    del ids[len(ids)-1]
    lessons = get_list_or_404(Lesson, id__in=ids, teacher=request.user, attendance__grade=request.user.current_grade)
    for lesson in lessons:
        form = LessonForm(request.GET, instance = lesson)
        if form.is_valid():
            form.save()
    return HttpResponse('ok')
Beispiel #4
0
def set_lesson(request):
    ids = request.GET.get('lesson', '').split(',')
    del ids[len(ids) - 1]
    lessons = get_list_or_404(Lesson,
                              id__in=ids,
                              teacher=request.user,
                              attendance__grade=request.user.current_grade)
    for lesson in lessons:
        form = LessonForm(request.GET, instance=lesson)
        if form.is_valid():
            form.save()
    return HttpResponse('ok')
Beispiel #5
0
def lessonEdit(request, mode, id = 0):
    render = {}
    if request.method == 'GET':
        if mode == 'edit':
            lesson = get_object_or_404(Lesson, id = id, teacher = request.user)
            render['form'] = LessonForm(instance = lesson)
            grades_id = []
            for connection in Connection.objects.filter(teacher = request.user):
                grades_id.append(connection.grade.id)
            render['form'].fields['grade'].queryset = Grade.objects.filter(id__in = grades_id)
            render['lesson_id'] = id
            return render_to_response('marks/teacher/lesson.html', render, context_instance = RequestContext(request))
        elif mode == 'delete': 
             lesson = get_object_or_404(Lesson, id = id, teacher = request.user)
             lesson.delete()
             return HttpResponseRedirect('/marks/lesson/')
        else:
            render['form'] = LessonForm()
            grades_id = []
            for connection in Connection.objects.filter(teacher = request.user):
                grades_id.append(connection.grade.id)
            render['form'].fields['grade'].queryset = Grade.objects.filter(id__in = grades_id)
            return render_to_response('marks/teacher/lesson.html', render, context_instance = RequestContext(request))
    else:
        form = LessonForm(request.POST, request.FILES)
        grades_id = []
        for connection in Connection.objects.filter(teacher = request.user):
            grades_id.append(connection.grade.id)
        form.fields['grade'].queryset = Grade.objects.filter(id__in = grades_id)
        if mode == 'edit':
            if form.is_valid():
                lesson = get_object_or_404(Lesson, id = id, teacher = request.user)
                form = LessonForm(request.POST, request.FILES, instance = lesson)
                form.save()
                return HttpResponseRedirect('/marks/lesson/')
            else:
                render['form'] = form
                return render_to_response('marks/teacher/lesson.html', render, context_instance = RequestContext(request))
        else:
            if form.is_valid():
                lesson = form.save(commit = False)
                lesson.teacher = request.user
                lesson.subject = request.user.current_subject
                lesson.save()
                form.save_m2m()
                return HttpResponseRedirect('/marks/lesson/')
            else:
                render['form'] = form
                return render_to_response('marks/teacher/lesson.html', render, context_instance = RequestContext(request))
Beispiel #6
0
	def new_lesson(self):
		form = LessonForm()

		if request.method == 'POST':
			course_id = form.course_id.data
			course_id = ObjectId(course_id)
			if form.validate() == False:
				data = self.course_data(course_id)
				data['new_lesson_form'] = form
				data['new'] = 1
				return render_template('instructor/course.html', data=data)
			else:
				#return jsonify(course_id)
				#course_id = '5a5e2612a8af96b319f84dce'
				#data = self.course_data(str(course_id))
				#duration = request.form['duration']
				id = self.newLesson.add(form.title.data, form.video_url.data, form.description.data, form.duration.data, course_id)
				return redirect(url_for('instructor_course', courseId=course_id))

		return redirect(url_for('instructor_dashboard'))
Beispiel #7
0
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!')
Beispiel #8
0
	def update_lesson(self):
		form = LessonForm()
		data = {}

		if request.method == 'POST':
			lesson_id = form.lesson_id.data
			lesson_id = ObjectId(lesson_id)
			lesson = self.newLesson.get_lesson_by_id(lesson_id)
			if form.validate() == True:
				result = self.newLesson.update(lesson_id, form.title.data, form.video_url.data, form.description.data, form.duration.data)
				if result == 'OK':
					flash('1')
				else:
					flash('0')

				#return jsonify(str(result))
				return redirect(url_for('instructor_edit_lesson', lessonId=lesson_id))
			else:
				return redirect(url_for('instructor_edit_lesson', lessonId=lesson_id))

		return redirect(url_for('instructor_dashboard'))
Beispiel #9
0
def course_secretary_page(secretaryID):
    """Show general secretary page"""

    secretary = Secretary.query.get_or_404(secretaryID)

    if secretary.course:

        return render_template("sec_course_page.html",
                               secretary=secretary,
                               form=LessonForm())

    else:

        return redirect("/secretary")
Beispiel #10
0
	def course(self, course_id):
		if self.loggedIn != True:
			return redirect(url_for('instructor_login'))

		data = self.course_data(course_id)
		data['new_course_form'] = CourseForm()
		data['new_course_form'].instructor_id.data = data['instructor']['_id']
		data['new_lesson_form'] = LessonForm()
		data['new_lesson_form'].course_id.data = course_id

			#return jsonify(len(similar_courses))
		if data['course']:
			return render_template("instructor/course.html", data=data)
		else:
			return redirect(url_for('index'))
Beispiel #11
0
	def edit_lesson(self, lesson_id):
		form = LessonForm()
		data = {}

		lesson = self.newLesson.get_lesson_by_id(ObjectId(lesson_id))
		course = self.newCourse.get_course_by_id(lesson['course_id'])
		data['edit_lesson_form'] = form
		data['edit_lesson_form'].lesson_id.data = lesson_id
		data['edit_lesson_form'].title.data = lesson['title']
		data['edit_lesson_form'].video_url.data = lesson['video_url']
		data['edit_lesson_form'].description.data = lesson['description']
		data['edit_lesson_form'].duration.data = lesson['duration']
		data['lesson'] = lesson
		data['course'] = course

		data['instructor'] = self.newInstructor.get_instructor_by_name(session['instructor']['name'])

		return render_template('instructor/edit_lesson.html', data=data)
Beispiel #12
0
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))
Beispiel #13
0
def index(request):
    '''
        Очень обширная страница для выставления и просмотра оценок
    '''
    def _get_month_key(dt):
        return int("%d%s" % (dt.year, str(dt.month).rjust(2, "0")))

    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', 0))
            if grade not in request.user.grades.all():
                raise Http404(u'Нет такого класса')
            request.user.current_grade = grade
            request.user.save()

        if request.GET.get('set_current_subject', False):
            subject = get_object_or_404(Subject,
                                        id=request.GET.get(
                                            'set_current_subject', 0))
            if subject not in request.user.subjects.all():
                raise Http404(u'Нет такого предмета')
            request.user.current_subject = subject
            request.user.save()

        if not request.user.current_grade:
            if request.user.get_grades_for_marks():
                request.user.current_grade = request.user.get_grades_for_marks(
                )[0]
            else:
                messages.error(request, u'К вам не прикреплено классов')
                return render_to_response(
                    '~marks/%s/index.html' % request.user.type.lower(),
                    render,
                    context_instance=RequestContext(request))

        render['lesson_form'] = LessonForm()

        try:
            request.user.current_grade.get_pupils_for_teacher_and_subject(
                request.user, request.user.current_subject)
        except PlaningError:
            messages.error(request, u'В выбранном классе нет учеников')
            return render_to_response('~marks/%s/index.html' %
                                      request.user.type.lower(),
                                      render,
                                      context_instance=RequestContext(request))

        from pytils import dt
        date_start = date.today() - timedelta(days=15)
        date_end = date.today() + timedelta(days=1)
        render['stat_form'] = form = StatForm(request.GET)
        if form.is_valid():
            date_start = form.cleaned_data['start']
            date_end = form.cleaned_data['end']
        else:
            render['stat_form'] = StatForm()

        lessons_range = []
        render['monthes'] = monthes = {}
        month = date.today() - timedelta(days=365)
        while month < date.today() + timedelta(days=30):
            monthes[_get_month_key(month)] = ('', 0)
            month += timedelta(weeks=4)

        kwargs = {
            'subject': request.user.current_subject,
            'grade': request.user.current_grade
        }
        conn = Connection.objects.filter(teacher=request.user, **kwargs)
        if not conn:
            messages.error(request,
                           u'Нет связок в выбранном сочетании предмет-класс')
            return render_to_response('~marks/%s/index.html' %
                                      request.user.type.lower(),
                                      render,
                                      context_instance=RequestContext(request))

        kwargs4lesson = {
            'teacher': request.user,
            #                         'attendance__subject': request.user.current_subject,
            'date__gte': date_start,
            #                         'attendance__grade': request.user.current_grade,
            'date__lte': date_end
        }

        args = [Q(attendance__group=c.connection) for c in conn]
        args.append(Q(attendance__group="0"))
        args.append(Q(attendance=None))

        filter_arg = \
            Q(attendance__subject=request.user.current_subject, attendance__grade=request.user.current_grade) \
            | Q(resultdate__grades=request.user.current_grade, grade=request.user.current_grade, subject=request.user.current_subject)

        #        filter_args.append(Q(attendance__subject=request.user.current_subject, attendance__grade=request.user.current_grade))
        #        filter_args.append(Q(resultdate__subject=request.user.current_subject, resultdate__grade=request.user.current_grade))

        last_col = []
        last_date = None
        for lesson in Lesson.objects.filter(reduce(lambda x, y: x | y,
                                                   args), filter_arg,
                                            **kwargs4lesson).order_by('date'):

            new_range = lesson.attendance==None or not lesson.attendance.subject.groups or \
                        (len(last_col) == conn.count() and conn[0].connection != "0") or \
                        lesson.attendance.group == '0' or last_date != lesson.date

            if new_range:
                monthes[_get_month_key(lesson.date)] = (dt.ru_strftime(
                    u'%B',
                    lesson.date), monthes[_get_month_key(lesson.date)][1] + 1)
                if len(last_col):
                    lessons_range.append(last_col)
                last_col = []
            last_col.append(lesson)
            last_date = lesson.date
        if len(last_col):
            lessons_range.append(last_col)

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