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, 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_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_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_get(
self, request: Request, body: dict, session: DBSession, mid: int, *args, **kwargs
) -> BaseHTTPResponse:
try:
db_message = message_queries.get_messages(session, mid)
except DBMessageNotExistsException:
raise SanicMessageNotFound('Message not found')
response_model = ResponseCreateMessageDto(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, msg_id: int, token: dict,
*args, **kwargs) -> BaseHTTPResponse:
try:
db_message = message_queries.get_db_message(session, msg_id)
except DBMessageNotExistsException:
raise SanicMessageNotFound('Message not found')
await self.check_sender_id_by_token(token, db_message,
response_error_message='You can only delete your own data')
try:
db_message = message_queries.delete_message(db_message)
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, message_id: int, *args,
**kwargs) -> BaseHTTPResponse:
request_model = RequestPatchMessageDto(body)
try:
message = message_queries.patch_message(session, request_model,
message_id, body['uid'])
except DBMessageNotExistsException:
raise SanicMessageNotFound('Message not found')
except DBResourceOwnerException:
raise SanicUserConflictException("This is not your message")
try:
if hasattr(request_model, 'file_ids'):
file_ids = file_queries.get_file_ids_by_msd_id(
session, message_id)
file_ids_merged = list(set(file_ids + request_model.file_ids))
for file_id in file_ids_merged:
if file_id not in file_ids:
file_queries.create_msg_file_relation(
session=session,
user_id=body['uid'],
msg_id=message_id,
file_id=file_id)
elif file_id not in request_model.file_ids:
file_queries.delete_msg_file_relation(
session=session,
user_id=body['uid'],
msg_id=message_id,
file_id=file_id)
except DBFileNotExistsException:
raise SanicFileNotFound('File not found')
except DBMsgFileNotExistsException:
raise SanicFileNotFound('MsgFile not found')
except DBResourceOwnerException:
raise SanicUserConflictException("This is not your file")
try:
session.commit_session()
except (DBDataException, DBIntegrityException) as e:
raise SanicDBException(str(e))
message.file_ids = file_queries.get_file_ids_by_msd_id(
session, message.id)
response_model = ResponsePatchMessageDto(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_db_message(session, msg_id)
except DBMessageNotExistsException:
raise SanicMessageNotFound('Message not found')
await self.check_sender_id_by_token(token, db_message, response_error_message='You can only get your own data',
include_recipient_id=True)
response_model = ResponseMessageDto(db_message)
return await self.make_response_json(body=response_model.dump(), status=200)
async def method_delete(self, request: Request, body: dict,
session: DBSession, mid: int, *args,
**kwargs) -> BaseHTTPResponse:
try:
message = message_queries.delete_message(session, mid)
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_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:
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, 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_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:
"""
Просмотр сообщения по его 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_delete(self, request: Request, body: dict,
session: DBSession, message_id: int, token: dict,
*args, **kwargs) -> BaseHTTPResponse:
try:
db_message = message_queries.delete_message(session,
message_id=message_id)
except DBMessageNotExistsException:
raise SanicMessageNotFound('Message not found')
if db_message.sender_id != token.get("eid"):
return await self.make_response_json(status=403,
message="Forbidden")
try:
session.commit_session()
except (DBDataException, DBIntegrityException) as e:
raise SanicDBException(str(e))
return await self.make_response_json(status=204)
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())