示例#1
0
def get_marks(num=None,
              start_cursor=None,
              ancestor_key=None,
              mark_complete=None):
    """Retrieves the num most recent marks, starting at start_cursor, only for the ancestor if provided, and only completed or not-completed tests if mark_complete is provided"""
    if ancestor_key:
        # This checks for only marks created by this entity
        mark_query = Mark.query(
            ancestor=ancestor_key).order(-Mark.test.created)
    else:
        mark_query = Mark.query().order(-Mark.test.created)
    if mark_complete is not None:
        # Filter completed marks based on mark_complete -> default is None => all marks
        mark_query = mark_query.filter(Mark.complete == mark_complete)
    if start_cursor:
        # Set the query start to the cursor location, if provided
        marks, next_cursor, more = mark_query.fetch_page(
            num, start_cursor=start_cursor)
        try:
            return {
                'marks': marks,
                'next': next_cursor.urlsafe(),
                'more': more
            }
        except:
            return {'marks': marks, 'next': None, 'more': False}
    elif num:
        # Otherwise return the number of requested results
        return mark_query.fetch(num)
    # Or all if no num was specified
    return mark_query.fetch()
示例#2
0
    def post(self):
        template_values = get_template_values( self )
        user = users.get_current_user()

        if self.request.get('next'):
            cursor = search.Cursor(web_safe_string=self.request.get('next'))
        else:
            cursor = search.Cursor()

        q = query = self.request.get("search-text").replace(',',"")
        order = self.request.get("search-order")
        completed = True if self.request.get("search-completed") == "on" else False

        template_values["query_values"] = {
            'query':query,
            'order':order,
            'completed':completed,
        }

        if order == "rating":
            sort_exp = search.SortExpression( expression='rating', direction=search.SortExpression.DESCENDING, default_value=0)
        elif order == "times_taken":
            sort_exp = search.SortExpression( expression='times_taken', direction=search.SortExpression.DESCENDING, default_value=0)
        elif order == "date_inc":
            sort_exp = search.SortExpression( expression='date', direction=search.SortExpression.DESCENDING, default_value=0)
        elif order == "date_dec":
            sort_exp = search.SortExpression( expression='date', direction=search.SortExpression.ASCENDING, default_value=0)
        elif order == "level_dec":
            sort_exp = search.SortExpression( expression='level', direction=search.SortExpression.DESCENDING, default_value=0)
        elif order == "level_inc":
            sort_exp = search.SortExpression( expression='level', direction=search.SortExpression.ASCENDING, default_value=0)

        query_options = search.QueryOptions(
            limit = self.page_depth,
            cursor = cursor,
            sort_options = search.SortOptions(expressions=[sort_exp,]),
        )

        query_obj = search.Query(query_string=query, options=query_options)
        results = search.Index(name="tests").search(query=query_obj)
        template_values["query_results"] = []

        for document in results:
            test = Test.query( Test.id == document.doc_id ).get()
            if completed and user:
                # If the "Hide completed" checkbox is selected by the user
                if Mark.query( Mark.taker_entity.id == user.user_id(), Mark.test.id == test.id ).get() != None :
                    # And a Mark has been created
                    continue # Don't add it to the list.
                    # If this continue is active, this selects out TAKEN tests
                    # Otherwise , this if statement selects out MARKED tests
                    if Mark.query( Mark.complete == False ).get() == None:
                        # And the Test has been marked as completed for this user.
                        continue # Don't add it to the list.
            template_values["query_results"].append( test )

        path = os.path.join( os.path.dirname(__file__), os.path.join( template_dir, 'main.html' ) )
        self.response.out.write( template.render( path, template_values ))
        return
示例#3
0
    def create(movie, user_first_name, user_last_name, value):
        """ Create a new mark """
        mark = Mark(movie=movie,
                    user_first_name=user_first_name,
                    user_last_name=user_last_name,
                    value=value)

        return mark.save()
示例#4
0
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))
示例#5
0
    def execute(self, count):
        db = self._application.db
        datetime = self._application.datetime
        c_hash = self._application.hash
        random = self._application.random
        settings = self._application.settings

        with self._application.instance.app_context():
            account = Account.query \
                .filter(Account.alias == settings[Constant.SETTING_ADMIN_ALIAS]) \
                .first()
            if account is None:
                uuid = c_hash.hex(
                    c_hash.NORMAL_DIGEST,
                    datetime.timestamp(),
                    random.salt(),
                    Constant.SETTING_ADMIN_ALIAS,
                )
                account = Account(
                    alias=settings[Constant.SETTING_ADMIN_ALIAS],
                    uuid=uuid,
                )
                db.session.add(account)
            token = c_hash.hex(
                c_hash.NORMAL_DIGEST,
                datetime.timestamp(),
                random.salt(),
            )
            session = Session(
                user_device=Device.desktop,
                user_digest='',
                user_agent='',
                user_ip='',
                token=token,
            )
            account.sessions.append(session)

            tasks = Task.query \
                .filter(Task.active == True) \
                .order_by(db.func.random()).limit(count).all()
            for task in tasks:
                answer = Answer(
                    result=False,
                    option_id=None,
                )
                answer.task = task
                answer.session = session
                mark = Mark(type=Type.upvote)
                mark.task = task
                mark.session = session
            db.session.commit()
示例#6
0
def get_grouped_marks_list( entity_id ):
    """Returns a list of summary of the marks in each group
        This only provides values for groups that the user has been given
       return {{'group_name':name, 'tests_taken':tests_taken, 'total_score':num }, {...}, ... }
    """
    grouped_marks = []
    groups = set()
    mark_list = Mark.query( ancestor = ndb.Key( "Entity", entity_id) ).filter( Mark.complete == True ).order( -Mark.created ).fetch()
    for mark in mark_list:
        groups_length = len(groups)
        groups.update( mark.test.group )
        if groups_length < len(groups):
            # If the set of groups got longer, add a new dict to the list
            grouped_marks.append({
                'name': mark.test.group,
                'tests_taken': 1,
                'total_score': mark.mark * mark.test.level,
            })
        else:
            for group in grouped_marks:
                if group['name'] == mark.test.group:
                    group['tests_taken'] += 1
                    group['total_score'] += mark.mark * mark.test.level

    for group in grouped_marks:
        if group['total_score'] is not None and group['total_score'] > 0:
            group['level'] = math.floor( math.log( float(group['total_score']),2 ) )
            group['level_progress'] = (math.log( group['total_score'],2 ) - group['level']) * 100
        else:
            group['total_score'] = 0
            group['level'] = 1
            group['level_progress'] = 0
    return grouped_marks
示例#7
0
def add_test_to_template(template_values, in_test):
    """Combines Test object properties into template_values"""
    template_values['test_id'] = in_test.id
    template_values['title'] = in_test.title
    template_values['description'] = in_test.description
    template_values['group'] = in_test.group
    template_values['level'] = in_test.level
    template_values['test_created'] = in_test.created
    template_values['test_modified'] = in_test.modified
    template_values['author_id'] = in_test.author_id
    template_values['author_name'] = Entity.query(
        Entity.id == in_test.author_id).get().display_name
    template_values['times_taken'] = in_test.times_taken
    template_values['total_score'] = in_test.total_score
    template_values['num_marked'] = in_test.num_marked
    template_values['open'] = in_test.open
    if in_test.num_marked > 0:
        template_values['average_mark'] = template_values[
            'total_score'] / template_values['num_marked']
    mark_list = Mark.query(Mark.test.id == in_test.id).filter(
        Mark.rating > -1).fetch()
    template_values['num_ratings'] = len(mark_list)
    if template_values['num_ratings'] > 0:
        template_values['average_rating'] = sum(
            [mark.rating
             for mark in mark_list]) / template_values['num_ratings']
        if template_values['average_rating'] is not in_test.average_rating:
            save_average_rating(in_test.id, template_values['average_rating'])
    return template_values
示例#8
0
    def post( self, in_test_id ):
        path = urlparse.urlsplit(self.request.referrer).path
        author_id = self.request.get("author_id")
        test_id = self.request.get("test_id")
        mark_id = self.request.get("mark_id")
        address = self.request.get("mark_address")
        comment = self.request.get("comment")
        mark = self.request.get("mark")

        author_entity = Entity.query( Entity.id == author_id ).get()
        test_entity = Test.query( Test.id == test_id ).get()
        mark_entity = Mark.query( ancestor = ndb.Key("Entity", mark_id) )
        mark_entity = mark_entity.filter( Mark.test.id == test_id ).get()

        mark_entity.marker_entity = author_entity
        mark_entity.test = test_entity
        mark_entity.comment = comment
        mark_entity.mark = int(mark)
        test_entity.total_score += mark_entity.mark
        test_entity.num_marked += 1
        mark_entity.modified = datetime.datetime.now()
        mark_entity.complete = True
        mark_entity.put()
        send_email( address, test_entity, "Answer-Response")
        test_entity.put()
        self.redirect( path )
        return
示例#9
0
    def post(self, in_test_id):
        path = urlparse.urlsplit(self.request.referrer).path
        author_id = self.request.get("author_id")
        test_id = self.request.get("test_id")
        mark_id = self.request.get("mark_id")
        address = self.request.get("mark_address")
        comment = self.request.get("comment")
        mark = self.request.get("mark")

        author_entity = Entity.query(Entity.id == author_id).get()
        test_entity = Test.query(Test.id == test_id).get()
        mark_entity = Mark.query(ancestor=ndb.Key("Entity", mark_id))
        mark_entity = mark_entity.filter(Mark.test.id == test_id).get()

        mark_entity.marker_entity = author_entity
        mark_entity.test = test_entity
        mark_entity.comment = comment
        mark_entity.mark = int(mark)
        test_entity.total_score += mark_entity.mark
        test_entity.num_marked += 1
        mark_entity.modified = datetime.datetime.now()
        mark_entity.complete = True
        mark_entity.put()
        send_email(address, test_entity, "Answer-Response")
        test_entity.put()
        self.redirect(path)
        return
示例#10
0
    def get(self, test_to_get=None):
        template_values = get_template_values( self )
        user = users.get_current_user()

        if not test_to_get:
            self.logger.debug("No test was provided for lookup")
            self.redirect('/')
            return
        else:
            try:
                test = Test.query( Test.id == test_to_get).fetch(1)[0]
            except IndexError:
                self.logger.debug("Invalid Test ID")
                self.redirect('/')
            else:
                if user:
                    template_values = add_entity_to_template(
                        template_values,
                        Entity.query( Entity.id == user.user_id() ).fetch(1)[0]
                    )
                    user_level = get_user_group_level(
                        get_grouped_marks( user.user_id() ),
                        test.group
                    )
                    if user_level == None:
                        user_level = 1

                    template_values['user_level'] = user_level
                    if user_level < test.level:
                        template_values['locked'] = True
                    try:
                        mark_query = Mark.query( ancestor = ndb.Key("Entity", user.user_id() ) )
                        mark = mark_query.filter( Mark.test.id == test.id ).fetch(1)[0]
                        template_values = add_mark_to_template( template_values, mark )
                        if (datetime.datetime.now() - mark.modified) < datetime.timedelta(hours=24) or mark.complete:
                            template_values['locked'] = True
                    except IndexError:
                        self.logger.debug( "No mark found" )
                        template_values = add_test_to_template( template_values, test )
                    finally:
                        if test.author_id == user.user_id():
                            template_values['is_test_marker'] = True
                            template_values['locked'] = True
                            test_marker = Entity.query( Entity.id == user.user_id() ).get()
                            template_values['to_be_marked'] = get_to_be_marked( test_marker, test )
                            template_values['name'] = test_marker.display_name
                            template_values['current_user'] = user.user_id()
                else:
                    template_values['locked'] = True
                    template_values['visitor'] = True
                    logging.warning("User not found!")
                    template_values = add_test_to_template( template_values, test )


            finally:

                path = os.path.join( os.path.dirname(__file__), os.path.join( template_dir, 'test_detail.html') )
                self.response.out.write( template.render( path, template_values) )
        return
示例#11
0
def get_marked( entity, num=None ):
    """Retrieves the responses from other entities that need to have marks assigned for tests created by this entity"""
    mark_query = Mark.query( Mark.marker_entity.id == entity.id )
    mark_query = mark_query.filter( Mark.complete == True )
    if not num:
        return mark_query.fetch()
    else:
        return mark_query.fetch( num )
示例#12
0
def get_marked(entity, num=None):
    """Retrieves the responses from other entities that need to have marks assigned for tests created by this entity"""
    mark_query = Mark.query(Mark.marker_entity.id == entity.id)
    mark_query = mark_query.filter(Mark.complete == True)
    if not num:
        return mark_query.fetch()
    else:
        return mark_query.fetch(num)
示例#13
0
def set_mark(request):
    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'н', '', u'б', u'b']:
        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'н', u'b', u'б']:
        m.absent = True
        if mark in [u'б', u'b']:
            m.sick = True
    else:
        m.mark = int(mark)
    m.save()
    pupil.get_groups()
    if lesson.attendance and lesson.attendance.subject_id in pupil.groups and lesson.attendance.group != pupil.groups[lesson.attendance.subject_id].value:
        mail_admins("lesson cognetive dissonans", "Lesson id#%d, mark id#%d" % (lesson.id, m.id))
    return HttpResponse(demjson.encode({'id': tr_id,
                                        'mark': get_mark(pupil, [lesson,]),
                                        'mark_value': str(m).strip(),
                                        'mark_type': m.get_type()
    }, encoding='utf8'))
示例#14
0
def new_mark():
    form = MarkForm()
    if form.validate_on_submit():
        m = Mark()
        form.populate_obj(m)
        m.owner_id = g.user.id
        m.created = datetime.utcnow()
        if form.tags.data:
            m.tags = ' '.join([t.strip()
                              for t in form.tags.data.strip().split(',')])\
                        .lower()
        m.clicks = 0
        if not form.title.data:
            soup = BSoup(urlopen(form.url.data))
            m.title = soup.title.string
        db.session.add(m)
        db.session.commit()
        flash('New mark %s added' % (m.title), category='info')
        return redirect(url_for('marks'))
    if request.args.get('url'):
        form.url.data = request.args.get('url')
    if request.args.get('title'):
        form.title.data = request.args.get('title')
    if request.args.get('type') == 'feed':
        form.type.data = 'feed'
    return render_template('mark/new.html', title='New mark', form=form)
示例#15
0
def get_student_data():
    return_ = {}
    faculty = random.choice(Faculty.objects())
    return_['curator'] = random.choice(Curator.objects(faculty=faculty))
    return_['academic_group'] = random.choice(
        AcademicGroup.objects(faculty=faculty))

    return_['student_card'] = random.randint(0, 100000000000000)
    return_['student_name'] = get_random_word(random.randint(2, 10)).title()
    return_['student_surname'] = get_random_word(random.randint(2, 15)).title()

    return_['marks'] = []
    lower_mark = random.randint(2, 5)
    for i in range(random.randint(5, 10)):
        mark = Mark()
        mark.mark = random.randint(lower_mark, 5)
        return_['marks'].append(mark)

    return return_
示例#16
0
def new_mark():
    form = MarkForm()
    if form.validate_on_submit():
        m = Mark()
        form.populate_obj(m)
        m.owner_id = g.user.id
        m.created = datetime.utcnow()
        if form.tags.data:
            m.tags = ' '.join([t.strip()
                              for t in form.tags.data.strip().split(',')])\
                        .lower()
        m.clicks = 0
        if not form.title.data:
            soup = BSoup(urlopen(form.url.data))
            m.title = soup.title.string
        db.session.add(m)
        db.session.commit()
        flash('New mark %s added' % (m.title), category='info')
        return redirect(url_for('marks'))
    if request.args.get('url'):
        form.url.data = request.args.get('url')
    if request.args.get('title'):
        form.title.data = request.args.get('title')
    if request.args.get('type') == 'feed':
        form.type.data = 'feed'
    return render_template('mark/new.html',
                           title='New mark',
                           form=form)
示例#17
0
def get_marks( num=None, start_cursor=None, ancestor_key=None, mark_complete=None):
    """Retrieves the num most recent marks, starting at start_cursor, only for the ancestor if provided, and only completed or not-completed tests if mark_complete is provided"""
    if ancestor_key:
        # This checks for only marks created by this entity
        mark_query = Mark.query( ancestor = ancestor_key ).order( -Mark.test.created )
    else:
        mark_query = Mark.query().order( -Mark.test.created )
    if mark_complete is not None:
        # Filter completed marks based on mark_complete -> default is None => all marks
        mark_query = mark_query.filter( Mark.complete == mark_complete )
    if start_cursor:
        # Set the query start to the cursor location, if provided
        marks, next_cursor, more = mark_query.fetch_page(num, start_cursor=start_cursor)
        try:
            return { 'marks':marks, 'next':next_cursor.urlsafe(), 'more':more }
        except:
            return { 'marks':marks, 'next':None, 'more':False }
    elif num:
        # Otherwise return the number of requested results
        return mark_query.fetch( num )
    # Or all if no num was specified
    return mark_query.fetch()
示例#18
0
def giveMark(request, grade_id, lesson_id):
    render = {}
    grade = get_object_or_404(Grade, id = grade_id)
    lesson = get_object_or_404(Lesson, id = lesson_id)
    if (grade in request.user.grades.all()) and (lesson.teacher == request.user):
        if not request.POST.get('send'):
            marks = []
            pupilsForMarks = []
            for pupil in Pupil.objects.filter(grade = grade):
                if request.POST.get('pupil-%d' % pupil.id):
                    try:
                        mark = Mark.objects.get(lesson = lesson, pupil = pupil)
                        markForm = MarkForm(prefix = pupil.id, instance = mark)
                    except ObjectDoesNotExist:
                        markForm = MarkForm(prefix = pupil.id)
                    marks.append({'name': pupil.fi(), 'form': markForm})
                    pupilsForMarks.append(pupil.id)
            render['marks'] = marks
            return render_to_response('marks/teacher/giveMark.html', render, context_instance = RequestContext(request))
        else:
            error = 0
            for pupil in Pupil.objects.filter(grade = grade):
                if request.POST.get('%d-mark' % pupil.id) or request.POST.get('%d-absent' % pupil.id):
                    form = MarkForm(request.POST, prefix = pupil.id)
                    if form.is_valid():
                        try:
                            mark = Mark.objects.get(pupil = Pupil.objects.get(id = pupil.id), 
                                                    lesson = lesson)
                        except ObjectDoesNotExist:
                            mark = Mark()
                        mark.pupil = Pupil.objects.get(id = pupil.id)
                        mark.lesson = lesson
                        mark.mark = form.cleaned_data['mark']
                        mark.absent = form.cleaned_data['absent']
                        mark.comment = form.cleaned_data['comment']
                        mark.save()
                    else:
                        error = 1
            if error == 0:
                return HttpResponseRedirect('/marks/grade/%d/' % grade.id)
            else: 
                marks = []
                for pupil in Pupil.objects.filter(grade = grade):
                    if request.POST.get('%d-mark' % pupil.id) or request.POST.get('%d-absent' % pupil.id):
                        marks.append({'name': pupil.fi(), 'form': MarkForm(request.POST, prefix = pupil.id)})
                render['marks'] = marks
                return render_to_response('marks/teacher/giveMark.html', render, context_instance = RequestContext(request))
    return Http404
示例#19
0
 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
示例#20
0
    def post(self):
        user = users.get_current_user()
        mark_id = self.request.get("mark_id")
        rating = int(self.request.get("rating"))
        try:
            mark = Mark.query( ancestor = ndb.Key("Entity", user.user_id()) ).filter( Mark.id == mark_id ).get()
        except:
            mark = None
        if mark:
            mark.rating = int( rating )
            mark.rated = True
            mark.put()

        self.redirect("/t/%s" % mark_id)
示例#21
0
    def post(self):
        user = users.get_current_user()
        mark_id = self.request.get("mark_id")
        rating = int(self.request.get("rating"))
        try:
            mark = Mark.query(
                ancestor=ndb.Key("Entity", user.user_id())).filter(
                    Mark.id == mark_id).get()
        except:
            mark = None
        if mark:
            mark.rating = int(rating)
            mark.rated = True
            mark.put()

        self.redirect("/t/%s" % mark_id)
示例#22
0
    def post(self):

        try:
            data = StudentPostSchema().load(request.get_json())
        except ValidationError as err:
            return str(err)

        if data.get('marks'):
            marks = []
            for m in data['marks'].split(','):
                m_dict = {'mark': int(m.strip())}

                try:
                    m_data = MarkSchema().load(m_dict)
                except ValidationError as err:
                    return str(err)

                mark_obj = Mark(**m_data)
                marks.append(mark_obj)

            data['marks'] = marks

        faculty = get_faculty_by_abr_or_name(data['faculty'])
        del data['faculty']

        if data.get('curator_name') and data.get('curator_surname'):
            data['curator'] = Curator.objects.get(
                faculty=faculty,
                curator_name=data['curator_name'],
                curator_surname=data['curator_surname'])

            del data['curator_name']
            del data['curator_surname']

        if not data['curator']:
            #raise ValidationError('No curator found with this name on the same faculty as student')
            return 'No curator found with this name on the same faculty as student'

        data['academic_group'] = AcademicGroup.objects.get(
            academic_group_name=data['academic_group'], faculty=faculty)

        if not data['academic_group']:
            #raise ValidationError('No academic group found with this name on the same faculty as student')
            return 'No academic group found with this name on the same faculty as student'

        student = Student.objects.create(**data)
        return StudentSchema().dump(student)
示例#23
0
def get_grouped_marks(entity_id):
    """Returns a list of summary of the marks in each group
        This list will return all available lgroups, even if the level is 0.
    """
    grouped_marks = []
    groups = set()
    mark_list = Mark.query(ancestor=ndb.Key("Entity", entity_id)).filter(
        Mark.complete == True).order(-Mark.created).fetch()
    entity = Entity.query(Entity.id == entity_id).fetch()[0]

    group_list = []
    for mark in mark_list:
        groups_length = len(groups)
        groups.update(mark.test.group)
        if groups_length < len(groups):
            # If the set of groups got longer, add a new dict to the list
            grouped_marks.append({
                'group': mark.test.group,
                'level': mark.test.level,
                'level_progress': 0,
                'tests_taken': 0,
                'total_score': 0,
            })
        else:
            for group in grouped_marks:
                if group['group'] == mark.test.group:
                    group['tests_taken'] += 1
                    group['total_score'] += mark.mark * mark.test.level
                    group_list.append(mark.test.group)

    for group in grouped_marks:
        if group['total_score'] is not None and group['total_score'] > 0:
            group['level'] = math.floor(
                math.log(float(group['total_score']), 2))
            group['level_progress'] = (math.log(group['total_score'], 2) -
                                       group['level']) * 100
        else:
            group['total_score'] = 0
            group['level'] = 1
            group['level_progress'] = 0

    unused_defaults = set(itertools.chain(
        entity.test_groups, default_groups)) - set(
            [group['group'] for group in grouped_marks])
    for group in unused_defaults:
        grouped_marks.append({'group': group, 'level': 1, 'level_progress': 0})
    return grouped_marks
示例#24
0
def get_mark(id):
    mark = Mark.get(id=id)
    try:
        score = curses.wrapper(
            get_input, 'Enter the mark you wanna record for this student: ')
        score = int(score)
    except ValueError:
        curses.wrapper(show_message, 'You should enter a number!')
        return False
    if 0 <= score <= 20:
        mark.mark = score
        mark.save()
        curses.wrapper(show_message, 'Your mark successfully recorded!')
        return True
    else:
        curses.wrapper(show_message,
                       'You should enter a valid number between 0 and 20')
        return False
示例#25
0
def set_mark(request):
    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'н', '', u'б', u'b']:
        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'н', u'b', u'б']:
        m.absent = True
        if mark in [u'б', u'b']:
            m.sick = True
    else:
        m.mark = int(mark)
    m.save()
    pupil.get_groups()
    if lesson.attendance and lesson.attendance.subject_id in pupil.groups and lesson.attendance.group != pupil.groups[
            lesson.attendance.subject_id].value:
        mail_admins("lesson cognetive dissonans",
                    "Lesson id#%d, mark id#%d" % (lesson.id, m.id))
    return HttpResponse(
        demjson.encode(
            {
                'id': tr_id,
                'mark': get_mark(pupil, [
                    lesson,
                ]),
                'mark_value': str(m).strip(),
                'mark_type': m.get_type()
            },
            encoding='utf8'))
示例#26
0
def get_grouped_marks( entity_id ):
    """Returns a list of summary of the marks in each group
        This list will return all available lgroups, even if the level is 0.
    """
    grouped_marks = []
    groups = set()
    mark_list = Mark.query( ancestor = ndb.Key( "Entity", entity_id )).filter( Mark.complete == True ).order( -Mark.created ).fetch()
    entity = Entity.query( Entity.id == entity_id).fetch()[0]

    group_list = []
    for mark in mark_list:
        groups_length = len(groups)
        groups.update( mark.test.group )
        if groups_length < len(groups):
            # If the set of groups got longer, add a new dict to the list
            grouped_marks.append({
                'group' : mark.test.group,
                'level' : mark.test.level,
                'level_progress' : 0,
                'tests_taken' : 0,
                'total_score' : 0,
            })
        else:
            for group in grouped_marks:
                if group['group'] == mark.test.group:
                    group['tests_taken'] += 1
                    group['total_score'] += mark.mark * mark.test.level
                    group_list.append( mark.test.group )

    for group in grouped_marks:
        if group['total_score'] is not None and group['total_score'] > 0:
            group['level'] = math.floor( math.log( float(group['total_score']),2 ) )
            group['level_progress'] = (math.log( group['total_score'],2 ) - group['level']) * 100
        else:
            group['total_score'] = 0
            group['level'] = 1
            group['level_progress'] = 0

    unused_defaults = set( itertools.chain( entity.test_groups, default_groups )) - set( [ group['group'] for group in grouped_marks ] )
    for group in unused_defaults:
        grouped_marks.append( {'group':group,'level':1,'level_progress':0} )
    return grouped_marks
示例#27
0
def setup(is_empty=True):
    table = Texttable().add_rows([['Student name', 'Student number', 'Grade']])
    for student in User.select().where((User.is_active == True)
                                       & (User.is_student == True)):
        sum, cnt, check = 0, 0, False
        for mark in Mark.select().where(Mark.student == student):
            if mark.mark:
                sum += mark.mark
                cnt += 1
                check = True
        if check:
            student.grade = sum / cnt
            student.save()
            table.add_row([
                get_student_name(student), student.student_number,
                student.grade
            ])
            is_empty = False
    if is_empty:
        curses.wrapper(show_message, 'Nothing to show! :)')
    else:
        # TODO: sort the table before draw that!
        curses.wrapper(draw_menu, table.draw())
示例#28
0
def add_test_to_template( template_values, in_test ):
    """Combines Test object properties into template_values"""
    template_values['test_id'] = in_test.id
    template_values['title'] = in_test.title
    template_values['description'] = in_test.description
    template_values['group'] = in_test.group
    template_values['level'] = in_test.level
    template_values['test_created'] = in_test.created
    template_values['test_modified'] = in_test.modified
    template_values['author_id'] = in_test.author_id
    template_values['author_name'] = Entity.query( Entity.id == in_test.author_id ).get().display_name
    template_values['times_taken'] = in_test.times_taken
    template_values['total_score'] = in_test.total_score
    template_values['num_marked'] = in_test.num_marked
    template_values['open'] = in_test.open
    if in_test.num_marked > 0:
        template_values['average_mark'] = template_values['total_score'] / template_values['num_marked']
    mark_list = Mark.query( Mark.test.id == in_test.id ).filter( Mark.rating > -1 ).fetch()
    template_values['num_ratings'] = len(mark_list)
    if template_values['num_ratings'] > 0:
        template_values['average_rating'] =  sum([mark.rating for mark in mark_list]) / template_values['num_ratings']
        if template_values['average_rating'] is not in_test.average_rating:
            save_average_rating( in_test.id, template_values['average_rating'])
    return template_values
示例#29
0
def get_grouped_marks_list(entity_id):
    """Returns a list of summary of the marks in each group
        This only provides values for groups that the user has been given
       return {{'group_name':name, 'tests_taken':tests_taken, 'total_score':num }, {...}, ... }
    """
    grouped_marks = []
    groups = set()
    mark_list = Mark.query(ancestor=ndb.Key("Entity", entity_id)).filter(
        Mark.complete == True).order(-Mark.created).fetch()
    for mark in mark_list:
        groups_length = len(groups)
        groups.update(mark.test.group)
        if groups_length < len(groups):
            # If the set of groups got longer, add a new dict to the list
            grouped_marks.append({
                'name': mark.test.group,
                'tests_taken': 1,
                'total_score': mark.mark * mark.test.level,
            })
        else:
            for group in grouped_marks:
                if group['name'] == mark.test.group:
                    group['tests_taken'] += 1
                    group['total_score'] += mark.mark * mark.test.level

    for group in grouped_marks:
        if group['total_score'] is not None and group['total_score'] > 0:
            group['level'] = math.floor(
                math.log(float(group['total_score']), 2))
            group['level_progress'] = (math.log(group['total_score'], 2) -
                                       group['level']) * 100
        else:
            group['total_score'] = 0
            group['level'] = 1
            group['level_progress'] = 0
    return grouped_marks
示例#30
0
def create():
    class_name = request.json.get('class_name')
    term_begin = request.json.get('term_begin')
    term_end = request.json.get('term_end')
    class_master = request.json.get('master_number')

    grades = [
        '大一上学期', '大一下学期', '大二上学期', '大二下学期', '大三上学期', '大三下学期', '大四上学期', '大四下学期'
    ]
    subject_name = []

    # build class
    new_class = FzuClass.query.filter(FzuClass.name == class_name).first()
    if not new_class:
        new_class = FzuClass(name=class_name)
        db.session.add(new_class)
        if not db_commit():
            return jsonify({'status': 303}), 303

    # build student
    data = pd.read_excel('mark.xls', usecols=[0, 1], converters={
        0: str
    }).values
    for (student_number, name) in data:
        _user = User.query.filter(
            User.student_number == student_number).first()
        if _user:
            continue
        else:
            user = User(student_number=student_number,
                        password=student_number,
                        name=name)
            user.class_id = new_class.id
            db.session.add(user)
    if not db_commit():
        return jsonify({'status': 303}), 303

    # build mark
    for i in range(term_end - term_begin + 1):
        data = pd.read_excel('mark.xls', sheet_name=[i], converters={0:
                                                                     str})[i]
        (r, c) = data.shape
        columns = data.columns.values.tolist()
        subject_name.extend(columns[2:])
        for j in range(r):
            user = User.query.filter(
                User.student_number == data.iloc[j, 0]).first()
            average = float(data.iloc[j, 2:].mean())
            for k in range(2, c):
                mark = Mark(name=columns[k],
                            mark=float(data.iloc[j, k]),
                            user_id=user.id,
                            class_id=new_class.id)
                mark.grade = grades[term_begin + i]
                mark.segment = get_segment(mark.mark)
                mark.average = average
                db.session.add(mark)
        for k in range(2, c):
            df = data.iloc[:, k]
            class_mark = Class_mark(
                name=columns[k],
                max_s=float(df.max()),
                min_s=float(df.min()),
                average=float(df.mean()),
                grade=grades[term_begin + i],
                pass_rate=float(df[df >= 60].count() / len(df) * 100),
                good_rate=float(df[df >= 90].count() / len(df) * 100),
                class_id=new_class.id)
            db.session.add(class_mark)
    if not db_commit():
        return jsonify({'status': 303}), 303

    # build rank
    create_rank(class_id=new_class.id)

    # build class master
    set_master(student_number=class_master)
    return jsonify({'status': 200}), 200
示例#31
0
    def post(self):
        test_id = self.request.get('test_id')
        author_id = self.request.get('author_id')

        user = users.get_current_user()
        if user:
            test = Test.query(Test.id == test_id).get()
            mark_query = Mark.query(ancestor=ndb.Key("Entity", user.user_id()))
            mark_query = mark_query.filter(Mark.test.id == test.id)

            this_mark = mark_query.get()

            if this_mark == None:
                print "IndexError"
                this_mark = Mark(parent=ndb.Key("Entity", user.user_id()))
                this_mark.test = test
                this_mark.created = datetime.datetime.now()
                this_mark.mark = None
                this_mark.rated = False
                this_mark.rating = 0
                test.times_taken += 1
                test.put()

            this_mark.response = self.request.get('response')
            this_mark.complete = False
            this_mark.modified = datetime.datetime.now()
            this_mark.id = test_id + user.user_id()
            this_mark.marker_entity = Entity.query(
                Entity.id == author_id).get()
            this_mark.taker_entity = Entity.query(
                Entity.id == user.user_id()).get()
            send_email(this_mark.marker_entity.user.email(), test,
                       "Test-Answer")
            this_mark.put()

        self.redirect('/t/%s' % test_id)
        return
示例#32
0
for group in groups:
    data = {'group': group.id, 'student_name': '', 'do_select': 'Выбрать'}
    students = list(
        map(
            lambda x: Student.create_or_get(**x)[0].groups.add(group),
            student_list_parser(
                session.post(baseUrl + 'students', data=data).content)))
    sys.stdout.write('\rFound {} students in {}'.format(
        len(students), group.name))

students = Student.select()
sys.stdout.write('\rFound {} students\n'.format(len(students)))

count = 0
for student in students:
    for disciplineDict in student_parser(
            session.get(baseUrl +
                        'marks_student?id={}'.format(student.id)).content):
        tasks = disciplineDict.pop('tasks')
        (discipline, _) = Discipline.create_or_get(**disciplineDict)
        for taskDict in tasks:
            marks = taskDict.pop('marks')
            (task, _) = Task.create_or_get(**taskDict, discipline=discipline)
            for mark in marks:
                Mark.create_or_get(**mark, task=task, student=student)
    count += 1
    sys.stdout.write('\rProcessed {}/{} students'.format(count, len(students)))

print('\nFinished')
示例#33
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))
示例#34
0
    def post(self):
        test_id = self.request.get( 'test_id' )
        author_id = self.request.get( 'author_id' )

        user = users.get_current_user()
        if user:
            test = Test.query( Test.id == test_id ).get()
            mark_query = Mark.query( ancestor = ndb.Key("Entity", user.user_id() ) )
            mark_query = mark_query.filter( Mark.test.id == test.id )

            this_mark = mark_query.get()

            if this_mark == None:
                print "IndexError"
                this_mark = Mark( parent = ndb.Key("Entity", user.user_id() ) )
                this_mark.test = test
                this_mark.created = datetime.datetime.now()
                this_mark.mark = None
                this_mark.rated = False
                this_mark.rating = 0
                test.times_taken += 1
                test.put()

            this_mark.response = self.request.get( 'response' )
            this_mark.complete = False
            this_mark.modified = datetime.datetime.now()
            this_mark.id = test_id + user.user_id()
            this_mark.marker_entity = Entity.query( Entity.id == author_id ).get()
            this_mark.taker_entity = Entity.query( Entity.id == user.user_id() ).get()
            send_email( this_mark.marker_entity.user.email() , test,  "Test-Answer")
            this_mark.put()

        self.redirect( '/t/%s' % test_id )
        return
示例#35
0
    def create(movie_id, user_id, note):
        """ Create a new mark """
        mark = Mark(movie_id=movie_id, user_id=user_id, note=note)

        return mark.save()
示例#36
0
    def put(self, id):
        student = Student.objects.get(id=id)

        try:
            data = StudentPutSchema().load(request.get_json())
        except ValidationError as err:
            return str(err)

        if data.get('marks'):
            marks = []
            for m in data['marks'].split(','):
                m_dict = {'mark': int(m.strip())}

                try:
                    m_data = MarkSchema().load(m_dict)
                except ValidationError as err:
                    return str(err)

                mark_obj = Mark(**m_data)
                marks.append(mark_obj)

            data['marks'] = marks

        if data.get('faculty'):
            faculty = get_faculty_by_abr_or_name(data['faculty'])
            del data['faculty']

        if data.get('curator_name') and data.get('curator_surname'):
            data['curator'] = Curator.objects.get(
                faculty=faculty,
                curator_name=data['curator_name'],
                curator_surname=data['curator_surname'])

            if not data['curator']:
                #raise ValidationError('No curator found with this name on the same faculty as student')
                return 'No curator found with this name on this faculty'

            del data['curator_name']
            del data['curator_surname']

        if data.get('academic_group'):
            data['academic_group'] = AcademicGroup.objects.get(
                academic_group_name=data['academic_group'], faculty=faculty)

            if not data['academic_group']:
                #raise ValidationError('No academic group found with this name on the same faculty as student')
                return 'No academic group found with this name on this faculty'

        if (data.get('curator') and
            not data.get('academic_group') and
            data.get('curator').faculty != student.faculty) or \
            (not data.get('curator') and
             data.get('academic_group') and
             student.curator and
             data.get('academic_group').faculty != student.curator.faculty):
            # raise ValidationError('Group and curator are in different faculties')
            return 'Group and curator are in different faculties'

        student.modify(**data)

        return StudentSchema().dump(student)
示例#37
0
    def post(self):
        template_values = get_template_values(self)
        user = users.get_current_user()

        if self.request.get('next'):
            cursor = search.Cursor(web_safe_string=self.request.get('next'))
        else:
            cursor = search.Cursor()

        q = query = self.request.get("search-text").replace(',', "")
        order = self.request.get("search-order")
        completed = True if self.request.get(
            "search-completed") == "on" else False

        template_values["query_values"] = {
            'query': query,
            'order': order,
            'completed': completed,
        }

        if order == "rating":
            sort_exp = search.SortExpression(
                expression='rating',
                direction=search.SortExpression.DESCENDING,
                default_value=0)
        elif order == "times_taken":
            sort_exp = search.SortExpression(
                expression='times_taken',
                direction=search.SortExpression.DESCENDING,
                default_value=0)
        elif order == "date_inc":
            sort_exp = search.SortExpression(
                expression='date',
                direction=search.SortExpression.DESCENDING,
                default_value=0)
        elif order == "date_dec":
            sort_exp = search.SortExpression(
                expression='date',
                direction=search.SortExpression.ASCENDING,
                default_value=0)
        elif order == "level_dec":
            sort_exp = search.SortExpression(
                expression='level',
                direction=search.SortExpression.DESCENDING,
                default_value=0)
        elif order == "level_inc":
            sort_exp = search.SortExpression(
                expression='level',
                direction=search.SortExpression.ASCENDING,
                default_value=0)

        query_options = search.QueryOptions(
            limit=self.page_depth,
            cursor=cursor,
            sort_options=search.SortOptions(expressions=[
                sort_exp,
            ]),
        )

        query_obj = search.Query(query_string=query, options=query_options)
        results = search.Index(name="tests").search(query=query_obj)
        template_values["query_results"] = []

        for document in results:
            test = Test.query(Test.id == document.doc_id).get()
            if completed and user:
                # If the "Hide completed" checkbox is selected by the user
                if Mark.query(Mark.taker_entity.id == user.user_id(),
                              Mark.test.id == test.id).get() != None:
                    # And a Mark has been created
                    continue  # Don't add it to the list.
                    # If this continue is active, this selects out TAKEN tests
                    # Otherwise , this if statement selects out MARKED tests
                    if Mark.query(Mark.complete == False).get() == None:
                        # And the Test has been marked as completed for this user.
                        continue  # Don't add it to the list.
            template_values["query_results"].append(test)

        path = os.path.join(os.path.dirname(__file__),
                            os.path.join(template_dir, 'main.html'))
        self.response.out.write(template.render(path, template_values))
        return
示例#38
0
async def index(**kw):

    #用户登录:接受客户端传来的code和nickname,从微信服务器获取openin和session_key,检索数据库,有则更新,无则增加一条记录
    if kw.get('code', None) and kw.get('nickName', None):
        print(appId)
        wxAPIURL = 'https://api.weixin.qq.com/sns/jscode2session?appid=%s&secret=%s&js_code=%s&grant_type=authorization_code' % (
            appId, appSecret, kw.get('code'))
        async with ClientSession() as session:
            async with session.get(wxAPIURL) as resp:
                #resp.text()是json格式的文本,需处理
                openidAndsession_key = json.loads(await resp.text())
        currentUser = await User.find(openidAndsession_key.get('openid'))
        if currentUser:
            #以防用户改过微信昵称,每次登录及时储存当前微信昵称
            currentUser.nickName = kw.get('nickName')
            await currentUser.update()
            #返回openid字符串作为SessionId
            return currentUser.id
        else:
            #openid字符串同时作为主键便于查找
            currentUser = User(
                id=openidAndsession_key.get('openid'),
                session_key=openidAndsession_key.get('session_key'),
                nickName=kw.get('nickName'))
            await currentUser.save()
            return currentUser.id

    #获取用户答案,更新Answer表
    if kw.get('answer', None) and kw.get('question_id', None) and kw.get(
            'SessionId', None):
        score = calculate_question_functionDict[kw.get('question_id')](
            kw.get('answer'))
        answer = Answer(answerText=kw.get('answer'),
                        question_id=kw.get('question_id'),
                        user_id=kw.get('SessionId'),
                        markNumByMachine=score)
        await answer.save()
        return answer.markNumByMachine

    #获取题库以及答案列表
    if kw.get('listName', None):
        examinations = await Examination.findAll()
        for e in examinations:
            e['open'] = False
            e['titles'] = [t for t in await Title.findAll('exam_id=?', e.id)]
            for t in e['titles']:
                t['questions'] = [
                    qs for qs in await Question.findAll('title_id=?', t.id)
                ]
        return json.dumps(examinations)

    #添加反馈到FeedBack表
    if kw.get('feedback', None) and kw.get('SessionId', None):
        currentUser = await User.find(kw.get('SessionId'))
        feedback = Feedback(feedbackContent=kw.get('feedback'),
                            userId=currentUser.id,
                            nickName=currentUser.nickName)
        await feedback.save()
        return 'done'

    #根据titleId查询user,并返回respondents
    if kw.get('titleId', None):
        respondents = {}
        for question in await Question.findAll('title_id=?',
                                               kw.get('titleId')):
            for answer in await Answer.findAll('question_id=?',
                                               question.id,
                                               orderBy='create_at asc'):
                u = await User.find(answer.user_id)
                pickerArray = ['请选择分数,确定即提交', 0]
                for i in range(question.fullMark):
                    pickerArray.append(i + 1)
                if answer.user_id + u.nickName in respondents:
                    #用user_id加上nickName作为key是避免出现用户有相同昵称,所以在value中还加上了user_id,方便客户端将key中的user_id去掉
                    respondents[answer.user_id + u.nickName].append({
                        'user_id':
                        answer.user_id,
                        'answer_id':
                        answer.id,
                        'answerText':
                        answer.answerText,
                        'markNumByMachine':
                        answer.markNumByMachine,
                        'question_id':
                        answer.question_id,
                        'pickerArray':
                        pickerArray,
                        'pickerIndex':
                        0,
                        'display':
                        'none'
                    })
                else:
                    respondents[answer.user_id + u.nickName] = [{
                        'user_id':
                        answer.user_id,
                        'answer_id':
                        answer.id,
                        'answerText':
                        answer.answerText,
                        'markNumByMachine':
                        answer.markNumByMachine,
                        'question_id':
                        answer.question_id,
                        'pickerArray':
                        pickerArray,
                        'pickerIndex':
                        0,
                        'display':
                        'none'
                    }]
        return json.dumps(respondents)

    #根据titleId查询对应用户的答案
    if kw.get('answeredTitleId', None):
        questionsAnswered = []
        for question in await Question.findAll('title_id=?',
                                               kw.get('answeredTitleId')):
            questionsAnswered.append({
                'questionContent': question.questionContent,
                'markReference': question.markReference,
                'id': question.id,
                'answers': []
            })
        return json.dumps(questionsAnswered)

    #获取用户评分,存到Mark表中
    if kw.get('markNumByUser', None) and kw.get(
            'user_mark_id', None) and kw.get('answer_id', None):
        mark = Mark(user_mark_id=kw.get('user_mark_id'),
                    answer_id=kw.get('answer_id'),
                    markNumByUser=kw.get('markNumByUser'))
        await mark.save()
        return '稳了'

    #根据I_mark_sessionId和questions数组得到I_mark_table表格
    if kw.get('I_mark_sessionId', None) and kw.get('questionIds', None):
        I_mark_table = {}
        for marksByMe in await Mark.findAll(
                'user_mark_id=?',
                kw.get('I_mark_sessionId'),
                orderBy='create_at asc'):  #查询该用户打得分,按时间升序排列
            for questionId in json.loads(kw.get('questionIds')):
                I_mark_table.setdefault(questionId, [])
                for answer in await Answer.findAll(
                        'question_id=?', questionId,
                        orderBy='create_at asc'):  #查询某道题的回答,按时间升序排列
                    #当该用户打分的answer_id与根据question_id查询到的answer_id相等时,则是该用户给这道题打的所有分,有可能同道题同个人答了多次,也可能给同个人的一次答题打了多次分
                    if answer.id == marksByMe.answer_id:
                        userAnswered = await User.find(answer.user_id)
                        I_mark_table[questionId].append({
                            'answerText':
                            answer.answerText,
                            'userNickname':
                            userAnswered.nickName,
                            'markNumByMachine':
                            answer.markNumByMachine,
                            'markNumByUser':
                            marksByMe.markNumByUser
                        })
        return json.dumps(I_mark_table)

    #根据sessionId和questions数组得到I_mark_table表格
    if kw.get('mark_me_sessionId', None) and kw.get('questionIds', None):
        mark_me_table = {}
        for questionId in json.loads(kw.get('questionIds')):
            mark_me_table.setdefault(questionId, [])
            for answer in await Answer.findAll('question_id=?',
                                               questionId,
                                               orderBy='create_at asc'):
                if answer.user_id == kw.get('mark_me_sessionId'):
                    tableList = []
                    for mark in await Mark.findAll('answer_id=?', answer.id):
                        user = await User.find(mark.user_mark_id)
                        tableList.append({
                            'userNickname': user.nickName,
                            'markNumByUser': mark.markNumByUser
                        })
                    mark_me_table[questionId].append({
                        'answerText':
                        answer.answerText,
                        'markNumByMachine':
                        answer.markNumByMachine,
                        'table':
                        tableList
                    })
        return json.dumps(mark_me_table)
示例#39
0
def result_mark(course, student):
    mark, created = Mark.get_or_create(course=course, student=student)
    return str(mark.mark) if mark.mark else 'Not recorded!'
示例#40
0
def addMark(student, course, hw, task, date, score):
    m = Mark(studentID=student, courseID=course, hwNo=hw, taskNo=task, date=date, result=score)
    m.save()
示例#41
0
def get_mark_id(course, student):
    mark, created = Mark.get_or_create(course=course, student=student)
    return '{}'.format(mark.id)
示例#42
0
 def FormResponseData(self):
     mark = Mark(ForUser=self.user, ForExercise=self.exer,
         Score = self.score, DateTime = self.date)
     mark.save()
     return "OK"
示例#43
0
    def get(self, test_to_get=None):
        template_values = get_template_values(self)
        user = users.get_current_user()

        if not test_to_get:
            self.logger.debug("No test was provided for lookup")
            self.redirect('/')
            return
        else:
            try:
                test = Test.query(Test.id == test_to_get).fetch(1)[0]
            except IndexError:
                self.logger.debug("Invalid Test ID")
                self.redirect('/')
            else:
                if user:
                    template_values = add_entity_to_template(
                        template_values,
                        Entity.query(Entity.id == user.user_id()).fetch(1)[0])
                    user_level = get_user_group_level(
                        get_grouped_marks(user.user_id()), test.group)
                    if user_level == None:
                        user_level = 1

                    template_values['user_level'] = user_level
                    if user_level < test.level:
                        template_values['locked'] = True
                    try:
                        mark_query = Mark.query(
                            ancestor=ndb.Key("Entity", user.user_id()))
                        mark = mark_query.filter(
                            Mark.test.id == test.id).fetch(1)[0]
                        template_values = add_mark_to_template(
                            template_values, mark)
                        if (datetime.datetime.now() - mark.modified
                            ) < datetime.timedelta(hours=24) or mark.complete:
                            template_values['locked'] = True
                    except IndexError:
                        self.logger.debug("No mark found")
                        template_values = add_test_to_template(
                            template_values, test)
                    finally:
                        if test.author_id == user.user_id():
                            template_values['is_test_marker'] = True
                            template_values['locked'] = True
                            test_marker = Entity.query(
                                Entity.id == user.user_id()).get()
                            template_values['to_be_marked'] = get_to_be_marked(
                                test_marker, test)
                            template_values['name'] = test_marker.display_name
                            template_values['current_user'] = user.user_id()
                else:
                    template_values['locked'] = True
                    template_values['visitor'] = True
                    logging.warning("User not found!")
                    template_values = add_test_to_template(
                        template_values, test)

            finally:

                path = os.path.join(
                    os.path.dirname(__file__),
                    os.path.join(template_dir, 'test_detail.html'))
                self.response.out.write(template.render(path, template_values))
        return