Sufficit.EFData 1.26.430.2043

<h1> Sufficit.EFData <a href="https://github.com/sufficit"><img src="https://avatars.githubusercontent.com/u/66928451?s=200&v=4" alt="Sufficit Logo" width="80" align="right"></a> </h1>

Entity Framework Data Providers for Sufficit Ecosystem

A comprehensive .NET library that provides Entity Framework-based data access providers for the Sufficit platform. This library implements the Provider Architecture Pattern with extension methods for optimal performance and maintainability.

📋 Table of Contents

• About
• Features
• Architecture
• Installation
• Usage
• Modules
• Configuration
• Development
• Contributing
• License

📖 About

Sufficit.EFData is a core component of the Sufficit ecosystem, providing standardized data access patterns using Entity Framework Core. The library implements a consistent provider architecture that ensures:

• Multi-target Framework Support: Compatible with .NET Standard 2.0, .NET 6.0, 7.0, 8.0, and 9.0
• Provider Pattern: Clean separation between data access logic and business logic
• Extension Methods: Convenient query methods without additional abstraction layers
• Dependency Injection: Seamless integration with Microsoft.Extensions.DependencyInjection
• Database Agnostic: Support for multiple database providers (MySQL, SQL Server, etc.)

Key Principles

1. Single Responsibility: Each provider handles one specific domain
2. Extension Methods: Business logic extensions without repository overhead
3. Scoped Contexts: Proper DbContext lifecycle management
4. Consistent API: Uniform interface across all providers

✨ Features

🔧 Core Features

• Multi-Framework Targeting: Supports .NET Standard 2.0+ and modern .NET versions
• Provider Architecture: Clean separation of data access concerns
• Extension Methods: Fluent API for complex queries
• Dependency Injection: Native support for IServiceCollection
• Database Providers: MySQL, SQL Server, and PostgreSQL support
• Migration Tools: Built-in database migration utilities

📊 Domain Modules

• Exchange: Email tracking, message templates, and communication logs
• Identity: User management and authentication data
• Contacts: Customer and contact information management
• Telephony: Call records, CDR data, and telephony operations
• Finance: Billing, payments, and financial transactions
• Statistics: Analytics and reporting data
• Storage: File and media storage management
• Tasks: Background job and task management

🛠️ Developer Experience

• IntelliSense Support: Full IDE integration
• Comprehensive Documentation: Detailed API documentation
• Code Examples: Practical usage samples
• Migration Tools: Database schema management
• Testing Support: Unit testing utilities

🏗️ Architecture

Provider Pattern Implementation

Sufficit.EFData/
├── EFProvider<TContext>          # Abstract base provider
├── ScopedProvider               # Scoped service management
├── Extension Methods            # Query extensions
└── DbContext Implementations    # Database contexts

Key Components

EFProvider Base Class

public abstract class EFProvider<DBContext> : ScopedProvider
    where DBContext : Microsoft.EntityFrameworkCore.DbContext
{
    protected EFProvider(IServiceScopeFactory serviceScopeFactory)
        : base(serviceScopeFactory) { }

    protected DBContext CreateDbContext(IServiceScope scope)
        => scope.ServiceProvider.GetRequiredService<DBContext>();
}

Extension Methods Pattern

public static class EFMessageTemplateProviderExtensions
{
    public static async Task<MessageTemplate?> GetByTitleAsync(
        this EFMessageTemplateProvider provider,
        string title,
        CancellationToken cancellationToken = default)
    {
        return await provider.Search(new MessageTemplateSearchParameters
        {
            Title = title
        }).FirstOrDefaultAsync(cancellationToken);
    }
}

Database Context Management

• Scoped Lifetime: DbContext instances are properly scoped
• Connection Pooling: Efficient database connection management
• Transaction Support: ACID transaction handling
• Migration Support: Automatic schema updates

📦 Installation

NuGet Package

# Install via NuGet
dotnet add package Sufficit.EFData

# Or via Package Manager
Install-Package Sufficit.EFData

Package Reference

<PackageReference Include="Sufficit.EFData" Version="1.0.0" />

Prerequisites

• .NET Standard 2.0+ or .NET 6.0+
• Entity Framework Core packages
• Database Provider (MySQL, SQL Server, etc.)

🚀 Usage

Basic Setup

// Program.cs or Startup.cs
using Microsoft.Extensions.DependencyInjection;
using Sufficit.EFData;

public void ConfigureServices(IServiceCollection services)
{
    // Add database context
    services.AddDbContext<ExchangeDbContext>(options =>
        options.UseMySql(connectionString,
            new MySqlServerVersion(new Version(8, 0, 21))));

    // Register providers
    services.AddSufficitEFData();
}

Using Providers

public class MessageService
{
    private readonly EFMessageTemplateProvider _provider;

    public MessageService(EFMessageTemplateProvider provider)
    {
        _provider = provider;
    }

    public async Task<MessageTemplate?> GetTemplateAsync(string title)
    {
        // Using extension method
        return await _provider.GetByTitleAsync(title);
    }

    public async Task<IEnumerable<MessageTemplate>> SearchTemplatesAsync(
        string? searchTerm = null,
        int page = 1,
        int pageSize = 20)
    {
        // Using base Search method
        return await _provider.Search(new MessageTemplateSearchParameters
        {
            Title = searchTerm,
            Paging = new PagingParameters { Page = page, PageSize = pageSize }
        }).ToListAsync();
    }
}

Advanced Queries

public async Task<IEnumerable<MessageTemplate>> GetActiveTemplatesAsync()
{
    return await _provider.Search(new MessageTemplateSearchParameters
    {
        IsActive = true,
        Sorting = new SortingParameters
        {
            SortBy = "CreatedAt",
            SortDirection = SortDirection.Descending
        }
    }).ToListAsync();
}

📚 Modules

Exchange Module

Handles email templates, message tracking, and communication logs.

// Usage
public class EmailService
{
    private readonly EFMessageTemplateProvider _templateProvider;
    private readonly EFEMailTrackingProvider _trackingProvider;

    public async Task SendTemplatedEmailAsync(string templateTitle, string recipient)
    {
        var template = await _templateProvider.GetByTitleAsync(templateTitle);
        if (template == null) return;

        // Send email logic here
        await _trackingProvider.TrackEmailAsync(template.Id, recipient);
    }
}

Identity Module

Manages user authentication and authorization data.

// Register Identity providers
services.AddSufficitIdentityProviders();

// Usage
public class UserService
{
    private readonly EFIdentityProvider _identityProvider;

    public async Task<User?> AuthenticateAsync(string username, string password)
    {
        return await _identityProvider.AuthenticateAsync(username, password);
    }
}

Telephony Module

Handles call records, CDR data, and telephony operations.

// Register Telephony providers
services.AddSufficitTelephonyProviders();

// Usage
public class CallService
{
    private readonly EFCallRecordProvider _callProvider;

    public async Task<IEnumerable<CallRecord>> GetRecentCallsAsync(string extension)
    {
        return await _callProvider.Search(new CallRecordSearchParameters
        {
            Extension = extension,
            DateRange = new DateTimeRange
            {
                Start = DateTime.UtcNow.AddDays(-7),
                End = DateTime.UtcNow
            }
        }).ToListAsync();
    }
}

⚙️ Configuration

Connection Strings

{
  "ConnectionStrings": {
    "ExchangeDb": "Server=localhost;Database=exchange;User=user;Password=password;",
    "IdentityDb": "Server=localhost;Database=identity;User=user;Password=password;",
    "TelephonyDb": "Server=localhost;Database=telephony;User=user;Password=password;"
  }
}

Service Registration

public void ConfigureServices(IServiceCollection services)
{
    // Database contexts
    services.AddDbContext<ExchangeDbContext>(options =>
        options.UseMySql(Configuration.GetConnectionString("ExchangeDb"),
            new MySqlServerVersion(new Version(8, 0, 21))));

    services.AddDbContext<IdentityDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("IdentityDb")));

    // Providers
    services.AddSufficitEFData();
}

Migration Setup

// In Program.cs
using Microsoft.EntityFrameworkCore;

var app = builder.Build();

// Apply migrations
using (var scope = app.Services.CreateScope())
{
    var dbContext = scope.ServiceProvider.GetRequiredService<ExchangeDbContext>();
    await dbContext.Database.MigrateAsync();
}

💻 Development

Project Structure

Sufficit.EFData/
├── src/
│   ├── EFProvider.cs              # Base provider class
│   ├── ScopedProvider.cs          # Scoped service management
│   ├── DEFAULT.cs                 # Constants and utilities
│   ├── Exchange/                  # Exchange domain providers
│   ├── Identity/                  # Identity domain providers
│   ├── Telephony/                 # Telephony domain providers
│   ├── Contacts/                  # Contacts domain providers
│   ├── Finance/                   # Finance domain providers
│   └── Extensions/                # Extension methods
├── tests/                         # Unit tests
├── docs/                          # Documentation
└── migrations-tool/              # Migration utilities

Building the Project

# Restore dependencies
dotnet restore

# Build for all target frameworks
dotnet build --configuration Release

# Run tests
dotnet test

# Create NuGet package
dotnet pack --configuration Release

Testing

// Example unit test
[Fact]
public async Task GetByTitleAsync_ReturnsCorrectTemplate()
{
    // Arrange
    var options = new DbContextOptionsBuilder<ExchangeDbContext>()
        .UseInMemoryDatabase(databaseName: "TestDb")
        .Options;

    using var context = new ExchangeDbContext(options);
    var provider = new EFMessageTemplateProvider(context);

    // Act
    var result = await provider.GetByTitleAsync("Welcome Email");

    // Assert
    Assert.NotNull(result);
    Assert.Equal("Welcome Email", result.Title);
}

🤝 Contributing

We welcome contributions! Please follow these guidelines:

Development Setup

1. Fork the repository

2. Clone your fork

   git clone https://github.com/yourusername/sufficit-efdata.git
   cd sufficit-efdata
   

3. Create a feature branch

   git checkout -b feature/new-provider
   

4. Make your changes

5. Add tests for new functionality

6. Ensure all tests pass

   dotnet test
   

7. Submit a pull request

Code Standards

• Follow C# coding conventions
• Use meaningful variable and method names
• Add XML documentation comments
• Write unit tests for new features
• Ensure code coverage > 80%

Commit Messages

Use conventional commit format:

feat: add new email tracking provider
fix: resolve connection timeout issue
docs: update API documentation
test: add unit tests for message templates

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

Developed by Sufficit Soluções em Tecnologia da Informação

For more information, visit our GitHub repository or contact development@sufficit.com.br.