MasLazu.AspNet.Authorization.Core 1.0.0-preview.7

MasLazu.AspNet.Authorization.Core

This project contains the core implementation of the MasLazu ASP.NET Authorization system. It provides concrete implementations of the service interfaces defined in the Abstraction layer, along with dependency injection registrations, validation rules, and utility classes.

Overview

The Core layer serves as the main implementation hub, bringing together the abstractions, domain entities, and framework components to provide a complete authorization system. It implements the business logic through service classes and handles cross-cutting concerns like validation and dependency injection.

Architecture

The project follows a modular architecture with clear separation of concerns:

Core Layer
├── Services/          # Business logic implementations
├── Extensions/        # Dependency injection registrations
├── Validators/        # Input validation rules
└── Utils/            # Property mapping utilities

Services

The project implements all service interfaces from the Abstraction layer using the framework's CrudService<T> base class:

Implemented Services

1. ActionService - Implements IActionService
2. PermissionService - Implements IPermissionService
3. PermissionTypeService - Implements IPermissionTypeService
4. ResourceService - Implements IResourceService
5. ResourceActionService - Implements IResourceActionService

Each service inherits from CrudService<TEntity, TDto, TCreateRequest, TUpdateRequest> and provides full CRUD operations with:

• Repository pattern for data access
• Unit of work for transaction management
• Validation integration
• Property mapping for sorting and filtering

Extensions

The Extensions folder contains dependency injection setup classes:

AuthorizationCoreApplicationExtension

Main extension method that registers all components:

services.AddAuthorizationCoreApplication();

AuthorizationCoreApplicationServiceExtension

Registers all service implementations in the DI container.

AuthorizationCoreApplicationUtilExtension

Registers property maps and expression builders for dynamic querying and sorting.

AuthorizationCoreApplicationValidatorExtension

Registers all FluentValidation validators for request validation.

Validators

Comprehensive validation rules using FluentValidation:

Create Validators

• CreateActionRequestValidator
• CreatePermissionRequestValidator
• CreatePermissionTypeRequestValidator
• CreateResourceRequestValidator
• CreateResourceActionRequestValidator

Update Validators

• UpdateActionRequestValidator
• UpdatePermissionRequestValidator
• UpdatePermissionTypeRequestValidator
• UpdateResourceRequestValidator
• UpdateResourceActionRequestValidator

Validation Rules

Common validation patterns include:

• Required fields (NotEmpty)
• Maximum length constraints
• Format validation where applicable

Utils (Property Maps)

Property mapping classes for dynamic sorting and filtering:

• ActionEntityPropertyMap
• PermissionEntityPropertyMap
• PermissionTypeEntityPropertyMap
• ResourceEntityPropertyMap
• ResourceActionEntityPropertyMap

Each map implements IEntityPropertyMap<TEntity> and provides:

• Case-insensitive property name mapping
• Expression trees for LINQ queries
• Support for common properties (id, code, name, timestamps)

Dependencies

This project depends on:

• MasLazu.AspNet.Authorization.Core.Abstraction - Service interfaces and DTOs
• MasLazu.AspNet.Authorization.Core.Domain - Domain entities
• FluentValidation - Input validation framework
• Microsoft.Extensions.DependencyInjection - DI container
• MasLazu.AspNet.Framework.Application - Base service classes and interfaces

Usage

Basic Setup

var services = new ServiceCollection();

// Add the complete authorization system
services.AddAuthorizationCoreApplication();

// Additional setup (repositories, database context, etc.)
// ...

var serviceProvider = services.BuildServiceProvider();

Individual Component Registration

// Register only services
services.AddAuthorizationCoreApplicationServices();

// Register only validators
services.AddAuthorizationCoreApplicationValidators();

// Register only utilities
services.AddAuthorizationCoreApplicationUtils();

Service Usage

// Inject services
private readonly IActionService _actionService;

// Use CRUD operations
var actions = await _actionService.GetAllAsync();
var action = await _actionService.GetByIdAsync(id);
await _actionService.CreateAsync(request);
await _actionService.UpdateAsync(request);
await _actionService.DeleteAsync(id);

Integration

This Core project integrates with:

• EF Core Layer: Provides data access implementations
• Endpoint Layer: Exposes HTTP APIs
• Application Layer: Orchestrates business operations

The Core layer acts as the central orchestrator, coordinating between the abstraction contracts and concrete implementations while providing a clean API for higher-level components.