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
