My Practice

🚀 User Management Project Documentation

This project aims to build a user management system that supports CRUD operations on user data and includes features such as error handling, dependency injection, and logging. The system adopts a layered architecture design, consisting of multiple modules such as the API layer, domain layer, infrastructure layer, and interface layer.

📦 Code Structure

The project's code is organized in the following directories:

app/
├── api/               # API interface definitions
│   ├── v1/           # First version of API interfaces
│   │   └── user_router.py       # User management routing file
├── core/             # Core configuration and utility classes
│   ├── config/       # System configuration files
│   │   └── settings.py         # System settings class
│   └── exceptions.py  # Custom exception handling
├── domain/           # Domain logic implementation
│   ├── user/         # User domain models and logic
│   │   ├── exceptions.py      # Domain layer custom exceptions
│   │   ├── fields.py          # Data validation field definitions
│   │   ├── models/            # Domain data models
│   │   │   ├── new_user.py    # New user model
│   │   │   └── user.py        # User entity class
│   └── use_cases/    # Business use case implementation
│       └── user/     # User-related business logic
│           └── user_use_case.py    # User business use case
├── infrastructure/   # Infrastructure layer implementation
│   ├── repositories/ # Data storage access layer
│   │   ├── exceptions.py      # Storage layer custom exceptions
│   │   └── user_repository_csv.py  # CSV file storage implementation
├── interfaces/       # Interface adapter layer
│   ├── csv_user_parser.py    # CSV format data parsing class
│   └── user_repository.py     # Data access interface definition
└── main.py           # Application startup entry file

🧩 Dependency Injection Configuration

The system uses the dependency injection design pattern, implemented through the dependency_injection package. The main configuration is as follows:

# Configuration loader
def load_config():
    return Config()

# Dependency provider
class ServiceProvider:
    def __init__(self):
        self.config = load_config()
    
    @property
    def config(self):
        return self._config
    
    @property
    def user_repository(self):
        return UserCSVRepository()

📝 Logging Configuration

The system uses the logging module to implement the logging function. The main configuration is as follows:

import logging

# Configure the log format
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

# Create a logger instance
logger = logging.getLogger('UserManagementSystem')

💻 User Management API Interfaces

The API interfaces are located in the api/v1/user_router.py file. The main functions include:

• Get all users: GET /users
• Get a single user: GET /users/{user_id}
• Create a new user: POST /users
• Update user information: PUT /users/{user_id}
• Delete a user: DELETE /users/{user_id}

⚠️ Error Handling

The system defines multiple custom exception classes to handle different error scenarios:

class UserManagementError(Exception):
    pass

class UserNotFoundError(UserManagementError):
    pass

class DuplicateUserError(UserManagementError):
    pass

🛂 Data Validation and Serialization

The data model includes detailed validation logic and field constraints:

class UserSchema(BaseModel):
    id: str
    username: constr(min_length=3, max_length=50)
    email: EmailStr
    phone_number: PhoneNumber
    created_at: datetime = Field(default_factory=datetime.now)

💾 Data Storage Implementation

User data is stored in a CSV file, implementing basic CRUD operations:

class UserCSVRepository:
    def __init__(self, file_path="users.csv"):
        self.file_path = file_path

    def get_all_users(self):
        # Read the CSV file and return the user list
        pass

    def get_user_by_id(self, user_id):
        # Query the user by ID
        pass

    def create_user(self, user_data):
        # Write the new user to the CSV file
        pass

    def update_user(self, user_id, updated_data):
        # Update the record of the specified user
        pass

    def delete_user(self, user_id):
        # Delete the record of the specified user
        pass

🏭 Dependency Injection and Factory Pattern

The system creates an instance of the service provider through the factory pattern:

class ServiceProviderFactory:
    @staticmethod
    def create_service_provider():
        return ServiceProvider()

⚙️ Configuration Management

The core configuration module includes basic system settings:

class Config:
    def __init__(self):
        self.api_version = "1.0.0"
        self.environment = "development"
        self.debug_mode = True

    @property
    def is_debug(self):
        return self.debug_mode

🔌 Interface Adapter

The CSV data parsing class implements the data read and write functions:

class CSVUserParser:
    def parse_user_data(self, data):
        # Parse the CSV format data into a user object
        pass

    def unparse_user_data(self, user):
        # Convert the user object back to CSV format data
        pass

🚀 Application Startup

The main file is responsible for initializing the configuration and starting the API service:

def main():
    config = load_config()
    service_provider = create_service_provider(config)
    app = FastAPI(title=config.api_version)
    app.include_router(user_router, prefix="/api/v1")
    uvicorn.run(app, host="0.0.0.0", port=8000)

if __name__ == "__main__":
    main()

📖 User Management Documentation

This project provides a complete user management function, including:

• Create a new user: POST /users
• Get the information of a specified user: GET /users/{user_id}
• Update user profile: PUT /users/{user_id}
• Delete a user record: DELETE /users/{user_id}

🧩 Dependency Injection Configuration

Dependency injection is implemented through the ServiceProvider class:

class ServiceProvider:
    def __init__(self, config):
        self.config = config

⚙️ Configuration Management Module

It includes settings for the system runtime environment and debug mode:

class Config:
    def __init__(self, environment="development", debug_mode=True):
        self.environment = environment
        self.debug_mode = debug_mode

    @property
    def is_debug(self):
        return self.debug_mode

⚠️ Error Handling Module

It defines multiple custom error types for different exception handling scenarios:

class UserManagementError(Exception):
    pass

class ValidationFailedError(UserManagementError):
    pass

class AuthenticationError(UserManagementError):
    pass

📄 Project Configuration File

The default configuration file path of the system is config.yaml, and the content is as follows:

environment: development
debug_mode: true
api_version: "1.0.0"
log_level: INFO

💾 User Data Storage Class

The specific methods for the CSV file storage implementation:

class UserCSVRepository:
    def __init__(self, file_path="users.csv"):
        self.file_path = file_path

    def get_all_users(self):
        # Implement the method to read all users from the CSV file
        pass

    def get_user_by_id(self, user_id):
        # The specific implementation of querying a user by ID
        pass

    def create_user(self, user_data):
        # The logic of writing new user data to the CSV file
        pass

    def update_user(self, user_id, updated_data):
        # The method of updating the record of a specified user
        pass

    def delete_user(self, user_id):
        # The implementation of deleting a specified user
        pass

🔌 Interface Adapter Layer

The specific implementation of CSV data parsing and conversion:

class CSVUserParser:
    def parse_csv_to_users(self, csv_data):
        # The method of converting CSV format data to a list of user objects
        pass

    def parse_user_to_csv(self, user):
        # The method of converting a user object to CSV format data
        pass

📋 Project Summary

This user management system adopts a layered architecture design, with clear responsibilities for each module. Through dependency injection and the factory pattern, the design principle of loose coupling is achieved, improving the maintainability and scalability of the system. The system supports basic CRUD operations and has a good error handling mechanism and logging function.

👋 Conclusion

The above documentation details the structure, implementation details, and configuration methods of the user management project.