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