예제 #1
0
 def validate(self, data):
     '''
     Data validation
     :param data: data from post/put request
     :return: clean data
     '''
     # move fields from orgExtra to data and rename fieldname from camelCase
     # to underscore
     for key, value in data['orgExtra'].items():
         data[re.sub('([A-Z]+)', r'_\1', key).lower()] = value
     try:
         course_org, course_id, course_run = Exam.get_course_data(
                 data['course_id'])
     except ValueError as e:
         raise serializers.ValidationError("Wrong courseId data")
     data['course_organization'] = course_org
     data['course_identify'] = "/".join((course_org, course_id))
     data['course_run'] = "/".join((course_org, course_id, course_run))
     data['exam_end_date'] = parser.parse(data['exam_end_date'])
     data['exam_start_date'] = parser.parse(data['exam_start_date'])
     del (data['orgExtra'])
     try:
         Exam(**data).full_clean()
     except ValidationError as e:
         raise serializers.ValidationError(e.message_dict)
     return super(ExamSerializer, self).validate(data)
예제 #2
0
def add_exam():
    if current_identity.is_superuser:
        data = request.get_json()
        exam = Exam(data['subject_id'], data['exam_period_id'], data['date'])
        exam.save()
        return custom_response({'message': 'Successfully created'}, 201)
    else:
        return custom_response({'error': 'Unauthorized'}, 403)
예제 #3
0
def get_metadata(request, ef_id):
    """returns the metadata for a file"""
    ef = get_object_or_404(ExamFile, id=ef_id)
    try:
        e = Exam.objects.get(file=ef)
    except Exam.DoesNotExist:
        e = Exam()
    return HttpResponse(content=cjson.encode(e.serialize()),
        mimetype="application/json")
예제 #4
0
def createNewExam(examName, groupName):
    groupObject = Group.objects.get(group_name=groupName)
    try:
        examObject = Exam.objects.get(group=groupObject, exam_name=examName)
        return False
    except Exam.DoesNotExist:
        examObject = Exam(group=groupObject, exam_name=examName)
        examObject.save()
        return True
예제 #5
0
def create_exam(user_id: UUID, user_role: Role, exam: schemas.Exam):
    is_authorized(user_role, "create_exam")

    exam_data = dict(name=exam.name, user=User[user_id])
    if exam.video_tutorial_name:
        exam_data["video_tutorial_name"] = exam.video_tutorial_name

    return Exam(**exam_data)
예제 #6
0
    def post(self, request):
        """
        Create exam record in database
        :param request: Key value pair data
        :return: status & respective message
        """

        data = request.data

        if "college_ids" in data:
            college_ids = data["college_ids"]
            data.pop("college_ids")

        # Assuming field_id is mandatory as of now
        try:
            exam = Exam(**data)
            exam.save()
            LOGGER.info("exam created successfully")
        except Exception, error:
            LOGGER.error("Error:%s", str(error))
            return Response({"status": "FAILED", "message": str(error)})
예제 #7
0
    def _get_old_in_time_exam(self):
        now = datetime.datetime.now()
        before_now_5min = now - datetime.timedelta(minutes=5)
        before_now_1day = now - datetime.timedelta(days=1)
        query1 = Exam.select(lambda x: x.created_at <= before_now_5min and
                             (x.mistake > 0 or x.appear_count == 1))
        before_now_2day = now - datetime.timedelta(days=2)
        query2 = Exam.select(lambda x: before_now_2day <= x.created_at and x.
                             created_at <= before_now_1day and
                             (x.mistake > 0 or x.appear_count <= 2))
        before_now_4day = now - datetime.timedelta(days=4)
        query3 = Exam.select(lambda x: before_now_4day <= x.created_at and x.
                             created_at <= before_now_2day and
                             (x.mistake > 0 or x.appear_count <= 3))
        before_now_7day = now - datetime.timedelta(days=7)
        query4 = Exam.select(lambda x: before_now_7day <= x.created_at and x.
                             created_at <= before_now_4day and
                             (x.mistake > 0 or x.appear_count <= 4))
        before_now_15day = now - datetime.timedelta(days=15)
        query5 = Exam.select(lambda x: before_now_15day <= x.created_at and x.
                             created_at <= before_now_7day and
                             (x.mistake > 0 or x.appear_count <= 5))

        query6 = Exam.select(lambda x: before_now_15day > x.created_at and
                             (x.mistake > 0 or x.appear_count <= 6))
        query = query1 or query2 or query3 or query4 or query5 or query6
        if query.count():
            exam = self._get_query_random(query)
            exam.appear_count += 1
            if exam.mistake:
                exam.mistake -= 1
            commit()
            return exam
예제 #8
0
    def get_exam(self):
        exam = self._get_old_in_time_exam()
        if exam:
            return self.exam_to_dict(exam)
        ids_query = select(el.explain.id for el in Exam)
        while True:
            try:
                query = Explain.select(lambda x: x.id not in ids_query)
                explain = self._get_query_random(query)
                sentence = self._get_query_random(
                    Sentence.select(lambda x: x.explain == explain))
                exam_query = Exam.select(lambda x: x.sentence == sentence)
                if exam_query.count():
                    exam = exam_query.first()
                    exam.appear_cout += 1
                else:

                    exam = Exam(word=explain.word,
                                explain=explain,
                                sentence=sentence)
                return self.exam_to_dict(exam)
            except Exception:
                pass
예제 #9
0
파일: exam.py 프로젝트: a88877689/Poliquizz
 def post(self, current_user: User):
     json = request.get_json(force=True)
     data, errors = exam_schema.load(json)
     if errors:
         return errors, 422
     exam = Exam.query.filter_by(name=data['name']).first()
     if exam:
         return {'message': f'Exam name "{exam.name}" already exists'}, 400
     data['date'] = datetime.now().strftime('%b %d, %Y')
     exam = Exam(data)
     db.session.add(exam)
     db.session.commit()
     exam = exam_schema.dump(exam).data
     return {'message': 'Exam succesfully created', 'exam': exam}, 201
예제 #10
0
def get_exam_performance(user_role: Role, exam_id: str):
    is_authorized(user_role, "get_exam_performance")

    exam = Exam.get(id=exam_id)
    if not exam:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,
                            detail="Exam not found : id: {}".format(exam_id))

    results = select(p for p in Performance if p.exam == exam)[:]

    performance = []
    for result in results:
        performance.append(result.to_dict())

    return performance
예제 #11
0
파일: load.py 프로젝트: jokull/namsbrautir
def get_or_create_exam(db, items):
    exam = db.query(Exam).get(items['_id'])
    if exam is None:
        exam = Exam(id=items['_id'],
                    **{
                        k: v
                        for k, v in items.items() if k in (
                            "title",
                            "level",
                            "maximum_credits",
                            "minimum_credits",
                            "number",
                        )
                    })
        db.add(exam)
        db.commit()
    return exam
예제 #12
0
def add_participant(user_id: UUID, user_role: Role,
                    participant: schemas.Participant):
    is_authorized(user_role, "add_participant")

    exam_id = participant.exam_id
    learner_id = participant.user_id

    exam = Exam.get(id=exam_id, user=User[user_id])
    if not exam:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,
                            detail="Exam not found : id: {}".format(exam_id))

    learner = User.get(id=learner_id, role=Role.learner)
    if not learner:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Learner not found : id: {}".format(learner_id))

    participant = Participant(exam=exam, user=learner)

    return participant.to_dict()
예제 #13
0
def create_question(user_id: UUID, user_role: Role,
                    question_in: schemas.Question):
    is_authorized(user_role, "create_question")

    exam = Exam.get(id=question_in.exam_id)
    if not exam:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,
                            detail="Exam not found : id: {}".format(
                                question_in.exam_id))

    question = dict(text=question_in.text, marks=question_in.marks, exam=exam)

    if question_in.multi_choice:
        question["multi_choice"] = question_in.multi_choice

    if question_in.answer:
        question["answer"] = question_in.answer

    counter = select(max(q.number) for q in Question if q.exam == exam)[:][0]
    if not counter:
        counter = 0
    question["number"] = counter + 1

    return Question(**question).to_dict()
from datetime import datetime, timedelta
import logging

from models import Exam, Assignment
from FCM import sendNotification
from apiMethods import createNotification

logging.basicConfig(level=logging.DEBUG)
LOG = logging.getLogger(__name__)
date = (datetime.now() + timedelta(days=7))
date = date.strftime('%d-%m-%Y')
LOG.info(date)
examList = Exam.query(Exam.dueDate == date).fetch()
LOG.info(str(examList))
assignmentList = Assignment.query(Assignment.dueDate == date).fetch()
for exam in examList:
    LOG.info(str(exam))
    sendNotification(exam.courseId.urlsafe(),
                     exam.key.urlsafe(), 'exam',
                     'Warning!!! Exam ahead',
                     'There is a exam next week')
    course = exam.courseId.get()
    title = course.courseName
    notificationText = 'There is a exam next week'
    createNotification(course.studentIds, title,
                       notificationText, 'exam',
                       exam.key.urlsafe(), course.key.urlsafe())

for assignment in assignmentList:
    LOG.info(str(assignment))
    sendNotification(assignment.courseId.urlsafe(),
예제 #15
0
def exam(update, context):
    reply = update.message.reply_text("¿De qué asignatura es el examen?")
    context.user_data['messages'] = [reply]
    context.user_data['event'] = Exam()
    return SUBJECT
예제 #16
0
def exam():

  if(request.method == 'GET'):
    exams=Exam.query.all()
    exams_dict={}
    i = 0
    for e in exams:
      exams_dict[str(i)] = str(e)
      i=i+1
    print exams
    return jsonify(exams = exams_dict)
    #return "exams GET"

  else:
    if("firstName" in request.form and request.form["firstName"]):
      fn = request.form["firstName"]
      print fn
    else:
      fn = "Place"
    if("lastName" in request.form and request.form["lastName"]):
      ln = request.form["lastName"]
    else:
      ln = "Holder"
    if("exam_uuid" in request.form):
      exam_uuid = request.form["exam_uuid"]
    else:
      print "PROBLEM WITH EXAM UUID"
      exam_uuid = "666"
    if("date" in request.form):      
      date = request.form["date"]
      print date
    else:
      date = "2000-01-01 11:11:11"
    
    try:
      if("phoneNumber" in request.form and request.form["phoneNumber"]):      
        phoneNumber = request.form["phoneNumber"]
        print phoneNumber
        phoneNumber = re.sub(r'[^\w]','',phoneNumber)
        #phoneNumber = phoneNumber.translate(None,'()-')
        print phoneNumber
      else:
        phoneNumber = "4085291354"
        print phoneNumber
    except:
      print "Exception in PHONE NUMBER"
      print '-'*60
      #print traceback.print_exc(file=sys.stdout)
      print traceback.print_exc()
      print '-'*60

    d = datetime.strptime(date, "%Y-%m-%d %H:%M:%S")
    print d
    yyyymmddHHMM = d.strftime("%Y-%m-%d-%H-%M")
    print yyyymmddHHMM
    bucketName = (yyyymmddHHMM+"-"+exam_uuid).lower()
    print "BucketName " + bucketName

    val = doesBucketExist(s3connection,bucketName)
    if val is False:
      print "about to create bucket"
      createBucket(s3connection,bucketName)
      #include bucketName in Exam model
      exam = Exam.query.filter(Exam.uuid== exam_uuid).first()  
      if not exam:
        exam = Exam(firstName=fn,lastName=ln,uuid=exam_uuid,bucket=bucketName, exam_date=d, phoneNumber = phoneNumber)
        db.session.add(exam)
        db.session.commit()
        try:
          examUploadConfirmation(exam_uuid,phoneNumber)
        except:
          print '-'*60
          print "SOMETHING WRONG WITH TWILIO"
          print traceback.print_exc()
          print '-'*60
        return jsonify(status="Exam Created")
      else:
        return jsonify(status="Exam was a duplicate and was not saved")
    else:
      return jsonify(status="Exam Bucket Already Created")  
예제 #17
0
    def test_exam_endpoints(self):
        user = rand.user()
        course = Course(name='World Lit')
        section1 = Section(name='Hour 1')
        section2 = Section(name='Hour 2')
        course.sections = [section1, section2]
        exam1 = Exam(name='Exam 1', exam_format='DDD..EEDD')
        exam2 = Exam(name='Exam 2', exam_format='..FFFFFFFFFFFF')
        course.exams = [exam1, exam2]
        user.courses.append(course)
        db.session.add(course)
        db.session.add_all([user, section1, section2, exam1, exam2])
        db.session.commit()
        db.session.refresh(course)
        db.session.refresh(exam1)

        ##############################################
        # Verify that we have two exams in this course
        exams_list_response = self.client.get(
            '/api/course/{course_id}/exams'.format(course_id=course.id),
            headers={'Authorization': 'Bearer {}'.format(jwt_token)})
        self.assertEqual(exams_list_response.status_code, HTTPStatus.OK)
        exam_list_data = json.loads(exams_list_response.data.decode())
        self.assertEqual(len(exam_list_data['exams']), 2)

        ###############################################
        # Verify that a specific exam has the correct name and format
        self.assertIn('Exam 1',
                      [exam['name'] for exam in exam_list_data['exams']])
        self.assertNotIn('Exam Foo',
                         [exam['name'] for exam in exam_list_data['exams']])
        self.assertIn(
            'DDD..EEDD',
            [exam['exam_format'] for exam in exam_list_data['exams']])

        ###############################################
        # Add an Exam
        new_exam = Exam(name='Exam 3', exam_format='DDDDD')
        new_exam_request_response = self.client.post(
            '/api/course/{course_id}/exam/add'.format(course_id=course.id),
            data=json.dumps(new_exam.toJSON()),
            content_type='application/json',
            headers={'Authorization': 'Bearer {}'.format(jwt_token)})
        self.assertEqual(new_exam_request_response.status_code, HTTPStatus.OK)
        exams_list_response = self.client.get(
            '/api/course/{course_id}/exams'.format(course_id=course.id),
            headers={'Authorization': 'Bearer {}'.format(jwt_token)})
        exam_list_data = json.loads(exams_list_response.data.decode())
        # we now have 3 exams
        self.assertEqual(len(exam_list_data['exams']), 3)
        new_exam_id = json.loads(
            new_exam_request_response.data.decode())['exam']['id']

        ###############################################
        # Edit an exam
        update_exam_response = self.client.post(
            '/api/course/{course_id}/exam/{exam_id}/update'.format(
                course_id=course.id, exam_id=new_exam_id),
            data=json.dumps({
                'name': 'Exam 4',
                'exam_format': 'CCC'
            }),
            content_type='application/json',
            headers={'Authorization': 'Bearer {}'.format(jwt_token)})
        self.assertEqual(update_exam_response.status_code, HTTPStatus.OK)
        update_exam_response_data = json.loads(
            update_exam_response.data.decode())
        self.assertEqual('CCC',
                         update_exam_response_data['exam']['exam_format'])
        self.assertEqual('Exam 4', update_exam_response_data['exam']['name'])

        ###############################################
        # Delete an Exam
        delete_exam_response = self.client.delete(
            '/api/course/{course_id}/exam/{exam_id}'.format(
                course_id=course.id, exam_id=new_exam_id),
            headers={'Authorization': 'Bearer {}'.format(jwt_token)})
        exams_list_response = self.client.get(
            '/api/course/{course_id}/exams'.format(course_id=course.id),
            headers={'Authorization': 'Bearer {}'.format(jwt_token)})
        exam_list_data = json.loads(exams_list_response.data.decode())
        # we should be back to two exams
        self.assertEqual(len(exam_list_data['exams']), 2)

        ###############################################
        ###############################################
        # Create three student exams
        for answers in ['DDDTTEEDD', 'ABCTFDEAC', 'DCBFFEAAA']:
            create_student_exam_response = self.client.post(
                '/api/course/{course_id}/exam/{exam_id}/student_exam'.format(
                    course_id=course.id, exam_id=exam1.id),
                data=json.dumps({'answers': answers}),
                content_type='application/json',
                headers={'Authorization': 'Bearer {}'.format(jwt_token)})
        exam1 = Exam.query.get(
            exam1.id
        )  # 'db.session.refresh' doesn't work here, as we're on to a different db session
        self.assertEqual(len(exam1.student_exams), 3)
        exam_response = self.client.get(
            '/api/course/{course_id}/exam/{exam_id}'.format(
                course_id=course.id, exam_id=exam1.id),
            headers={'Authorization': 'Bearer {}'.format(jwt_token)})
        exam_response_data = json.loads(exam_response.data.decode())
        self.assertEqual(len(exam_response_data['exam']['student_exams']), 3)

        ###############################################
        # Update one of those student exams
        student_exam_id = exam_response_data['exam']['student_exams'][0]['id']
        self.client.post(
            '/api/course/{course_id}/exam/{exam_id}/student_exam/{student_exam_id}'
            .format(course_id=course.id,
                    exam_id=exam1.id,
                    student_exam_id=student_exam_id),
            data=json.dumps({'answers': 'AAAFFAAAA'}),
            content_type='application/json',
            headers={'Authorization': 'Bearer {}'.format(jwt_token)})
        student_exam = StudentExam.query.get(student_exam_id)
        self.assertEqual(student_exam.answers, 'AAAFFAAAA')

        ###############################################
        # Delete a student exam
        delete_student_exam_response = self.client.delete(
            '/api/course/{course_id}/exam/{exam_id}/student_exam/{student_exam_id}'
            .format(course_id=course.id,
                    exam_id=exam1.id,
                    student_exam_id=student_exam_id),
            content_type='application/json',
            headers={'Authorization': 'Bearer {}'.format(jwt_token)})
        exam1 = Exam.query.get(exam1.id)
        self.assertEqual(len(exam1.student_exams), 2)
예제 #18
0
def post_metadata(request, ef_id):
    ef = get_object_or_404(ExamFile, id=ef_id)
    try:
        e = Exam.objects.get(file=ef)
    except Exam.DoesNotExist:
        e = Exam()
        e.file = ef
    e.professor, c = Professor.objects.get_or_create(name=request.POST['professor'])
    e.subject, c = Subject.objects.get_or_create(name=request.POST['subject'])
    e.degree, c = Degree.objects.get_or_create(name=request.POST['degree'])
    try:
        e.year = int(request.POST['year'])
    except ValueError:
        r = HttpResponse("invalid year")
        r.status_code = 405
        return r
    e.hws = True if request.POST['hws'] == "true" else False 
    e.solution = True if request.POST['solution'] == "true" else False 
    e.note = request.POST['note'] 
    e.save()
    return HttpResponse("OK")
예제 #19
0
 def increase_mistake(self, exam_id):
     exam = Exam.get(id=exam_id)
     exam.mistake += 1
     commit()
     return exam