def register(self, request: Request):
        ip, port = request.connection

        if isinstance(request.body, dict):
            nickname = request.body.get("nickname")

            if nickname != None:
                player = Player(ip, port, nickname)

                # Block if the gamming is running
                if self.game_running or self.last_question != None:
                    return Response(code=codes.IS_RUNNING,
                                    body="Gamming is running")

                if len(self.players) == self.max_players:
                    return Response(code=codes.FULL, body="The room is full")

                # Check if user is not already registred
                elif player in self.players:
                    return Response(code=codes.ALREADY_EXISTS,
                                    body="Already exists")

                # Add new player
                print("[*] Player Registred!", str(player))
                self.players.append(player)
                return Response(code=codes.REGISTRED, body="OK")

        # Return invalid parameters
        return Response(code=codes.INVALID_PARAMETERS, body="Invalid params")
예제 #2
0
def update(db_conn, user, card, response):
    """
    Update the card's parameters (and its parents')
    when given a response.
    """

    # TODO-3 split up into smaller methods

    if not card.has_assessment():
        return {
            'response': Response({}),
            'feedback': '',
        }

    errors = card.validate_response(response)
    if errors:
        return {'errors': errors}

    score, feedback = card.score_response(response)
    response = Response({
        'user_id': user['id'],
        'card_id': card['entity_id'],
        'unit_id': card['unit_id'],
        'response': response,
        'score': score,
    })

    card_parameters = CardParameters.get(db_conn, entity_id=card['entity_id'])
    if not card_parameters:
        card_parameters = CardParameters({
            'entity_id': card['entity_id']
        })
    previous_response = Response.get_latest(db_conn,
                                            user_id=user['id'],
                                            unit_id=card['unit_id'])

    now = time()
    time_delta = now - (int(previous_response['created'].strftime("%s"))
                        if previous_response else now)

    learned = (previous_response['learned']
               if previous_response else init_learned)
    guess_distribution = card_parameters.get_distribution('guess')
    slip_distribution = card_parameters.get_distribution('slip')

    updates = formula_update(score, time_delta,
                             learned, guess_distribution, slip_distribution)

    response['learned'] = updates['learned']
    response, errors = response.save(db_conn)
    if errors:
        return {'errors': errors, 'feedback': feedback}

    card_parameters.set_distribution('guess', updates['guess_distribution'])
    card_parameters.set_distribution('slip', updates['slip_distribution'])
    card_parameters, errors = card_parameters.save(db_conn)
    if errors:
        return {'errors': errors, 'feedback': feedback}

    return {'response': response, 'feedback': feedback}
예제 #3
0
    async def execute_head(self, request):
        file_data = self.get_file_info(request)

        if file_data == 403:  # forbidden error
            return Response(status=ALLOWED_CODES.get(403), protocol=request.protocol, connection='')
        elif file_data == 404:  # not found error
            return Response(status=ALLOWED_CODES.get(404), protocol=request.protocol, connection='')
        else:
            return Response(status=ALLOWED_CODES.get(200), protocol=request.protocol, connection='closed',
                            content_length=file_data.get('content_length'), content_type=file_data.get('content_type'))
예제 #4
0
def update(user, card, response):
    """
    Update the card's parameters (and its parents')
    when given a response.
    """

    # TODO-3 split up into smaller methods

    if not card.has_assessment():
        return {
            'response': Response({}),
            'feedback': '',
        }

    errors = card.validate_response(response)
    if errors:
        return {'errors': errors}

    score, feedback = card.score_response(response)
    response = Response({
        'user_id': user['id'],
        'card_id': card['entity_id'],
        'unit_id': card['unit_id'],
        'response': response,
        'score': score,
    })

    card_parameters = CardParameters.get(entity_id=card['entity_id'])
    previous_response = Response.get_latest(user_id=user['id'],
                                            unit_id=card['unit_id'])

    now = time()
    time_delta = now - (int(previous_response['created'].strftime("%s"))
                        if previous_response else now)

    learned = (previous_response['learned']
               if previous_response else init_learned)
    guess_distribution = card_parameters.get_distribution('guess')
    slip_distribution = card_parameters.get_distribution('slip')

    updates = formula_update(score, time_delta,
                             learned, guess_distribution, slip_distribution)

    response['learned'] = updates['learned']
    response, errors = response.save()
    if errors:
        return {'errors': errors, 'feedback': feedback}

    card_parameters.set_distribution('guess', updates['guess_distribution'])
    card_parameters.set_distribution('slip', updates['slip_distribution'])
    card_parameters, errors = card_parameters.save()
    if errors:
        return {'errors': errors, 'feedback': feedback}

    return {'response': response, 'feedback': feedback}
    def create_prospect(self, prospect):
        try:
            message = self.xstream_service.create_message(
                FunctionTypes.CREATE_PROSPECT.value, prospect=prospect)
            service_response = self.xstream_service.process_message(message)
            api_response_body = self.xstream_service.process_response(
                service_response, ResponseType.PROSPECT)
            api_response = Response(api_response_body, status_code=200)
        except Exception as e:
            print('Error: create_prospect failed - {}'.format(e))
            api_response = Response(ErrorResponses.INTERNAL_SERVER_ERROR.value,
                                    status_code=500)

        return api_response
예제 #6
0
 async def _execute_head_request(self, request: Request) -> Response:
     try:
         resource = self._build_resource(request)
     except ForbiddenError:
         return Response(status_code=StatusCodes.FORBIDDEN,
                         protocol=request.protocol)
     except NotFoundError:
         return Response(status_code=StatusCodes.NOT_FOUND,
                         protocol=request.protocol)
     return Response(status_code=StatusCodes.OK,
                     protocol=request.protocol,
                     content_length=resource.size,
                     content_type=resource.content_type.value,
                     body=b'')
예제 #7
0
    def execute_head(self, request):
        try:
            file = self.get_file_info(request)
            content_length = self.get_file_content_length(file.file_path)
            return Response(status_code=Response.OK,
                            protocol=request.protocol,
                            connection=request.connection,
                            content_type=file.content_type.value,
                            content_length=content_length)

        except (BadFilePathException, FileNotFoundError):
            return Response(status_code=Response.NOT_FOUND,
                            protocol=request.protocol,
                            connection=request.connection)
예제 #8
0
def judge(unit, user):
    """
    Given a unit and a user, pass judgement on which bucket to file it under.
    """

    response = Response.get_latest(user_id=user['id'],
                                   unit_id=unit['entity_id'])
    if response:
        learned = response['learned']
        now = time()
        time_delta = now - (int(response['created'].strftime("%s"))
                            if response else now)
        belief = calculate_belief(learned, time_delta)
    else:
        learned = 0
        belief = 0

    if learned >= max_learned:
        if belief > max_belief:
            return "done"

        if belief <= max_belief:
            return "review"

    if belief > diag_belief:
        return "learn"

    return "diagnose"
 def status(self, request: Request):
     return Response(code=codes.SUCCESS,
                     body={
                         "total": self.max_players,
                         "actual": len(self.players),
                         'running': self.running
                     })
예제 #10
0
def test_created(db_conn, responses_table):
    """
    Expect to have a created date.
    """

    response = Response({
        'user_id': 'A',
        'card_id': 'BC',
        'unit_id': 'RM',
        'response': 42,
        'score': 0.9,
        'learned': 0.9,
    })
    del response['created']  # should be set to default anywho
    response, errors = response.save(db_conn)
    assert len(errors) == 0
예제 #11
0
 async def execute_head(self, request):
     try:
         file = self.get_file_info(request)
     except ForbidenError:
         return Response(status=Response.FORBIDDEN,
                         protocol=request.protocol,
                         connection='')
     except NotFoundError:
         return Response(status=Response.NOT_FOUND,
                         protocol=request.protocol,
                         connection='')
     return Response(status=Response.OK,
                     protocol=request.protocol,
                     connection='closed',
                     content_length=file.content_length,
                     content_type=file.content_type)
예제 #12
0
def judge(db_conn, unit, user):
    """
    Given a unit and a user, pass judgement on which bucket to file it under.
    """

    response = Response.get_latest(
        db_conn,
        user_id=user['id'],
        unit_id=unit['entity_id']
    )
    if response:
        learned = response['learned']
        now = time()
        time_delta = now - (int(response['created'].strftime("%s"))
                            if response else now)
        belief = calculate_belief(learned, time_delta)
    else:
        learned = 0
        belief = 0

    if learned >= max_learned:
        if belief > max_belief:
            return "done"

        if belief <= max_belief:
            return "review"

    if belief > diag_belief:
        return "learn"

    return "diagnose"
예제 #13
0
def test_created(db_conn, responses_table):
    """
    Expect to have a created date.
    """

    response = Response({
        'user_id': 'A',
        'card_id': 'BC',
        'unit_id': 'RM',
        'response': 42,
        'score': 0.9,
        'learned': 0.9,
    })
    del response['created']  # should be set to default anywho
    response, errors = response.save()
    assert len(errors) == 0
예제 #14
0
    def register(self, request: Request):
        ip, port = request.connection
        p = Player(ip, port)

        if len(self.room.players) == self.room.max_players:
            return Response(code=codes.SUCCESS,
                            body="the game is full, await some minutes")
        elif (p in self.room.players):
            return Response(code=codes.SUCCESS,
                            body="you're already registred")

        # Add into a virtual database
        self.room.players.append(p)

        print("[*] Player Registred!", str(p))

        return Response(code=codes.SUCCESS, body="ok")
예제 #15
0
 def delete(self, cls, slug=None):
     session = self.backend.get_session()
     response = Response()
     cls_obj = getattr(sys.modules[__name__], cls)
     if inspect.isclass(cls_obj):
         try:
             if slug:
                 session.query(cls_obj).filter(cls_obj.id == slug).delete()
                 session.commit()
                 response.add_data('Deleted')
             else:
                 response.add_error_message('Missing %s id' % cls)
         except:
             response.add_error_message('Exception while fetching cards')
     else:
         response.add_error_message('No such class %s' % cls)
     self.write(response.as_dict())
예제 #16
0
 async def execute(self, request):
     if request.get_method() not in [b'GET', b'HEAD']:
         return Response(Response.METHOD_NOT_ALLOWED,
                         request.get_protocol(), request.get_connection())
     elif request.get_method() == b'HEAD':
         return await self.execute_head(request)
     else:
         return await self.execute_get(request)
예제 #17
0
    async def _execute_get_request(self, request: Request) -> Response:

        try:
            resource = self._build_resource(request)
        except ForbiddenError:
            return Response(status_code=StatusCodes.FORBIDDEN,
                            protocol=request.protocol)
        except NotFoundError:
            if request.url[-1:] == '/':
                return Response(status_code=StatusCodes.FORBIDDEN,
                                protocol=request.protocol)
            else:
                return Response(status_code=StatusCodes.NOT_FOUND,
                                protocol=request.protocol)

        try:
            body = await self._reader.read(resource.filename)
        except FileNotFoundError:
            if request.url[-1:] == '/':
                return Response(status_code=StatusCodes.FORBIDDEN,
                                protocol=request.protocol)
            else:
                return Response(status_code=StatusCodes.NOT_FOUND,
                                protocol=request.protocol)
        except NotADirectoryError:
            return Response(status_code=StatusCodes.NOT_FOUND,
                            protocol=request.protocol)

        return Response(status_code=StatusCodes.OK,
                        protocol=request.protocol,
                        content_type=resource.content_type.value,
                        content_length=resource.size,
                        body=body)
예제 #18
0
 async def execute_get(self, request):
     try:
         file = self.get_file_info(request)
         body = await self.read_file(file.filename)
         return Response(status=Response.OK,
                         protocol=request.protocol,
                         connection='closed',
                         content_type=file.content_type,
                         content_length=file.content_length,
                         body=body)
     except ForbiddenError:
         return Response(status=Response.FORBIDDEN,
                         protocol=request.protocol,
                         connection='')
     except NotFoundError:
         return Response(status=Response.NOT_FOUND,
                         protocol=request.protocol,
                         connection='')
예제 #19
0
 async def execute_get(self, request):
     try:
         file = self.get_file_info(request)
         body = await self.read_file(file.file_path, request.url)
         return Response(status_code=Response.OK,
                         protocol=request.protocol,
                         connection=request.connection,
                         content_type=file.content_type.value,
                         content_length=len(body),
                         body=body)
     except (BadFilePathException, FileNotFoundError):
         return Response(status_code=Response.NOT_FOUND,
                         protocol=request.protocol,
                         connection=request.connection)
     except ForbiddenException:
         return Response(status_code=Response.FORBIDDEN,
                         protocol=request.protocol,
                         connection=request.connection)
예제 #20
0
 async def execute(self, request):
     if request.method not in [b'GET', b'HEAD']:
         return Response(Response.METHOD_NOT_ALLOWED,
                         request.protocol,
                         connection=request.connection)
     elif request.method == b'HEAD':
         return await self.execute_head(request)
     else:
         return await self.execute_get(request)
예제 #21
0
def choose_card(user, unit):
    """
    Given a user and a unit, choose an appropriate card.
    Return a card instance.
    """

    # TODO-3 simplify this method

    unit_id = unit['entity_id']
    query = (Card.start_accepted_query()
                 .filter({'unit_id': unit_id})
                 .sample(10))  # TODO-2 index
    # TODO-3 does this belong as a model method?
    # TODO-2 is the sample value decent?
    # TODO-2 has the learner seen this card recently?

    cards = [Card(d) for d in query.run(database.db_conn)]
    if not len(cards):
        return None

    previous_response = Response.get_latest(user_id=user['id'],
                                            unit_id=unit_id)
    if previous_response:
        learned = previous_response['learned']
        # Don't allow the previous card as the next card
        cards = [
            card
            for card in cards
            if card['entity_id'] != previous_response['card_id']
        ]
    else:
        learned = init_learned

    shuffle(cards)
    assessment, nonassessment = partition(cards, lambda c: c.has_assessment())
    choose_assessment = random() < p_assessment_map[floor(learned * 10)]

    if choose_assessment:
        if not len(assessment):
            return nonassessment[0]
        for card in assessment:
            params = CardParameters.get(entity_id=card['entity_id'])
            guess = params.get_distribution('guess').get_value()
            slip = params.get_distribution('slip').get_value()
            correct = calculate_correct(guess, slip, learned)
            if 0.25 < correct < 0.75:
                return card
        return assessment[0]

    if len(nonassessment):
        return nonassessment[0]

    if len(assessment):
        return assessment[0]

    return None
예제 #22
0
 async def execute(self, request):
     if request.get_method == ALLOWED_METHODS.get('HEAD'):
         # print('Request: HEAD')
         return await self.execute_head(request)
     elif request.get_method == ALLOWED_METHODS.get('GET'):
         # print('Request: GET')
         return await self.execute_get(request)
     else:
         # print('Request: Unknown')
         return Response(ALLOWED_CODES.get(405), request.get_protocol, request.get_connection)
예제 #23
0
    async def execute(self, request: Request) -> Optional[Response]:
        if request.method not in ('GET', 'HEAD'):
            return Response(status_code=StatusCodes.NOT_ALLOWED,
                            protocol=request.protocol)

        if request.method == 'HEAD':
            return await self._execute_head_request(request=request)

        elif request.method == 'GET':
            return await self._execute_get_request(request=request)
예제 #24
0
def main():
    url = 'https://www.westerncalendar.uwo.ca/Courses.cfm?Subject=COMPSCI&SelectedCalendar=Live'
    scraper = Scraper(url)
    course_headers = scraper.get_course_headers_list()
    course_details = scraper.get_course_details_list()

    response = Response(
        transformer.generate_course_summary_list(course_headers,
                                                 course_details))
    json_response = json.dumps(vars(response),
                               default=lambda x: x.__dict__,
                               indent=4)
    print(json_response)
    def open_connection(socket, client_conn, data, router):
        request = None

        try:
            payload = json.loads(data)
            request = Request(**payload)
            request.connection = client_conn

            try:
                response = router.resolve(request)

                if response != None:
                    socket.sendto(response.encode(), client_conn)
            except Exception as e:
                print(e)
                socket.sendto(
                    Response(code=codes.INTERNAL_ERROR,
                             body="Internal error").encode(), client_conn)
        except Exception as e:
            print(e)
            socket.sendto(
                Response(code=codes.BAD_REQUEST,
                         body="Invalid request").encode(), client_conn)
예제 #26
0
 def get(self):
     session = self.backend.get_session()
     response = Response()
     try:
         username = self.get_argument('username', None, True)
         password = self.get_argument('password', None, True)
         user = session.query(User).filter(User.username == username).one()
         if user.check_password(password):
             session.query(UserToken).filter(UserToken.user_id == user.id).delete()
             token = UserToken.generate_token_for_user(user)
             session.add(token)
             session.commit()
             response.add_data(token.as_dict())
         else:
             raise NoResultFound
     except NoResultFound:
         response.add_error_message('User does not exist')
     except IntegrityError:
         response.add_error_message('Token already exists. Retry')
     except Exception:
         response.add_error_message('Exception while generating a token')
     finally:
         session.rollback()
     self.write(response.as_dict())
예제 #27
0
 def get(self):
     session = self.backend.get_session()
     response = Response()
     try:
         username = self.get_argument('username', None, True)
         password = self.get_argument('password', None, True)
         user = User.register({'username': username, 'password': password})
         session.add(user)
         session.commit()
         response.add_data(user.as_dict())
     except IntegrityError:
         response.add_error_message('Username already exists')
     except Exception:
         response.add_error_message('Exception while adding a new user')
     finally:
         session.rollback()
     self.write(response.as_dict())
예제 #28
0
 def post(self, cls, slug=None):
     session = self.backend.get_session()
     response = Response()
     cls_obj = getattr(sys.modules[__name__], cls)
     if inspect.isclass(cls_obj):
         try:
             obj = cls_obj()
             obj.update(self.request.arguments)
             session.add(obj)
             session.commit()
             response.add_data(obj.as_dict())
         except:
             session.rollback()
             response.add_error_message('Exception while fetching cards')
     else:
         response.add_error_message('No such class %s' % cls)
     self.write(response.as_dict())
예제 #29
0
파일: app.py 프로젝트: aucontraire/rel8
def new_session(user, message, response):
    sms_session = Session(user_id=user.id, interval_id=user.interval.id)
    models.storage.new(sms_session)
    models.storage.save()

    if message.strip().lower() == user.predictor.name:
        sms_response = Response(session_id=sms_session.id,
                                predictor_id=user.predictor.id,
                                user_id=user.id,
                                message=message,
                                twilio_json="{}")
        models.storage.new(sms_response)
        models.storage.save()
    else:
        response.message('This should be the predictor.')
예제 #30
0
def test_response(db_conn, responses_table):
    """
    Expect to record the user's response.
    """

    response, errors = Response.insert(db_conn, {
        'user_id': 'A',
        'card_id': 'BC',
        'unit_id': 'RM',
        'score': 0.9,
        'learned': 0.9,
    })
    assert len(errors) == 1
    response['response'] = 42
    response, errors = response.save(db_conn)
    assert len(errors) == 0
예제 #31
0
def test_unit(db_conn, responses_table):
    """
    Expect to require a unit ID.
    """

    response, errors = Response.insert(db_conn, {
        'user_id': 'A',
        'card_id': 'BC',
        'response': 42,
        'score': 0.9,
        'learned': 0.9,
    })
    assert len(errors) == 1
    response['unit_id'] = 'A24JLD'
    response, errors = response.save(db_conn)
    assert len(errors) == 0
예제 #32
0
def test_card(db_conn, responses_table):
    """
    Expect to require a card ID.
    """

    response, errors = Response.insert({
        'user_id': 'A',
        'unit_id': 'RM',
        'response': 42,
        'score': 0.9,
        'learned': 0.9,
    })
    assert len(errors) == 1
    response['card_id'] = 'AFJ'
    response, errors = response.save()
    assert len(errors) == 0
예제 #33
0
def test_unit(db_conn, responses_table):
    """
    Expect to require a unit ID.
    """

    response, errors = Response.insert({
        'user_id': 'A',
        'card_id': 'BC',
        'response': 42,
        'score': 0.9,
        'learned': 0.9,
    })
    assert len(errors) == 1
    response['unit_id'] = 'A24JLD'
    response, errors = response.save()
    assert len(errors) == 0
예제 #34
0
def test_response(db_conn, responses_table):
    """
    Expect to record the user's response.
    """

    response, errors = Response.insert({
        'user_id': 'A',
        'card_id': 'BC',
        'unit_id': 'RM',
        'score': 0.9,
        'learned': 0.9,
    })
    assert len(errors) == 1
    response['response'] = 42
    response, errors = response.save()
    assert len(errors) == 0
def handler(event, context):
    prospect = json.loads(event['body'])
    print(event)

    # todo move jwt functionality into a service class to keep things dry
    try:
        # todo make jwt secret an env var
        jwt.decode(event['headers']['Authorization'], 'paigeleah1')
    except Exception as e:
        print('Error: jwt did not decode correctly - {}'.format(e))
        # todo refactor Response, it ain't pretty atm
        return Response(ErrorResponses.NOT_AUTHORIZED.value,
                        status_code=401).to_json()

    prospect_service = ProspectService()
    api_response = prospect_service.create_prospect(prospect)

    return api_response.to_json()
예제 #36
0
def test_get_latest(db_conn, responses_table):
    """
    Expect to get the latest response by user and unit.
    """

    responses_table.insert([{
        'id': 'A',
        'user_id': 'abcd1234',
        'unit_id': 'apple',
        'created': r.now(),
        'modified': r.now(),
    }, {
        'id': 'B',
        'user_id': 'abcd1234',
        'unit_id': 'banana',
        'created': r.now(),
        'modified': r.now(),
    }]).run(db_conn)

    assert Response.get_latest(db_conn, 'abcd1234', 'apple')['id'] == 'A'
예제 #37
0
def test_get_latest(db_conn, responses_table):
    """
    Expect to get the latest response by user and unit.
    """

    responses_table.insert([{
        'id': 'A',
        'user_id': 'abcd1234',
        'unit_id': 'apple',
        'created': r.now(),
        'modified': r.now(),
    }, {
        'id': 'B',
        'user_id': 'abcd1234',
        'unit_id': 'banana',
        'created': r.now(),
        'modified': r.now(),
    }]).run(db_conn)

    assert Response.get_latest('abcd1234', 'apple')['id'] == 'A'
예제 #38
0
def test_score(db_conn, responses_table):
    """
    Expect to have a score between 0 and 1 (including).
    """

    response, errors = Response.insert(db_conn, {
        'user_id': 'A',
        'card_id': 'BC',
        'unit_id': 'RM',
        'response': 42,
        'learned': 0.9,
    })
    assert len(errors) == 1
    response['score'] = 1.1
    response, errors = response.save(db_conn)
    assert len(errors) == 1
    response['score'] = 0
    response, errors = response.save(db_conn)
    assert len(errors) == 0
    response['score'] = 1
    response, errors = response.save(db_conn)
    assert len(errors) == 0
예제 #39
0
def test_score(db_conn, responses_table):
    """
    Expect to have a score between 0 and 1 (including).
    """

    response, errors = Response.insert({
        'user_id': 'A',
        'card_id': 'BC',
        'unit_id': 'RM',
        'response': 42,
        'learned': 0.9,
    })
    assert len(errors) == 1
    response['score'] = 1.1
    response, errors = response.save()
    assert len(errors) == 1
    response['score'] = 0
    response, errors = response.save()
    assert len(errors) == 0
    response['score'] = 1
    response, errors = response.save()
    assert len(errors) == 0
    def answer(self, request: Request):
        ip, port = request.connection
        p = Player(ip, port, "")
        result = [player for player in self.players if p == player]

        if len(result) == 0:
            return Response(code=codes.NOT_ALLOWED,
                            body="You aren't in this room")

        elif not self.running and self.last_question == None:
            return Response(code=codes.NOT_RUNNING,
                            body="Game ins't started yet")

        elif self.round_hit:
            return Response(code=codes.ALREADY_EXISTS,
                            body="Someone alrady won")

        player = result[0]
        for ans in self.last_question.answers:
            if ans.player == player:
                return Response(code=codes.ALREADY_EXISTS,
                                body="You already answered")

        if isinstance(request.body, dict):
            answer_obj = request.body.get("answer")

            if answer_obj:
                # Add new answer in actual question
                self.last_question.answers.append(
                    Answer(player, answer_obj,
                           answer_obj == self.last_question.correct_code))

                if answer_obj == self.last_question.correct_code:
                    self.round_hit = True

                return Response(code=codes.SUCCESS, body="OK")

        # Return invalid parameters
        return Response(code=codes.INVALID_PARAMETERS, body="Invalid params")
예제 #41
0
 def put(self, cls, slug=None):
     session = self.backend.get_session()
     response = Response()
     cls_obj = getattr(sys.modules[__name__], cls)
     if inspect.isclass(cls_obj):
         try:
             if slug:
                 obj = session.query(cls_obj).filter(cls_obj.id == slug).one()
                 obj.update(self.request.arguments)
                 session.add(obj)
                 session.commit()
                 response.add_data(obj.as_dict())
             else:
                 response.add_error_message('Missing %s id' % cls)
         except NoResultFound:
             response.add_error_message('Missing %s' % cls)
         except:
             response.add_error_message('Exception while fetching %s' % cls)
         finally:
             session.rollback()
     else:
         response.add_error_message('No such class %s' % cls)
     self.write(response.as_dict())
예제 #42
0
 def get(self, cls, slug=None):
     session = self.backend.get_session()
     response = Response()
     cls_obj = getattr(sys.modules[__name__], cls)
     if inspect.isclass(cls_obj):
         try:
             objs = session.query(cls_obj)
             if slug:
                 obj = objs.filter(cls_obj.id == slug).one()
                 response.add_data(obj.as_dict())
             else:
                 response.add_data([obj.as_dict() for obj in objs])
         except NoResultFound:
             response.add_error_message('No such %s' % cls)
         except:
             response.add_error_message('Exception while fetching %s' % cls)
     else:
         response.add_error_message('No such class %s' % cls)
     self.write(response.as_dict())
예제 #43
0
 def resolve(self, request) -> Response:
     for route in self.routes:
         if route.route == request.route and request.method in route.methods:
             return route.callback(request)
     
     return Response(code=codes.NOT_FOUND, body=f"Not found {request.route}")
예제 #44
0
파일: app.py 프로젝트: aucontraire/rel8
def sms():
    session, counter, consent, name_req = get_session()
    response = MessagingResponse()
    phone_number = request.form['From']
    message = request.form['Body']
    user = find_user_by_phone(phone_number)
    if user:
        if not user.predictor and not user.outcome:
            response.message(
                "Hi {}. You need to set up your variables first: {}".format(
                    user.username, SITE_URL))
        elif message.strip().lower() != user.predictor.name and message.strip(
        ).lower() != user.outcome.name:
            response.message('That does not match your variables. Try again.')
        else:
            user.sessions.sort(key=lambda sess: sess.updated_at, reverse=True)
            if message.strip().lower() == user.predictor.name:
                if len(user.sessions
                       ) == 0 or user.sessions[0].complete is True:
                    new_session(user, message, response)
                elif user.sessions[0].complete is False:
                    if session_expired(user.sessions[0].created_at,
                                       user.sessions[0].interval.duration):
                        user.sessions[0].complete = True
                        new_session(user, message, response)
                    else:
                        response.message(
                            'We were expecting outcome: {}'.format(
                                user.outcome.name))
            elif message.strip().lower() == user.outcome.name:
                if len(user.sessions
                       ) == 0 or user.sessions[0].complete is True:
                    response.message('We were expecting predictor: {}'.format(
                        user.predictor.name))
                elif user.sessions[0].complete is False:
                    if session_expired(user.sessions[0].created_at,
                                       user.sessions[0].interval.duration):
                        user.sessions[0].complete = True
                        response.message(
                            'We were expecting predictor: {}'.format(
                                user.predictor.name))
                    else:
                        sms_response = Response(session_id=user.sessions[0].id,
                                                outcome_id=user.outcome.id,
                                                user_id=user.id,
                                                message=message,
                                                twilio_json="{}")
                        models.storage.new(sms_response)
                        user.sessions[0].complete = True
                        models.storage.save()
    elif consent is True and name_req is True:
        access_code = binascii.hexlify(os.urandom(8)).decode()
        session['access-code'] = access_code
        user = User()
        user.username = message.strip()
        user.phone_number = phone_number
        user.access_code = access_code
        models.storage.new(user)
        models.storage.save()
        session['user-id'] = user.id
        response.message(
            "Welcome {}! Please go to: {}/register/?access-code={}".format(
                user.username, SITE_URL, access_code))
    elif consent is True and name_req is False:
        session['name_req'] = True
        if message.strip().lower() == 'yes':
            session['consent'] = True
            response.message("What's your name?")
        elif message.strip().lower() == 'no':
            response.message("Sorry to hear that. Bye.")
    else:
        response.message("Would you like to enroll in rel8? [Yes, No]")
        session['consent'] = True

    return str(response)