def update_messages_stats(session: DBSession,
*,
user_id: int = None,
login: str = None,
role: str,
context: Context) -> DBUser:
db_user = None
if user_id is not None:
db_user = session.get_user_by_id(user_id)
elif login is not None:
db_user = session.get_user_by_login(login)
# to pretend data race
while context.is_locked:
time.sleep(0.05)
context.lock()
if role == 'sender':
db_user.sent_messages += 1
else:
db_user.received_messages += 1
context.unlock()
return db_user
async def method_patch(self, request: Request, body: dict,
session: DBSession, message_id: int, token: dict,
*args, **kwargs) -> BaseHTTPResponse:
"""
Редактирование сообщения по его id
"""
if token.get('user_id') != message_queries.check_user_by_message_id(
session, message_id=message_id).sender_id:
return await self.make_response_json(status=403)
request_model = RequestPatchMessageDto(body)
try:
db_message = message_queries.patch_message(session,
request_model,
message_id=message_id)
except DBMessageNotExistsException:
raise SanicMessageNotFound('Message not found')
try:
session.commit_session()
except (DBDataException, DBIntegrityException) as e:
raise SanicDBException(str(e))
response_model = ResponseMessageDto(db_message)
return await self.make_response_json(body=response_model.dump(),
status=201)
async def method_delete(
self,
request: Request,
body: dict,
session: DBSession,
message_id: int,
token: dict,
*args,
**kwargs,
) -> BaseHTTPResponse:
"""
Delete message by id
:param request:
:param body:
:param session:
:param message_id:
:param token:
:param args:
:param kwargs:
:return:
"""
try:
db_message = delete_message(session, message_id=message_id)
except DBMessageNotExists as e:
raise NotFound(f"Message {message_id} not found") from e
if token["sub"] not in (db_message.sender_id, db_message.recipient_id):
raise Forbidden("user is not recipient or sender")
try:
session.commit_session()
except (DBDataException, DBIntegrityException) as e:
raise SanicDBException(str(e))
return await self.make_response_json(status=204)
async def method_patch(self, request: Request, body: dict,
session: DBSession, user_id: int, token: dict,
*args, **kwargs) -> BaseHTTPResponse:
# проверяем, что пользователь посылает запрос от своего имени
if token['id'] != user_id:
return await self.make_response_json(status=403)
request_model = RequestPatchUserPasswordDto(body)
try:
hashed_password = generate_hash(request_model.password)
except GeneratePasswordHashException as error:
raise SanicPasswordHashException(str(error))
# проверка, что пользователь не удален
try:
db_user = user_queries.change_password(session, hashed_password,
user_id)
except DBUserDeletedException:
raise SanicUserDeletedException('User deleted')
# проверяем, что secret_word валидный и совпадает с тем, который находится в БД
try:
check_hash(request_model.secret_word, db_user.secret_word)
except CheckPasswordHashException:
raise SanicSecretWordHashException('Error')
try:
session.commit_session()
except (DBIntegrityException, DBDataException) as error:
raise SanicDBException(str(error))
return await self.make_response_json(status=200)
async def method_post(
self, request: Request, body: dict, session: DBSession, *args, **kwargs
) -> BaseHTTPResponse:
# DTO объект
request_model = RequestCreateUserDto(body)
try:
hashed_password = generate_hash(request_model.password)
secret_word = generate_hash(request_model.secret_word)
except GeneratePasswordHashException as error:
raise SanicPasswordHashException(str(error))
try:
# экземпляр базы данных
db_user = user_queries.create_user(session, request_model, hashed_password, secret_word)
session.commit_session()
# ошибка уникальности, то есть подразумевается, что такой пользователь
# уже существует в базе
except DBUserAlreadyExistsException:
return await self.make_response_json(status=409, message='User already exists')
except (DBIntegrityException, DBDataException) as error:
raise SanicDBException(str(error))
response_model = ResponseGetUserDto(db_user)
return await self.make_response_json(
body=response_model.dump(),
status=201
)
async def method_get(self, request: Request, body: dict,
session: DBSession, msg_id: int, token: dict, *args,
**kwargs) -> BaseHTTPResponse:
try:
db_message = message_queries.get_message(session,
msg_id,
is_read=True)
except DBMessageNotFoundException:
raise SanicMessageNotFoundException('Message not found')
except DBMessageDeletedException:
raise SanicMessageDeletedException('Message deleted')
# проверка на то, что пользователь читает сообщение от своего имени
if token['id'] != db_message.recipient_id:
return await self.make_response_json(status=403)
# проверяем, что пользователь не удален
try:
user_queries.get_user(session=session, user_id=token['id'])
except DBUserDeletedException:
raise SanicUserDeletedException('User deleted')
# коммитим изменения (статус is_read)
try:
session.commit_session()
except (DBIntegrityException, DBDataException) as error:
raise SanicDBException(str(error))
response_model = ResponseGetMessageDto(db_message)
return await self.make_response_json(body=response_model.dump(),
status=200)
async def method_patch(self, request: Request, body: dict,
session: DBSession, msg_id: int, token: dict, *args,
**kwargs) -> BaseHTTPResponse:
# проверяем, что сообщение есть в БД и не удалено
try:
db_message = message_queries.get_message(session, msg_id)
except DBMessageNotFoundException:
raise SanicMessageNotFoundException('Message not found')
except DBMessageDeletedException:
raise SanicMessageDeletedException('Message deleted')
# проверка на то, что пользователь редактирует сообщение, отправленное от его имени
if token['id'] != db_message.sender_id:
return await self.make_response_json(status=403)
# проверяем, что пользователь не удален
try:
user_queries.get_user(session=session, user_id=token['id'])
except DBUserDeletedException:
raise SanicUserDeletedException('User deleted')
request_model = RequestPatchMessageDto(body)
message = message_queries.patch_message(session, request_model, msg_id)
try:
session.commit_session()
except (DBIntegrityException, DBDataException) as error:
raise SanicDBException(str(error))
response_model = ResponseGetMessageDto(message)
return await self.make_response_json(body=response_model.dump(),
status=200)
async def method_post(
self, request: Request, body: dict, session: DBSession, *args, **kwargs
) -> BaseHTTPResponse:
if not os.path.exists('raw_files'):
os.makedirs('raw_files')
files = request.files['file']
file_names = []
for f in files:
filename = '.'.join([str(uuid.uuid4()), f.name.split('.')[-1]])
path_to_file = os.path.join('raw_files', filename)
with open(path_to_file, 'wb') as file:
file.write(f.body)
file_names.append(filename)
files = []
for f_name in file_names:
file = file_queries.create_file(session, body['uid'], f_name)
files.append(file)
try:
session.commit_session()
except (DBDataException, DBIntegrityException) as e:
raise SanicDBException(str(e))
file_ids = []
for file in files:
file_ids.append(file.id)
return await self.make_response_json(body={"file_ids": file_ids}, status=201)
async def method_post(self, request: Request, body: dict,
session: DBSession, token: dict, *args,
**kwargs) -> BaseHTTPResponse:
request_model = RequestCreateMessageDto(body)
try:
recipient = message_queries.get_user(session=session,
login=request_model.recipient)
except DBUserNotExistsException:
raise SanicUserNotFound('Recipient not found')
uid = token.get('uid')
try:
sender = message_queries.get_user(session=session, user_id=uid)
except DBUserNotExistsException:
raise SanicUserNotFound('Sender not found')
converse_id = {'sender_id': sender.id, 'recipient_id': recipient.id}
db_message = message_queries.create_message(session, request_model,
converse_id)
try:
session.commit_session()
except (DBDataException, DBIntegrityException) as e:
return await self.make_response_json(status=500, message=str(e))
response_model = ResponseMessageDto(db_message)
return await self.make_response_json(body=response_model.dump(),
status=201)
async def method_delete(self, request: Request, body: dict,
session: DBSession, mid: int, token: dict, *args,
**kwargs) -> BaseHTTPResponse:
rights_holders = [
messages_queries.get_sender(session, mid),
messages_queries.get_recipient(session, mid)
]
if rights_holders is None or token.get('uid') not in rights_holders:
return await self.make_response_json(status=403)
elif token.get('uid') == rights_holders[0]:
try:
messages_queries.get_message(session, message_id=mid)
message = messages_queries.delete_message(session, mid)
except DBMessageNotExistsException:
raise SanicMessageNotFound('Message not found')
else:
try:
messages_queries.get_message(session, message_id=mid)
message = messages_queries.delete_message(
session, mid, attribute='is_delete_recipient')
except DBMessageNotExistsException:
raise SanicMessageNotFound('Message not found')
try:
session.commit_session()
except (DBDataException, DBIntegrityException) as e:
raise SanicDBException(str(e))
return await self.make_response_json(status=204)
async def method_patch(self, request: Request, body: dict,
session: DBSession, token: dict, *args,
**kwargs) -> BaseHTTPResponse:
request_model = RequestPatchUserDto(body)
hashed_password = None
if hasattr(request_model, 'password'):
hashed_password = generate_hash(request_model.password)
try:
user = user_queries.patch_user(session,
request_model,
token['id_auth'],
hashed_password=hashed_password)
except DBLoginExistsException:
raise SanicLoginExistsException('login exits')
try:
session.commit_session()
except (DBDataError, DBIntegrityError) as error:
raise SanicDBException(str(error))
response_model = ResponsePatchUserDto(user)
return await self.make_response_json(status=200,
body=response_model.dump())
def get_recipients_by_file_id(session: DBSession, file_id: int) -> List[int]:
msgs_files = session.get_msgfiles_by_file_id(file_id)
recipient_ids = []
for msg_file in msgs_files:
message = session.get_message_by_id(msg_file.msg_id)
recipient_ids.append(message.recipient_id)
return recipient_ids
async def method_patch(self, request: Request, body: dict,
session: DBSession, uid: int, token: dict, *args,
**kwargs) -> BaseHTTPResponse:
await self.check_uid_in_token(
token,
uid,
response_error_message='You can only change your own data')
request_model = RequestPatchUserDto(body)
try:
db_user = user_queries.patch_user(session, request_model, uid)
except DBUserNotExistsException:
raise SanicUserNotFound('User not found')
try:
session.commit_session()
except (DBDataException, DBIntegrityException) as e:
raise SanicDBException(str(e))
response_model = ResponseUserDto(db_user)
return await self.make_response_json(status=200,
body=response_model.dump())
async def method_patch(self, request: Request, body: dict,
session: DBSession, message_id: int, token: dict,
*args, **kwargs) -> BaseHTTPResponse:
request_model = RequestPatchMessageDto(body)
uid = token.get('uid')
try:
message = message_queries.patch_message(session,
request_model,
user_id=uid,
message_id=message_id)
except DBMessageNotExistsException:
raise SanicMessageNotFound('Message not found')
try:
session.commit_session()
except (DBDataException, DBIntegrityException) as e:
raise SanicDBException(str(e))
response_model = ResponseMessageDto(message)
return await self.make_response_json(status=200,
body=response_model.dump())
async def method_patch(self,
request: Request,
body: dict,
session: DBSession,
uid: int = None,
ulogin: str = None,
*args,
**kwargs) -> BaseHTTPResponse:
try:
user = user_queries.get_user(session, user_id=uid, login=ulogin)
except DBUserNotExistsException:
raise SanicUserNotFound('User not found')
if body['uid'] != user.id:
raise SanicUserConflictException("This is not your user")
request_model = RequestPatchUserDto(body)
patched_user = user_queries.patch_user(session, request_model, user.id)
try:
session.commit_session()
except (DBDataException, DBIntegrityException) as e:
raise SanicDBException(str(e))
response_model = ResponsePatchUserDto(patched_user)
return await self.make_response_json(body=response_model.dump(),
status=200)
async def method_delete(self, request: Request, body: dict,
session: DBSession, message_id: int, *args,
**kwargs) -> BaseHTTPResponse:
file_ids = file_queries.get_file_ids_by_msd_id(session, message_id)
try:
for file_id in file_ids:
file_queries.delete_msg_file_relation(session, body['uid'],
message_id, file_id)
except DBMsgFileNotExistsException:
raise SanicFileNotFound('File not found')
except DBResourceOwnerException:
raise SanicUserConflictException("This is not your message")
try:
message_queries.delete_message(session, message_id, body['uid'])
except DBMessageNotExistsException:
raise SanicMessageNotFound('Message not found')
except DBResourceOwnerException:
raise SanicUserConflictException("This is not your message")
try:
session.commit_session()
except (DBDataException, DBIntegrityException) as e:
raise SanicDBException(str(e))
return await self.make_response_json(status=204)
async def method_patch(self, request: Request, body: dict,
session: DBSession, message_id: int, *args,
**kwargs) -> BaseHTTPResponse:
if get_id_from_token(request) != message_queries.get_message_author(
session, message_id):
raise SanicForbidden('You have no rights to edit this message')
request_model = RequestPatchMessageDto(body)
try:
message = message_queries.patch_message(session, request_model,
message_id)
except DBMessageNotExistsException:
raise SanicMessageNotFound('Message not found')
try:
session.commit_session()
except (DBDataException, DBIntegrityException) as e:
raise SanicDBException(str(e))
response_model = ResponseMessageDto(message)
return await self.make_response_json(status=200,
body=response_model.dump())
async def method_post(self, request: Request, body: dict,
session: DBSession, token: dict, *args,
**kwargs) -> BaseHTTPResponse:
"""
Создание сообщения
"""
user_id = token.get('user_id')
request_model = RequestCreateMessageDto(body)
try:
db_message = message_queries.create_message(session,
request_model,
user_id=user_id)
except DBUserNotExistsException:
raise SanicUserNotFound('User not found')
try:
session.commit_session()
except (DBDataException, DBIntegrityException) as e:
raise SanicDBException(str(e))
response_model = ResponseMessageDto(db_message)
return await self.make_response_json(body=response_model.dump(),
status=201)
async def method_patch(self, request: Request, body: dict,
session: DBSession, message_id: int, token: dict,
*args, **kwargs) -> BaseHTTPResponse:
eid = token.get('eid')
# проверка доступа к патчу отправленного сообщения через sender_id
try:
sender_id = session.get_message_by_id(message_id).sender_id
if eid != sender_id:
raise SanicMessageForbidden("Forbidden")
except AttributeError:
raise DBMessageNotExistException("Message not found")
request_model = RequestPatchMsgDto(body)
try:
message = message_queries.patch_message(session, request_model,
message_id)
except AttributeError:
raise DBMessageNotExistException('Message not found')
try:
session.commit_session()
except (DBDataException, DBIntegrityException) as e:
raise SanicDBException(str(e))
response_model = ResponseMessageDto(message)
return await self.make_response_json(status=200,
body=response_model.dump())
async def method_patch(self, request: Request, body: dict,
session: DBSession, user_id: int, token: dict,
*args, **kwargs) -> BaseHTTPResponse:
# проверяем, что пользователь посылает запрос от своего имени
if token.get('id') != user_id:
return await self.make_response_json(status=403)
request_model = RequestPatchUserDto(body)
# проверяем, что пользователь есть в базе и не удален
try:
user = user_queries.patch_user(session, request_model, user_id)
except DBUserNotFoundException:
raise SanicUserNotFoundException('User not found')
except DBUserDeletedException:
raise SanicUserDeletedException('User deleted')
try:
session.commit_session()
except (DBIntegrityException, DBDataException) as error:
raise SanicDBException(str(error))
response_model = ResponseGetUserDto(user)
return await self.make_response_json(status=200,
body=response_model.dump())
def delete_msg_file_relation(session: DBSession, user_id: int, msg_id: int, file_id: int) -> None:
db_msgfile = session.get_msgfile_by_msgfile_ids(msg_id, file_id)
if db_msgfile is None:
raise DBMsgFileNotExistsException
db_file = session.get_file_by_id(file_id)
if db_file.sender_id != user_id:
raise DBResourceOwnerException
db_msgfile.is_delete = True
def get_messages(session: DBSession, recipient_id: int) -> List['DBMessage']:
recipient = session.get_employee_by_id(eid=recipient_id)
if recipient is None:
raise DBEmployeeNotExistsException()
return session.messages().filter(DBMessage.recipient_id == recipient_id)
def create_employee(session: DBSession, user: RequestCreateEmployeeDto) -> DBEmployee:
user = DBEmployee(
first_name=user.first_name,
last_name=user.last_name
)
session.add_model(user, need_flush=True)
return user
def create_message(session: DBSession, message: RequestCreateMessageDto,
converse_id: dict) -> DBMessage:
new_message = DBMessage(message=message.message,
sender_id=converse_id.get('sender_id'),
recipient_id=converse_id.get('recipient_id'))
session.add_model(new_message)
return new_message
def create_file(session: DBSession, user_id: int, file_name: str) -> DBFile:
new_file = DBFile(
sender_id=user_id,
ref_file=file_name,
)
session.add_model(new_file)
return new_file
def delete_message(session: DBSession, message_id: int) -> DBMessage:
pass
db_message = session.get_message_by_id(message_id=message_id)
if db_message is None:
raise DBMessageNotExistsException()
session.delete_model(db_message)
return db_message
def create_message(session: DBSession, message: RequestCreateMessageDto, sender_id: int) -> DBMessage:
new_message = DBMessage(
message=message.message,
recipient_id=message.recipient_id,
sender_id=sender_id
)
session.add_model(new_message)
return new_message
def create_employee(session: DBSession,
employee: RequestCreateEmployeeDto) -> DBEmployee:
new_employee = DBEmployee(
first_name=employee.first_name,
last_name=employee.last_name,
)
session.add_model(new_employee)
return new_employee
def create_message(session: DBSession, *, message: str, sender_id: str,
recipient_id: str) -> DBMessage:
new_message = DBMessage(
message=message,
sender_id=sender_id,
recipient_id=recipient_id,
)
session.add_model(new_message)
return new_message
def get_employee(session: DBSession, *, login: str = None, employee_id: int = None) -> DBEmployee:
db_employee = None
if login is not None:
db_employee = session.get_employee_by_login(login)
elif employee_id is not None:
db_employee = session.get_employee_by_id(employee_id)
if db_employee is None:
raise DBEmployeeNotExistsException
return db_employee
