IMEX.CORE 1.0.2.35

🏥 IMEX.Core

Thư viện IMEX.Core mạnh mẽ cho hệ thống API của bạn - Cung cấp các tính năng cốt lõi cho phát triển ứng dụng với hiệu suất cao và bảo mật tối ưu.

📋 Mục lục

• 🚀 Giới thiệu
• ✨ Tính năng chính
• 📦 Cài đặt
• ⚙️ Cấu hình
• 📚 Hướng dẫn sử dụng
• 🏗️ Kiến trúc
• 🔧 API Reference
• 🧪 Testing
• 📈 Performance
• 🤝 Đóng góp
• 📄 License

🚀 Giới thiệu

IMEX.Core là thư viện cốt lõi được thiết kế đặc biệt cho hệ thống quản lý nhân sự trong lĩnh vực y tế. Thư viện cung cấp các tính năng mạnh mẽ, hiệu suất cao và bảo mật tối ưu để xây dựng các ứng dụng HR phức tạp.

🎯 Mục tiêu

• Hiệu suất cao: Tối ưu hóa cache, database access và memory usage
• Bảo mật mạnh: Mã hóa dữ liệu, quản lý quyền truy cập chi tiết
• Dễ sử dụng: API đơn giản, documentation chi tiết
• Mở rộng tốt: Kiến trúc modular, dễ dàng customize
• Production-ready: Đã được test kỹ lưỡng trong môi trường thực tế

✨ Tính năng chính

🗄️ Database & ORM

• SqlSugar ORM: Hỗ trợ multi-database, read/write splitting
• Migration System: Tự động migration và seeding dữ liệu
• Multi-tenant: Hỗ trợ multi-tenant architecture
• Connection Pooling: Tối ưu hóa kết nối database

🚀 Caching System

• Multi-tier Cache: L1 (Memory) + L2 (Redis) + Hybrid
• Smart Compression: Tự động nén dữ liệu lớn
• Adaptive TTL: Tự động điều chỉnh thời gian cache
• Lock-free Operations: Thread-safe, high-performance
• Cache Invalidation: RemoveByPrefix, tag-based removal

🔐 Security & Authentication

• Multi-encryption: RSA, SM2, SM3, SM4
• JWT Authentication: Stateless authentication
• Role-based Access Control: Bitwise permission system
• Data Encryption: End-to-end encryption
• Audit Logging: Comprehensive security logging

📊 Logging & Monitoring

• Structured Logging: Serilog với Elasticsearch
• Performance Monitoring: Real-time metrics
• Error Tracking: Comprehensive error handling
• Request/Response Logging: Full API monitoring
• SQL Query Logging: Database performance tracking

🛠️ Utilities & Helpers

• File Operations: Secure file handling
• Data Conversion: Number to text, encoding/decoding
• Validation: Input validation helpers
• HTTP Utilities: Request/response helpers
• ID Generation: Snowflake ID, custom generators

📦 Cài đặt

NuGet Package

# Package Manager
Install-Package IMEX.CORE -Version 1.0.2.35

# .NET CLI
dotnet add package IMEX.CORE --version 1.0.2.35
# Paket
paket add IMEX.CORE --version 1.0.2.35

Yêu cầu hệ thống

• .NET 8.0 hoặc .NET 9.0
• SQL Server 2019+ hoặc MySQL 8.0+
• Redis 6.0+ (tùy chọn, cho distributed cache)
• Elasticsearch 7.0+ (tùy chọn, cho logging)

⚙️ Cấu hình

1. Database Configuration

{
  "MainDB": "DB_Main",
   "MultiDBEnabled": true,
   "DBConnections": [
     {
      "ConnId": "DB_Main",
       "DBType": 1,
       "Enable": true,
       "HitRate": 50,
      "ConnectionStr": "Data Source=localhost;Initial Catalog=MedcomHR;Integrated Security=True;",
       "ProviderName": "System.Data.SqlClient",
        "Slaves": [
         {
          "HitRate": 0,
          "Connection": "Data Source=slave-server;Initial Catalog=MedcomHR;Integrated Security=True;"
        }
      ]
    }
  ]
}

2. Cache Configuration

{
  "Cache": {
    "EnableL1Cache": true,
    "EnableL2Cache": true,
    "DefaultTTL": 600,
    "CompressionThreshold": 51200,
    "MaxCacheSize": 100000
  },
  "Redis": {
    "ConnectionString": "localhost:6379",
    "Database": 0,
    "KeyPrefix": "medcom:hr:"
  }
}

3. Logging Configuration

{
  "Serilog": {
    "MinimumLevel": "Information",
    "WriteTo": [
      {
        "Name": "Console",
        "Args": {
          "outputTemplate": "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj} {Properties:j}{NewLine}{Exception}"
        }
      },
      {
        "Name": "Elasticsearch",
        "Args": {
          "nodeUris": "http://localhost:9200",
          "indexFormat": "medcom-hr-logs-{0:yyyy.MM.dd}"
        }
      }
    ]
  }
}

📚 Hướng dẫn sử dụng

1. Database Operations

using IMEX.CORE.Core.DBAccess;

// Khởi tạo database context
var dbContext = new DbContextBase();

// Query dữ liệu
var employees = await dbContext.Queryable<Employee>()
    .Where(e => e.DepartmentId == departmentId)
    .ToListAsync();

// Insert dữ liệu
var newEmployee = new Employee
{
    Name = "Nguyễn Văn A",
    Email = "a@medcom.com",
    DepartmentId = 1
};
await dbContext.Insertable(newEmployee).ExecuteCommandAsync();

2. Caching

using IMEX.Core.Caching.Interfaces;

// Khởi tạo cache
var memoryCache = new MemoryCache(new MemoryCacheOptions());
var config = new EnhancedMemoryCacheConfig();
var cache = new EnhancedMemoryCache(memoryCache, config);

// Set cache
await cache.SetAsync("employee:123", employeeData, 30); // 30 phút

// Get cache
var employee = await cache.GetAsync<Employee>("employee:123", async () =>
{
    return await dbContext.Queryable<Employee>()
        .Where(e => e.Id == 123)
        .FirstAsync();
});

// Remove by prefix
await cache.RemoveByPrefixAsync("employee:"); // Xóa tất cả cache employee

3. Authentication & Authorization

using IMEX.CORE.Core.AuthencationBuilder;

// Cấu hình authentication
services.AddAuthentication(options =>
{
    options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
    options.TokenValidationParameters = new TokenValidationParameters
    {
        ValidateIssuer = true,
        ValidateAudience = true,
        ValidateLifetime = true,
        ValidateIssuerSigningKey = true,
        ValidIssuer = "imex",
        ValidAudience = "imex",
        IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("your-secret-key"))
    };
});

// Kiểm tra quyền
[Authorize]
[RequirePermission("EMPLOYEE",PermissionValue.View)]
public async Task<IActionResult> GetEmployee(int id)
{
    // Implementation
}

4. Logging

using IMEX.CORE.Core.LogHelper;

// Ghi log
LogHelper.LogInformation("Employee created: {EmployeeId}", employeeId);
LogHelper.LogWarning("Failed to send email to: {Email}", email);
LogHelper.LogError(exception, "Database connection failed");

// Structured logging
LogHelper.LogInformation("User {UserId} accessed {Resource} at {Timestamp}", 
    userId, resource, DateTime.UtcNow);

5. File Operations

using IMEX.CORE.Core.Helper;

// Đọc file
var content = await FileHelper.ReadFileAsync("path/to/file.txt");

// Ghi file
await FileHelper.WriteFileAsync("path/to/file.txt", content);

// Upload file
var result = await FileHelper.UploadFileAsync(file, "uploads/");

// Xóa file
await FileHelper.DeleteFileAsync("path/to/file.txt");

🏗️ Kiến trúc

System Architecture

┌───────────────────────────────────────────────────────────┐
│                    IMEX.Core                              │
├───────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │
│  │   Caching   │  │  Database   │  │  Security   │        │
│  │   System    │  │   Access    │  │   Layer     │        │
│  └─────────────┘  └─────────────┘  └─────────────┘        │
├───────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │
│  │   Logging   │  │  Utilities  │  │   Models    │        │
│  │   System    │  │   & Helpers │  │   & DTOs    │        │
│  └─────────────┘  └─────────────┘  └─────────────┘        │
├───────────────────────────────────────────────────────────┤
│                    .NET 8.0/9.0 Runtime                   │
└───────────────────────────────────────────────────────────┘

Cache Architecture

┌───────────────────────────────────────────────────────────┐
│                    Cache System                           │
├───────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │
│  │   L1 Cache  │  │   L2 Cache  │  │  Hybrid     │        │
│  │  (Memory)   │  │   (Redis)   │  │  Manager    │        │
│  │             │  │             │  │             │        │
│  │ • Fast      │  │ • Shared    │  │ • Smart     │        │
│  │ • Local     │  │ • Scalable  │  │ • Routing   │        │
│  │ • Limited   │  │ • Persistent│  │ • Fallback  │        │
│  └─────────────┘  └─────────────┘  └─────────────┘        │
├───────────────────────────────────────────────────────────┤
│              Performance Optimizations                    │
│  • Object Pooling    • Compression    • Lock-free         │
│  • Adaptive TTL      • Jittering      • Circuit Breaker   │
└───────────────────────────────────────────────────────────┘

🔧 API Reference

Core Classes

EnhancedMemoryCache

public class EnhancedMemoryCache : IMemCache
{
    // Set operations
    Task<T> GetAsync<T>(string key, Func<Task<T>> acquire, int cacheTimeInMinutes);
    void Set(string cacheKey, object cacheValue, int timeSpan);
    Task RemoveByPrefixAsync(string prefix);
    
    // Performance methods
    void SetFast(string cacheKey, object cacheValue, int timeSpan);
    void SetSmart(string cacheKey, object cacheValue, int timeSpan);
    void SetMemoryEfficient(string cacheKey, object cacheValue, int timeSpan);
}

DbContextBase

public class DbContextBase
{
    // Query operations
    ISugarQueryable<T> Queryable<T>();
    Task<List<T>> ToListAsync<T>();
    Task<T> FirstAsync<T>();
    
    // Command operations
    IInsertable<T> Insertable<T>(T insertObj);
    IUpdateable<T> Updateable<T>(T updateObj);
    IDeleteable<T> Deleteable<T>();
}

LogHelper

public static class LogHelper
{
    void LogInformation(string message, params object[] args);
    void LogWarning(string message, params object[] args);
    void LogError(Exception exception, string message, params object[] args);
    void LogDebug(string message, params object[] args);
}

🧪 Testing

Unit Tests

[Test]
public async Task Cache_Should_Store_And_Retrieve_Data()
{
    // Arrange
    var cache = new EnhancedMemoryCache(memoryCache, config);
    var testData = new { Id = 1, Name = "Test" };
    
    // Act
    await cache.SetAsync("test:key", testData, 10);
    var result = await cache.GetAsync<object>("test:key", () => Task.FromResult(testData));
    
    // Assert
    Assert.That(result, Is.Not.Null);
    Assert.That(result.Id, Is.EqualTo(1));
}

Performance Tests

[Test]
public async Task Cache_Performance_Should_Be_Optimal()
{
    // Arrange
    var analyzer = new CachePerformanceAnalyzer();
    
    // Act
    var results = await analyzer.RunBenchmarkAsync(100_000);
    
    // Assert
    Assert.That(results.SetOperations.Improvement, Is.GreaterThan(2.0)); // 2x faster
    Assert.That(results.MemoryUsage.MemorySavings, Is.GreaterThan(40.0)); // 40% less memory
}

📈 Performance

Benchmark Results

Cache Performance

• Hit Ratio: 85-95% trong production
• Response Time: < 1ms cho cache hits
• Memory Efficiency: 40-60% tiết kiệm memory
• Concurrent Support: 10,000+ concurrent operations

Database Performance

• Connection Pooling: Tối ưu hóa kết nối
• Query Optimization: SqlSugar ORM với performance tuning
• Read/Write Splitting: Tự động routing queries
• Multi-tenant: Isolated performance per tenant

🤝 Đóng góp

Chúng tôi hoan nghênh mọi đóng góp từ cộng đồng! Để đóng góp:

1. Fork repository
2. Tạo branch cho feature mới (git checkout -b feature/amazing-feature)
3. Commit changes (git commit -m 'Add amazing feature')
4. Push lên branch (git push origin feature/amazing-feature)
5. Tạo Pull Request

Development Guidelines

• Tuân thủ coding standards của .NET
• Viết unit tests cho code mới
• Cập nhật documentation
• Đảm bảo backward compatibility

📄 License

Dự án này được phân phối dưới giấy phép MIT. Xem file LICENSE để biết thêm chi tiết.

📞 Liên hệ

• Tác giả: truongnv2412
• Công ty: IMEXsoft.,JSC
• Email: support@imexsoft.com
• Website: https://imexsoft.com

🙏 Acknowledgments

• SqlSugar ORM - Powerful ORM framework
• Serilog - Structured logging framework
• StackExchange.Redis - High-performance Redis client
• Microsoft.Extensions - .NET extension libraries

⭐ Nếu thư viện này hữu ích, hãy cho chúng tôi một star! ⭐

Made with ❤️ by truongnv2412