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, mid: int, token: dict, *args,
**kwargs) -> BaseHTTPResponse:
right_holder = messages_queries.get_sender(session, mid)
if right_holder is None or token.get('uid') != right_holder:
return await self.make_response_json(status=403)
request_model = RequestPatchMessageDto(body)
try:
messages_queries.get_message(session, mid)
message = messages_queries.patch_message(session, request_model,
mid)
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, 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_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_get(
self, request: Request, body: dict, session, mid: int, token: dict, *args, **kwargs
) -> BaseHTTPResponse:
try:
db_message = message_queries.get_message(session, mid, uid=token.get("uid"))
except (DBMessagesNoAccess, DBMessageNotExistsException):
raise SanicResponseForbiddenException('message not found')
response_model = ResponseMessageDto(db_message)
return await self.make_response_json(status=200, body=response_model.dump())
async def method_get(
self, request: Request, body: dict, session: DBSession, token: dict, *args, **kwargs
) -> BaseHTTPResponse:
db_messages = message_queries.get_message(session=session, user_id=token.get('id_auth'))
response_body = {
'received_messages': ResponseGetMessagesDtoSchema(many=True).dump(db_messages)
}
return await self.make_response_json(body=response_body, status=200)
async def method_get(self, request: Request, body: dict,
session: DBSession, message_id: int, token: dict,
*args, **kwargs) -> BaseHTTPResponse:
try:
message = message_queries.get_message(session, message_id)
except DBMessageNotExistsException:
raise SanicMessagesNotFound('')
recipient_id = message.recipient_id
sender_id = message.sender_id
if token.get('eid') != recipient_id and token.get('eid') != sender_id:
return await self.make_response_json(status=403)
try:
message = message_queries.get_message(session, message_id)
except DBMessageNotExistsException:
raise SanicMessagesNotFound('Message not found')
response_model = ResponseMessageDto(message)
return await self.make_response_json(body=response_model.dump(),
status=200)
async def method_get(self, request: Request, body: dict,
session: DBSession, token: dict, mid: int, *args,
**kwargs) -> BaseHTTPResponse:
try:
db_message = message_queries.get_message(session=session, mid=mid)
except DBMessageDoesntExistException:
raise SanicMessageNotFound('message not found')
if db_message.recipient_id == token.get(
'id_auth') or db_message.sender_id == token.get('id_auth'):
response_model = ResponseGetMessagesDto(db_message)
else:
return await self.make_response_json(status=403)
return await self.make_response_json(body=response_model.dump(),
status=200)
async def method_get(self, request: Request, body: dict,
session: DBSession, message_id: int, *args,
**kwargs) -> BaseHTTPResponse:
try:
message = message_queries.get_message(session, message_id)
except DBMessageNotExistsException as e:
raise SanicDBException(str(e))
if message.recipient_id != body['uid']:
raise SanicUserConflictException("This message is not for you")
message.file_ids = file_queries.get_file_ids_by_msd_id(
session, message.id)
response_model = ResponseGetMessageDto(message)
return await self.make_response_json(body=response_model.dump(),
status=200)
async def method_get(self, request: Request, body: dict,
session: DBSession, message_id: int, *args,
**kwargs) -> BaseHTTPResponse:
try:
message = message_queries.get_message(session, message_id)
except DBMessageNotExistsException:
raise SanicMessageNotFound('Message not found') # change
if not (message.recipient_id == get_id_from_token(request)) and \
not (message.sender_id == get_id_from_token(request)):
raise SanicForbidden('You have no rights to read this message')
response_model = ResponseMessageDto(message)
return await self.make_response_json(status=200,
body=response_model.dump())
async def method_get(self, request: Request, body: dict,
session: DBSession, token: dict, message_id: int,
*args, **kwargs) -> BaseHTTPResponse:
uid = token.get('uid')
try:
db_message = message_queries.get_message(session=session,
message_id=message_id,
user_id=uid)
except DBMessageNotExistsException:
raise SanicMessageNotFound('Message not found')
response_model = ResponseMessageDto(db_message)
return await self.make_response_json(status=200,
body=response_model.dump())
async def method_delete(self, request: Request, body: dict,
session: DBSession, token: dict, mid: int, *args,
**kwargs) -> BaseHTTPResponse:
try:
db_message = message_queries.get_message(session=session, mid=mid)
except DBMessageDoesntExistException:
raise SanicMessageNotFound('message not found')
if db_message.sender_id != token.get('id_auth'):
return await self.make_response_json(status=403)
message_queries.delete_message(db_message)
try:
session.commit_session()
except (DBDataError, DBIntegrityError) as error:
raise SanicDBException(str(error))
return await self.make_response_json(status=204, body=None)
async def method_get(self, request: Request, body: dict,
session: DBSession, message_id: int, token: dict,
*args, **kwargs) -> BaseHTTPResponse:
try:
message = message_queries.get_message(session,
message_id=message_id)
except DBMessageNotExistsException:
raise SanicMessageNotFound('Message not found')
employee_id = token["eid"]
if message.sender_id != employee_id and message.recipient_id != employee_id:
return await self.make_response_json(status=403,
message="Forbidden")
response_message = ResponseMessageDto(message)
return await self.make_response_json(status=200,
body=response_message.dump())
async def method_get(self, request: Request, body: dict,
session: DBSession, message_id, token: dict, *args,
**kwargs) -> BaseHTTPResponse:
eid = token.get('eid')
try:
recipient_id = session.get_recipient_id_by_message(message_id)
except AttributeError:
raise DBMessageNotExistException("Message not found")
if eid != recipient_id:
raise SanicMessageForbidden("Not allowed")
try:
db_message = message_queries.get_message(session, message_id)
except SanicMessageReadNotAllowedException as e:
raise e
response_model = ResponseMessageDto(db_message)
return await self.make_response_json(body=response_model.dump())
async def method_get(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)
try:
db_message = message_queries.get_message(session,
message_id=message_id)
except DBMessageNotExistsException:
raise SanicMessageNotFound('Message not found')
response_model = ResponseMessageDto(db_message)
return await self.make_response_json(body=response_model.dump(),
status=201)
async def method_get(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)
try:
message = messages_queries.get_message(session, mid)
except DBMessageNotExistsException:
raise SanicMessageNotFound('Message not found')
response_model = ResponseMessageDto(message)
return await self.make_response_json(status=200,
body=response_model.dump())
async def method_delete(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.recipient_id:
return await self.make_response_json(status=403)
message_queries.delete_message(session, msg_id)
try:
session.commit_session()
except (DBIntegrityException, DBDataException) as error:
raise SanicDBException(str(error))
return await self.make_response_json(status=204)
async def method_delete(self, request: Request, body: dict,
session: DBSession, message_id: int, token: dict,
*args, **kwargs) -> BaseHTTPResponse:
try:
sender_id = message_queries.get_message(session,
message_id).sender_id
except DBMessageNotExistsException:
raise SanicMessagesNotFound('')
if token.get('eid') != sender_id:
return await self.make_response_json(status=403)
try:
message_queries.delete_message(session, message_id=message_id)
except DBMessageNotExistsException:
raise SanicMessagesNotFound('Message not found')
try:
session.commit_session()
except (DBDataException, DBIntegrityException) as e:
raise SanicDBException(str(e))
return await self.make_response_json(status=204)
