server/message_handler.py - master - Lexus_666/PIR_LAB_4

server/message_handler.py
210 строк7 KB
Lexus-666
Lab_4_done added client + server + test run
25 дек 2025, 02:27
25 дек 2025, 02:271e2f432
import logging
from datetime import datetime
from common.utils import json_dumps
from common.models import ResponseMessage
from server.auth import AuthService
from server.database import Database

logger = logging.getLogger(__name__)

class MessageHandler:
    def __init__(self):
        self.db = Database()
        self.auth = AuthService()

    def process_message(self, message_body: dict) -> dict:

        if not self._validate_message(message_body):
            return self._create_error_response(
                message_body.get('id', 'unknown'),
                'INVALID_MESSAGE',
                'Invalid message format'
            )

        request_id = message_body['id']

        if self.db.is_request_processed(request_id):
            logger.info(f"Request {request_id} already processed")
            return self._create_error_response(
                request_id,
                'DUPLICATE_REQUEST',
                'Request already processed'
            )

        if not self.auth.validate_api_key(message_body['auth'], self.db):
            return self._create_error_response(
                request_id,
                'UNAUTHORIZED',
                'Invalid API key'
            )

        try:
            result = self._handle_action(message_body)
            self.db.mark_request_processed(request_id)
            return result
        except Exception as e:
            logger.error(f"Error processing request {request_id}: {e}")
            return self._create_error_response(
                request_id,
                'INTERNAL_ERROR',
                str(e)
            )

    def _validate_message(self, message: dict) -> bool:
        required_fields = ['id', 'version', 'action', 'data', 'auth']
        return all(field in message for field in required_fields)

    def _handle_action(self, message: dict) -> dict:
        action = message['action']
        data = message['data']

        handlers = {
            'create_user': self._handle_create_user,
            'get_user': self._handle_get_user,
            'get_all_users': self._handle_get_all_users,
            'update_user': self._handle_update_user,
            'delete_user': self._handle_delete_user,
            'health_check': self._handle_health_check
        }

        handler = handlers.get(action)
        if not handler:
            return self._create_error_response(
                message['id'],
                'INVALID_ACTION',
                f'Unknown action: {action}'
            )

        return handler(data, message['id'])

    def _handle_create_user(self, data: dict, request_id: str) -> dict:
        required_fields = ['username', 'email']
        if not all(field in data for field in required_fields):
            return self._create_error_response(
                request_id,
                'VALIDATION_ERROR',
                'Missing required fields: username, email'
            )

        result = self.db.create_user(
            data['username'],
            data['email'],
            data.get('full_name')
        )

        if result:
            response = ResponseMessage(
                correlation_id=request_id,
                status='ok',
                data=result
            )
            return response.to_dict()
        else:
            return self._create_error_response(
                request_id,
                'DATABASE_ERROR',
                'Failed to create user'
            )

    def _handle_get_user(self, data: dict, request_id: str) -> dict:
        if 'user_id' not in data:
            return self._create_error_response(
                request_id,
                'VALIDATION_ERROR',
                'Missing user_id field'
            )

        result = self.db.get_user(data['user_id'])

        if result:
            response = ResponseMessage(
                correlation_id=request_id,
                status='ok',
                data=result
            )
            return response.to_dict()
        else:
            return self._create_error_response(
                request_id,
                'NOT_FOUND',
                'User not found'
            )

    def _handle_get_all_users(self, data: dict, request_id: str) -> dict:
        result = self.db.get_all_users()

        response = ResponseMessage(
            correlation_id=request_id,
            status='ok',
            data={'users': result}
        )
        return response.to_dict()

    def _handle_update_user(self, data: dict, request_id: str) -> dict:
        if 'user_id' not in data:
            return self._create_error_response(
                request_id,
                'VALIDATION_ERROR',
                'Missing user_id field'
            )

        result = self.db.update_user(
            data['user_id'],
            data.get('username'),
            data.get('email'),
            data.get('full_name')
        )

        if result:
            response = ResponseMessage(
                correlation_id=request_id,
                status='ok',
                data=result
            )
            return response.to_dict()
        else:
            return self._create_error_response(
                request_id,
                'NOT_FOUND',
                'User not found'
            )

    def _handle_delete_user(self, data: dict, request_id: str) -> dict:
        if 'user_id' not in data:
            return self._create_error_response(
                request_id,
                'VALIDATION_ERROR',
                'Missing user_id field'
            )

        result = self.db.delete_user(data['user_id'])

        if result:
            response = ResponseMessage(
                correlation_id=request_id,
                status='ok',
                data={'deleted_user_id': result['id']}
            )
            return response.to_dict()
        else:
            return self._create_error_response(
                request_id,
                'NOT_FOUND',
                'User not found'
            )

    def _handle_health_check(self, data: dict, request_id: str) -> dict:
        response = ResponseMessage(
            correlation_id=request_id,
            status='ok',
            data={'status': 'healthy', 'timestamp': str(datetime.now())}
        )
        return response.to_dict()

    def _create_error_response(self, request_id: str, error_code: str, message: str) -> dict:
        response = ResponseMessage(
            correlation_id=request_id,
            status='error',
            error=f'{error_code}: {message}'
        )
        return response.to_dict()