Soft Delete Example

Overview

This document demonstrates the complete Soft Delete flow using the SoftDeleteShipping feature from the EBusiness application. The flow starts with a DELETE request to the controller and ends with event publishing and subscriber processing. Soft delete marks the entity as deleted without physically removing it from the database.

Complete Flow Architecture

DELETE Request → Controller → Service → PreBus Plugins → Command Handler → RESTClient → External System
                                                                                    ↓
Response ← Controller ← Service ← Command Handler ← RESTClient ← External System

Detailed Flow Breakdown

1. DELETE Request
   ↓
2. Controller (API Entry Point)
   ↓
3. Service Layer (Business Orchestration)
   ↓
4. PreBus Processing (Validation Pipeline)
   ├── SoftDeleteShippingSequence (Plugin Registration)
   ├── SoftDeleteShippingDataPacket (Validation Context)
   └── IsValidShippingForSoftDelete Plugin (Business Rules)
   ↓
5. Command Handler (RESTClient Integration)
   ├── Internal DTO → Request DTO Mapping
   ├── RESTClient Call to External System
   └── Response DTO Processing
   ↓
6. Event Publishing (Asynchronous Processing)
   ↓
7. Subscribers (Side Effects)

Step-by-Step Implementation

1. API Controller - The Entry Point

File: ShippingController_SoftDeleteShipping.cs

[HttpDelete()]
[Route("SoftDeleteShipping/{id}")]
[ProducesResponseType(typeof(BadRequestResult), 400)]
[ProducesResponseType(typeof(string), 200)]
public async Task<IActionResult> SoftDeleteShipping(string id)
{
    SoftDeleteShippingDto dto = new SoftDeleteShippingDto();
    dto.Id = id;
    return await RunService(200, dto, _processShippingService.SoftDeleteShipping);
}

What Happens:

HTTP Method: DELETE /api/Shipping/SoftDeleteShipping/{id}
Input: Shipping ID from URL parameter
DTO Creation: Creates SoftDeleteShippingDto with the ID
Action: Calls the service layer to process the soft delete
Response: HTTP 200 OK with success status

2. Service Layer - Business Orchestration

File: ProcessShippingService_SoftDeleteShipping.cs

public async Task<CommandResult> SoftDeleteShipping(SoftDeleteShippingDto dto)
{
    var packet = await ProcessBusinessRuleSequence<SoftDeleteShippingDataPacket, SoftDeleteShippingSequence, SoftDeleteShippingDto, FlexAppContextBridge>(dto);

    if (packet.HasError)
    {
        return new CommandResult(Status.Failed, packet.Errors());
    }
    else
    {
        dto.SetGeneratedId(_pkGenerator.GenerateKey());
        SoftDeleteShippingCommand cmd = new SoftDeleteShippingCommand
        {
            Dto = dto,
        };

        await ProcessCommand(cmd);

        CommandResult cmdResult = new CommandResult(Status.Success);

        SoftDeleteShippingResultModel outputResult = new SoftDeleteShippingResultModel();
        cmdResult.result = outputResult;
        return cmdResult;
    }
}

What Happens:

PreBus Processing: Executes business rule sequences (plugins)
Validation: Processes business rule sequences
ID Generation: Generates unique key for tracking
Command Creation: Creates SoftDeleteShippingCommand with DTO
Command Processing: Calls the command handler
Result: Returns success status

2.1. PreBus Business Rule Sequence - Validation Pipeline

File: SoftDeleteShippingSequence.cs

public class SoftDeleteShippingSequence : FlexiBusinessRuleSequenceBase<SoftDeleteShippingDataPacket>
{
    public SoftDeleteShippingSequence()
    {
        this.Add<IsValidShippingForSoftDelete>(); 
    }
}

What Happens:

Plugin Registration: Registers validation plugins in execution order
Sequential Processing: Executes plugins one by one
Error Collection: Collects validation errors from all plugins
Early Exit: Stops processing if any plugin fails

2.2. PreBus Data Packet - Validation Context

File: SoftDeleteShippingDataPacket.cs

public partial class SoftDeleteShippingDataPacket : FlexiFlowDataPacketWithDtoBridge<SoftDeleteShippingDto, FlexAppContextBridge>
{
    protected readonly ILogger<SoftDeleteShippingDataPacket> _logger;

    public SoftDeleteShippingDataPacket(ILogger<SoftDeleteShippingDataPacket> logger)
    {
        _logger = logger;
    }

    #region "Properties
    //Models and other properties goes here
    #endregion
}

What Happens:

Context Container: Holds DTO and application context
Error Collection: Collects validation errors from plugins
Data Sharing: Allows plugins to share data during validation
Logging: Provides logging capabilities for plugins

2.3. PreBus Validation Plugin - Business Rules

File: IsValidShippingForSoftDelete.cs

public partial class IsValidShippingForSoftDelete : FlexiBusinessRuleBase, IFlexiBusinessRule<SoftDeleteShippingDataPacket>
{
    public override string Id { get; set; } = "3a1cd5b1fa98b4c63378de9607706082";
    public override string FriendlyName { get; set; } = "IsValidShippingForSoftDelete";

    protected readonly ILogger<IsValidShippingForSoftDelete> _logger;
    protected readonly RepoFactory _repoFactory;

    public IsValidShippingForSoftDelete(ILogger<IsValidShippingForSoftDelete> logger, RepoFactory repoFactory)
    {
        _logger = logger;
        _repoFactory = repoFactory;
    }

    public virtual async Task Validate(SoftDeleteShippingDataPacket packet)
    {
        //Uncomment the below line if validating against a db data using your repo
        //_repoFactory.Init(packet.Dto);

        //If any validation fails, uncomment and use the below line of code to add error to the packet
        //packet.AddError("key", "ErrorMessage");

        await Task.CompletedTask; //If you have any await in the validation, remove this line
    }
}

What Happens:

Business Rule Validation: Implements specific validation logic
Database Access: Can access repository for data validation
Error Reporting: Adds errors to the data packet if validation fails
Async Support: Supports asynchronous validation operations
Dependency Injection: Receives logger and repository factory

3. Command Handler - RESTClient Integration

File: SoftDeleteShippingHandler.cs

public partial class SoftDeleteShippingHandler : ISoftDeleteShippingHandler
{
    protected string EventCondition = "";
    protected readonly ILogger<SoftDeleteShippingHandler> _logger;
    protected readonly IFlexHost _flexHost;
    protected ShippingRESTClient _restClient;
    protected FlexAppContextBridge? _flexAppContext;

    public SoftDeleteShippingHandler(ILogger<SoftDeleteShippingHandler> logger, IFlexHost flexHost, ShippingRESTClient restClient)
    {
        _logger = logger;
        _flexHost = flexHost;
        _restClient = restClient;
    }

    public virtual async Task Execute(SoftDeleteShippingCommand cmd, IFlexServiceBusContext serviceBusContext)
    {
        // Convert internal DTO to Request DTO
        SoftDeleteShippingRequestDto requestParams = new SoftDeleteShippingRequestDto
        {
            Id = cmd.Dto.Id,
            DeletionReason = cmd.Dto.DeletionReason ?? "User requested soft deletion",
            SoftDeleteFlag = true
        };

        // Call external REST service
        var response = await _restClient.SoftDeleteShipping(requestParams);

        // Process response
        if (response.IsSuccessStatusCode)
        {
            var responseContent = await response.Content.ReadAsStringAsync();
            var responseDto = JsonConvert.DeserializeObject<SoftDeleteShippingResponseDto>(responseContent);
            
            _logger.LogDebug("Shipping soft deleted successfully with external ID: {ExternalId}", responseDto?.Id);
            
            // Set success condition for event firing
            EventCondition = "CONDITION_ONSUCCESS";
        }
        else
        {
            _logger.LogError("Failed to soft delete shipping. Status: {StatusCode}", response.StatusCode);
            EventCondition = "CONDITION_ONFAILED";
        }

        await this.Fire(EventCondition, serviceBusContext);
    }
}

What Happens:

DTO Mapping: Converts internal DTO to Request DTO for external system
RESTClient Call: Calls external shipping service via RESTClient
Response Processing: Handles success/failure responses from external system
Logging: Logs success/failure of external service call
Event Publishing: Fires events based on external service result

4. Domain Model - Business Logic

File: Shipping/SoftDeleteShipping.cs

public virtual Shipping SoftDeleteShipping(SoftDeleteShippingCommand cmd)
{
    Guard.AgainstNull("Shipping model cannot be empty", cmd);

    this.Id = cmd.Dto.Id;
    this.SetSoftDeleted();

    //Set your appropriate SetSoftDeleted for the inner object here

    return this;
}

What Happens:

Validation: Guards against null commands
ID Assignment: Sets the shipping ID from DTO
State Management: Marks entity as soft deleted
Child Objects: Processes child object soft deletions

5. NServiceBus Handler - Message Processing

File: SoftDeleteShippingNsbHandler.cs

public class SoftDeleteShippingNsbHandler : NsbCommandHandler<SoftDeleteShippingCommand>
{
    readonly ILogger<SoftDeleteShippingNsbHandler> _logger;
    readonly IFlexHost _flexHost;
    readonly ISoftDeleteShippingHandler _handler;

    public SoftDeleteShippingNsbHandler(ILogger<SoftDeleteShippingNsbHandler> logger, IFlexHost flexHost, ISoftDeleteShippingHandler handler)
    {
        _logger = logger;
        _flexHost = flexHost;
        _handler = handler;
    }

    public override async Task Handle(SoftDeleteShippingCommand message, IMessageHandlerContext context)
    {
        _logger.LogTrace($"Executing {nameof(SoftDeleteShippingNsbHandler)}");

        await _handler.Execute(message, new NsbHandlerContextBridge(context));
    }
}

What Happens:

Message Reception: Receives SoftDeleteShippingCommand from message bus
Logging: Logs handler execution
Delegation: Calls the actual command handler
Context Bridge: Converts NServiceBus context to FlexBase context

6. Event Publishing - Asynchronous Processing

Event: ShippingSoftDeletedEvent (if implemented)

public class ShippingSoftDeletedEvent : FlexEventBridge<FlexAppContextBridge>
{
    // Event data is automatically populated by FlexBase
}

What Happens:

Event Creation: FlexBase creates event with shipping data
Message Bus: Event is published to message bus
Subscriber Notification: All subscribers are notified

7. Event Subscribers - Side Effects

File: NotifyLogisticsOnShippingSoftDeleted.cs (if implemented)

public partial class NotifyLogisticsOnShippingSoftDeleted : INotifyLogisticsOnShippingSoftDeleted
{
    protected readonly ILogger<NotifyLogisticsOnShippingSoftDeleted> _logger;
    protected string EventCondition = "";

    public NotifyLogisticsOnShippingSoftDeleted(ILogger<NotifyLogisticsOnShippingSoftDeleted> logger)
    {
        _logger = logger;
    }

    public virtual async Task Execute(ShippingSoftDeletedEvent @event, IFlexServiceBusContext serviceBusContext)
    {
        _flexAppContext = @event.AppContext;

        //TODO: Write your business logic here:
        // - Update logistics systems
        // - Notify carriers of cancellation
        // - Update analytics
        // - Archive related data

        await this.Fire<NotifyLogisticsOnShippingSoftDeleted>(EventCondition, serviceBusContext);
    }
}

What Happens:

Event Reception: Receives ShippingSoftDeletedEvent from message bus
Side Effects: Executes business logic (logistics updates, notifications, etc.)
Additional Events: Can fire more events if needed

Data Transfer Objects (DTOs)

Input DTO: `SoftDeleteShippingDto`

public partial class SoftDeleteShippingDto : DtoBridge 
{
    public string Id { get; set; }
    
    // Optional: Reason for soft delete
    public string DeletionReason { get; set; }
}

Command: `SoftDeleteShippingCommand`

public class SoftDeleteShippingCommand : FlexCommandBridge<SoftDeleteShippingDto, FlexAppContextBridge>
{
    // Command data is automatically populated by FlexBase
}

Key Differences from Hard Delete

Soft Delete vs Hard Delete Characteristics

Aspect

Soft Delete

Hard Delete

Data Persistence

✅ Data remains in database

❌ Data physically removed

Recovery

✅ Can be restored

❌ Cannot be recovered

Audit Trail

✅ Complete history maintained

❌ History lost

Performance

✅ Fast (just flag update)

✅ Fast (row deletion)

Storage

❌ Uses more storage

✅ Frees storage

Queries

❌ Need to filter deleted items

✅ No filtering needed

Business Rules

✅ Can validate before delete

Soft Delete-Specific Features

Data Preservation: Entity remains in database with deleted flag
Recovery: Can be restored if needed
Audit Trail: Maintains complete history
Query Filtering: Queries must filter out soft-deleted items
Business Logic: Can implement complex deletion rules

Soft Delete Pattern Benefits

Data Safety: No accidental data loss
Compliance: Meets regulatory requirements for data retention
Audit Trail: Complete history of all operations
Recovery: Can restore deleted data if needed
Business Rules: Can implement complex deletion logic

Flow Summary

Synchronous Flow (Immediate Response)

DELETE Request → Controller receives request with ID
Service Processing → Business orchestration and PreBus validation
PreBus Plugins → Sequential validation of business rules
Command Handler → Data processing and soft delete
Domain Logic → Business rules and state management
Response → HTTP 200 OK with success status

Asynchronous Flow (Event Processing)

Event Publishing → ShippingSoftDeletedEvent published to message bus
Subscriber Processing → NotifyLogisticsOnShippingSoftDeleted executes
Side Effects → Logistics updates, carrier notifications, analytics

Query Filtering for Soft Deleted Items

Standard Query Filtering

// In query handlers, always filter out soft deleted items
protected override IQueryable<T> Build<T>()
{
    _repoFactory.Init(_params);
    IQueryable<T> query = _repoFactory.GetRepo().FindAll<T>();
    
    // Always exclude soft deleted items
    query = query.Where(s => !s.IsSoftDeleted);
    
    // Add other filtering logic here
    
    return query;
}

Include Soft Deleted Items (Admin Queries)

// For admin queries that need to see soft deleted items
protected override IQueryable<T> Build<T>()
{
    _repoFactory.Init(_params);
    IQueryable<T> query = _repoFactory.GetRepo().FindAll<T>();
    
    // Only include soft deleted items if specifically requested
    if (_params.IncludeSoftDeleted == true)
    {
        // Don't filter out soft deleted items
    }
    else
    {
        query = query.Where(s => !s.IsSoftDeleted);
    }
    
    return query;
}

Key Benefits

Data Safety: No accidental data loss
Compliance: Meets regulatory requirements
Audit Trail: Complete history of operations
Recovery: Can restore deleted data
Business Rules: Complex deletion logic support
Event-Driven: Notifies other systems of deletions
Testable: Each component can be tested independently
Maintainable: Clear separation of concerns

This SoftDeleteShipping example demonstrates how FlexBase enables clean, maintainable, and scalable soft delete operations with proper validation, data preservation, and event-driven architecture! 🚀

PreviousDelete Example NextGet By Id Example

Last updated 0 minutes ago

Overview

Complete Flow Architecture

Detailed Flow Breakdown

Step-by-Step Implementation

1. API Controller - The Entry Point

2. Service Layer - Business Orchestration

2.1. PreBus Business Rule Sequence - Validation Pipeline

2.2. PreBus Data Packet - Validation Context

2.3. PreBus Validation Plugin - Business Rules

3. Command Handler - RESTClient Integration

4. Domain Model - Business Logic

5. NServiceBus Handler - Message Processing

6. Event Publishing - Asynchronous Processing

7. Event Subscribers - Side Effects

Data Transfer Objects (DTOs)

Input DTO: SoftDeleteShippingDto

Command: SoftDeleteShippingCommand

Key Differences from Hard Delete

Soft Delete vs Hard Delete Characteristics

Soft Delete-Specific Features

Soft Delete Pattern Benefits

Flow Summary

Synchronous Flow (Immediate Response)

Asynchronous Flow (Event Processing)

Query Filtering for Soft Deleted Items

Standard Query Filtering

Include Soft Deleted Items (Admin Queries)

Key Benefits

Input DTO: `SoftDeleteShippingDto`

Command: `SoftDeleteShippingCommand`