def registration_controller(request): errors = {} is_valid = True data = request.get('data') if not 'password' in data: errors.update({'password': '******'}) is_valid = False if not 'login' in data: errors.update({'login': '******'}) is_valid = False if not is_valid: return make_response(request, 400, {'errors': errors}) # сокрытие пароля для хранения на сервере hmac_obj = hmac.new(SECRET_KEY.encode(), data.get('password').encode()) password_digest = hmac_obj.digest() with session_scope() as db_session: user = User(name=data.get('login'), password=password_digest) db_session.add(user) token = login(request, user) return make_response(request, 200, {'token': token})
def list_users_chat(request): data = get_json(request) if data is None: return make_response(400, 'Bad request', 'json is not valid') conn = connect() cursor = conn.cursor() if len( cursor.execute("SELECT id from users WHERE id = (?)", (data['user'], )).fetchall()) != 1: return make_response(400, 'Bad request', 'user is not exist') cursor.execute( """ SELECT chat.* FROM chat JOIN ( SELECT messages.chat, MAX(created_at) FROM messages JOIN (SELECT chat, user FROM user_chat WHERE user = (?)) as u_c ON u_c.chat = messages.chat GROUP BY messages.chat ORDER BY -created_at ) as mes ON mes.chat = chat.id """, (data['user'], )) descriptions = list(zip(*cursor.description))[0] res = [dict(zip(descriptions, row)) for row in cursor.fetchall()] return make_response(200, 'OK', json.dumps(res))
def handle_default_request(raw_request): request = json.loads(raw_request.decode()) if validate_request(request): action_name = request.get('action') controller = resolve(action_name) if controller: try: logging.debug( 'controller: {} resolved with request: {}'.format( action_name, request)) response = controller(request) except Exception as err: logging.critical('controller: {} error: {}'.format( action_name, err)) response = make_response(request, 500, 'internal server error') else: logging.error('controller: {} not found'.format(action_name)) response = make_response( request, 404, 'action with name {} not supported'.format(action_name)) else: logging.error('controller wrong request: {}'.format(request)) response = make_response(request, 400, 'wrong request format') return json.dumps(response).encode()
def login_controller(request): errors = {} is_valid = True data = eval(request.get('data')) if not 'time' in request: errors.update({'time': 'Attribute is required'}) is_valid = False if not 'password' in data: errors.update({'password': '******'}) is_valid = False if not 'login' in data: errors.update({'login': '******'}) is_valid = False if not is_valid: return make_response(request, 400, {'errors': errors}) user = authenticate(data.get('login'), data.get('password')) if user: token = login(request, user) return make_response(request, 200, {'token': token}) return make_response(request, 400, 'Enter correct login or password')
def handle_default_request(raw_request): # в строку потом в словарь request = json.loads(raw_request.decode()) # проходим валидацию if validate_request(request): action_name = request.get('action') # извлекаем контроллер controller = resolve(action_name) # if action == 'echo': if controller: try: ''' фиксируем debug ''' logging.debug( f'Controller {action_name} resolved with request: {request}' ) response = controller(request) except Exception as err: ''' фикусируем критическую ситуацию ''' logging.critical(f'Controller {action_name} error: {err}') response = make_response(request, 500, 'Internal server error') else: ''' фиксируем симантические ошибки ''' logging.error(f'Controller {action_name} not found') response = make_response( request, 404, f'Action with name "{action_name}" not supported') else: ''' фиксируем симантические ошибки ''' logging.error(f'Controller wrong request: {request}') response = make_response(request, 400, 'Wrong request format!') return json.dumps(response).encode()
def create_chat(request): def is_user_exist(user_id): return len( cursor.execute("SELECT id from users WHERE id = (?)", (user_id, )).fetchall()) == 1 data = get_json(request) if data is None: return make_response(400, 'Bad request', 'json is not valid') conn = connect() cursor = conn.cursor() user_1, user_2 = data['users'][0], data['users'][1] if not (is_user_exist(user_1) and is_user_exist(user_2)): return make_response(400, 'Bad Request', 'users is not exits') chat_id = cursor.execute( "INSERT INTO chat(`name`, `created_at`) VALUES (?,?)", (data['name'], datetime.datetime.now().timestamp())).lastrowid cursor.execute("INSERT INTO user_chat(`chat`, `user`) VALUES (?,?)", (chat_id, user_1)) cursor.execute("INSERT INTO user_chat(`chat`, `user`) VALUES (?,?)", (chat_id, user_2)) conn.commit() return make_response(201, 'Creates', chat_id)
def get_messages_controller(request): errors = get_validation_errors(request, 'from_date') if errors: return make_response(request, 400, {'errors': errors}) data = request.get('data') from_date = datetime.fromtimestamp(data.get('from_date')) with session_scope() as session: try: client = session.query(ClientSession).filter_by(token=request.get('token')).first().client except AttributeError: data = 'Client not found.' return make_response(request, 404, data) else: filtered_gotten_messages = client.gotten_messages.filter(Message.created > from_date).all() messages = [ { 'text': msg.text, 'from_client': msg.from_client.name, 'to_client': msg.to_client.name, 'created': msg.created.timestamp() } for msg in filtered_gotten_messages ] data = {'messages': messages} return make_response(request, 200, data)
def add_contact_controller(request): errors = get_validation_errors(request, 'friend_name') if errors: return make_response(request, 400, {'errors': errors}) request_data = request.get('data') friend_name = request_data.get('friend_name') with session_scope() as session: client = session.query(ClientSession).filter_by(token=request.get('token')).first().client friend = session.query(Client).filter_by(name=friend_name).first() if client and friend: if client.name == friend_name: data = 'You can\'t add yourself in your own friend list.' return make_response(request, 400, data) existing_friend = client.friends.filter_by(friend_id=friend.id).first() if existing_friend: data = f'{friend.name} already in friend list.' return make_response(request, 400, data) contact = ClientContact(owner_id=client.id, friend_id=friend.id) session.add(contact) data = {'friend_id': friend.id, 'friend_name': friend.name} return make_response(request, 200, data) else: data = 'Client not found.' return make_response(request, 404, data)
def register_controller(request): errors = get_validation_errors(request, 'login', 'password') if errors: return make_response(request, 400, {'errors': errors}) data = request.get('data') client_login = data.get('login') hmac_obj = hmac.new( SECRET_KEY.encode(), data.get('password').encode(), digestmod='sha256' ) password_digest = hmac_obj.hexdigest() bytes_photo = base64.decodebytes(bytes(data.get('photo'), 'UTF-8')) client = Client( name=client_login, password=password_digest, photo=bytes_photo ) try: with session_scope() as session: session.add(client) token = login(request, client) add_client_to_active_list(request, client) return make_response(request, 200, {'token': token}) except IntegrityError: data = {'errors': f'Client with name {client_login} already exists.'} return make_response(request, 400, data)
def registration_controller(request): errors = {} is_valid = True data = request.get('data') if 'login' not in data: errors.update({'login': '******'}) is_valid = False if 'password' not in data: errors.update({'password': '******'}) is_valid = False if not is_valid: response = make_response(request, 400, errors) return response hmac_obj = hmac.new(SECRET_KEY.encode(), data.get('password').encode()) password_digest = hmac_obj.digest() with session_scope() as db_session: user = User(name=data.get('login'), password=password_digest) db_session.add(user) token = login(request, user) response = make_response(request, 200, {'token': token}) return response
def handle_default_request(raw_request): request = json.loads(raw_request.decode()) if validate_request(request): action_name = request.get('action') controller = resolve(action_name) if controller: try: # print(f'Controller {action_name} resolved with request: {request}') logging.debug( f'Controller {action_name} resolved with request: {request}' ) # rec2mongo({'level': 'debug', 'Controller': action_name, 'request': str(request), 'time': str(datetime.now())}) response = controller(request) except Exception as err: # print(f'Controller {action_name} error: {err}') logging.critical(f'Controller {action_name} error: {err}') # rec2mongo({'level': 'critical', 'Controller': action_name, 'error': str(err), 'time': str(datetime.now())}) response = make_response(request, 500, 'Internal server error') else: # print(f'Controller {action_name} not found') logging.error(f'Controller {action_name} not found') # rec2mongo({'level': 'error', 'Controller': action_name, 'error': 'Controller not found', 'time': str(datetime.now())}) response = make_response( request, 404, f'Action with name {action_name} not supported') else: # print(f'Controller wrong request: {request}') logging.error(f'Controller wrong request: {request}') # rec2mongo({'level': 'error', 'request': str(request), 'time': str(datetime.now())}) response = make_response(request, 400, 'wrong request format') return json.dumps(response).encode()
def login_controller(request): errors = {} is_valid = True data = request.get('data') if 'time' not in request: errors.update({'time': 'Attribute is required'}) is_valid = False if 'login' not in request: errors.update({'login': '******'}) is_valid = False if 'password' not in request: errors.update({'password': '******'}) is_valid = False if not is_valid: response = make_response(request, 400, errors) return response user = authenticate(data.get('login'), data.get('password')) if user: token = login(request, user) response = make_response(request, 200, {'token': token}) return response response = make_response(request, 400, 'Enter correct login and password') return response
def handle_default_request(raw_request): request = json.loads(raw_request.decode()) if validate_request(request): action_name = request.get('action') controller = resolve(action_name) if controller: try: logging.debug( f'Controller {action_name} resolved with request: {request}' ) response = controller(request) except Exception as err: logging.critical(f'Controller {action_name} error: {err}', exc_info=err) response = make_response(request, 500, 'Internal server error') else: logging.error(f'Controller {action_name} not found') response = make_response( request, 404, f'Action with name {action_name} not supported') else: logging.error(f'Controller wrong request: {request}') response = make_response(request, 400, 'wrong request format') return json.dumps(response).encode()
def handle_request(request): """ Get response by handling client request. :param (any) request: Request from client. :return (dict) : Dict with response body. """ if is_request_valid(request): action = request.get('action') controller = get_controller(action) if controller: try: response = controller(request) LOGGER.debug( f'Controller {action} resolved with response: {response}') except Exception as error: response = make_response(request, 500, 'Internal server error.') LOGGER.critical( f'Controller {action} rejected. Error: {error.__class__}: {error}' ) else: response = make_response(request, 404, f'Action "{action}" not supported.') LOGGER.error(f'Controller {action} not found.') else: response = make_response(request, 400, 'Bad request format.') LOGGER.error(f'Bad request format: {request}') global RECEIVER # TODO: Убрать global RECEIVER = get_receiver_addr_and_port(response) return response
def registration_controller(request): errors = {} is_valid = True request = get_login_pass_from_data(request) print(f'request-updated: {request}') if not 'password' in request: errors.update({'password': '******'}) is_valid = False if not 'login' in request: errors.update({'login': '******'}) is_valid = False if not is_valid: return make_response(request, 400, {'errors': errors}) hmac_obj = hmac.new(SECRET_KEY, request.get('password').encode()) password_digest = hmac_obj.digest() with session_scope() as db_session: user = User(name=request.get('login'), password=password_digest) db_session.add(user) token = login(request, user) return make_response(request, 200, {'token': token})
def handle_default_request(bytes_request): request = json.loads(bytes_request.decode()) if validate_request(request): actions_name = request.get('action') controller = resolve(actions_name) if controller: try: logging.info(f'Client send valid request {request}') response = controller(request) except Exception as err: logging.critical(f'Internal server error: {err}') response = make_response(request, 500, data='Internal server error') else: logging.error( f'Controller with action name {actions_name} does not exists') response = make_response(request, 404, 'Action not found') else: logging.error(f'Client send invalid request {request}') response = make_response(request, 400, 'Wrong request') str_response = json.dumps(response) return str_response.encode()
def handle_tcp_request(bytes_request): request = json.loads(bytes_request.decode()) if validate_request(request): action = request.get('action') controller = resolve(action) if controller: try: response = controller(request) logging.debug(f'Client send request {request}') except Exception as err: response = response = make_response( request, 500, f'Internal server error' ) logging.critical(f'Exception - {err}') else: response = response = make_response( request, 404, f'Action {action} is not supported' ) logging.error(f'Client call action with name {action}') else: response = make_response( request, 400, 'Wrong request' ) logging.error(f'Client send wrong request {request}') string_response = json.dumps(response) return string_response.encode()
def wrapper(request, *args, **kwargs): if 'token' not in request: return make_response(request, 403, 'Access denied') with session_scope() as db_session: user_session = db_session.query(Session).filter_by( token=request.get('token')).first() if not user_session or user_session.closed: return make_response(request, 403, 'Access denied') return func(request, *args, **kwargs)
def create_user(request): data = get_json(request) if data is None: return make_response(400, 'Bad request', 'json is not valid') conn = connect() cursor = conn.cursor() res_id = cursor.execute( "INSERT INTO users (`username`, `created_at`) VALUES (?,?)", (data['username'], datetime.datetime.now().timestamp())).lastrowid conn.commit() return make_response(201, 'Created', res_id)
def handle_default_request(raw_request): request = json.loads(raw_request.decode(ENCODING_NAME)) action_name = request.get('action') if validate_request(request): controller = resolve(action_name) if controller: try: response = controller(request) print('response', response) if response.get('code') != 200: logging.error(f'Request is not valid') else: logging.info( f'Function { controller.__name__ } was called') except Exception as err: logging.critical(err, exc_info=True) response = make_response( request, 500, 'Internal server error', ) else: logging.error(f'Action { action_name } does not exits') response = make_404(request) else: logging.error(f'Request is not valid') response = make_400(request) return json.dumps(response).encode(ENCODING_NAME)
def wrap(request, *args, **kwargs): user = request.get('user') user_name = user.get('account_name') if user_name: logger.warning(f'User name - {user_name}') return func(request, *args, **kwargs) return make_response(request, 403, 'Access denied.')
def test_make_response(): action_name = 'echo' user = '******' data = 'some data' code = 200 request = { 'action': action_name, 'user': user, 'time': datetime.now().timestamp(), 'data': data } expected = { 'action': action_name, 'user': user, 'time': None, 'data': data, 'code': 200 } response = make_response(request, code) assert expected.get('code') == response.get('code') assert expected.get('user') == response.get('user')
def handle_request(raw_request): request = jim.unpack(raw_request) action_name = request.get('action') if validate_request(request): controller = resolve(action_name) if controller: try: response = controller(request) if response.get('code') != 200: logging.error('Wrong request format') else: logging.info( f'Request is valid and processed by controller') except Exception as err: logging.critical(err) response = make_response(request, 500, 'Internal server error') else: logging.error(f'Action {action_name} does not exits') response = make_404(request) else: logging.error('Request is not valid') response = make_400(request) return jim.pack(response)
def add_user_controller(request): name = request.get('name') password = request.get('password') session = Session() session.add(User(name=name, password=password)) session.commit() return make_response(request, 200, f'User {name} created')
def del_user_controller(request): user_id = int(request.get('id')) session = Session() for each_user in session.query(User).filter_by(id=user_id): session.delete(each_user) session.commit() return make_response(request, 200, f'User id {user_id} deleted')
def test_data_make_response(initial_request, expected_code, expected_data, expected_time): response = make_response(initial_request, expected_code, expected_data, date=expected_time) assert response.get('data') == expected_data
def test_make_response(valid_request, data, code, assert_response): response = make_response(valid_request, code, data) for name, item in response.items(): if name != 'time': assert item == assert_response.get(name)
def delete_message_controller(request): data = request.get('data') message_id = data.get('message_id') with session_scope() as session: message = session.query(Message).filter_by(id=message_id).first() session.delete(message) return make_response(request, 200)
def get_presence(request): username = request.get('user').get('username') status = request.get('user').get('status') data = f'Пользователь: {username}. Статус: {status}' return make_response(request, 200, data)
def logout_controller(request): with session_scope() as db_session: user_session = db_session.query(Session).filter_by( token=request.get('token')).first() user_session.closed = datetime.now() response = make_response(request, 200, 'Session closed') return response