Modern Architecture Shop (Clean Architecture And Microservices)

• User Interface
• Database
• Use Cases
• Domain

Clean Architecture Circle Diagram from Uncle Bob book

Benefits

• Independent of Database
• Independent of Frameworks
• Effective testable
• Independent of any external agency
• All business logic is in use cases

Clean architecture can solve the below-listed problems:

• Decisions are taken too early
• It's hard to change,
• It's centered around frameworks
• It's centered around the database
• We focus on technical aspects
• It's hard to find things
• Business logic is spread everywhere
• Heavy tests

ModernArchitectureShop architecture

Architecture Overview

Each domain service is divided into four parts:

.Domain

It contains only the POCOs and related domain events.

.Application

It contains the Uses Cases, Interfaces for the infrastructure, and other business logic stuff.

.Infrastructure

It contains Infrastructure stuff like databases etc.

.Api

The WebAPI stuff.

Note
StoreApi and the BasketApi assemblies are mixing the Infrastructure and the WebAPI and the Application Logic. In the next version, I will separate them according to the clean architecture principles.

ModernArchitectureShop.BlazorUI Service

In the ModernArchitectureShop.BlazorUI.Startup.cs I have registered all services, and I have added the HTTP clients to the services.

HTTP Clients

IdentityService.cs

Is responsible for the login/logout

ProductService.cs

Retrieves all products from the Store and display them the Products.razor

BasketProductService.cs

It manages the basket, for example, adding or removing items to/from the basket.

ModernArchitectureShop.StoreApi Service

The WebApi for the Store.

Controllers

ProductsController.cs loads the products from the store service and forward them to the BlazorUI as follows,

public async Task<IActionResult> GetProducts([FromQuery]    
GetProductsCommand command)    
{    
  var result = await _mediator.Send(command);    
  return Ok(result);    
}

The MediatR design pattern is used to reduce the dependencies between objects.

As shown below, the GetProductsHanlder is called from the mediator.

public async Task<GetProductsCommandResponse>    
Handle(GetProductsCommand command, CancellationToken cancellationToken)    
{    
  var query = _dbContext.Set<Product>();    
    
  var totalOfProducts = await query.CountAsync(cancellationToken);    
  var products = await query.AsNoTracking()    
    .OrderBy(x => x.Code)    
    .Skip((command.PageIndex - 1) \* command.PageSize)    
    .Take(command.PageSize)    
    .Include(x => x.ProductStores)    
    .ThenInclude(x => x.Store)    
    .ProjectTo<ProductDto>(_mapper.ConfigurationProvider)    
    .ToListAsync(cancellationToken);    
    
   var result = new GetProductsCommandResponse    
   {    
    Products = products,    
    TotalOfProducts = totalOfProducts    
   };    
    
  return result;    
}

The data is displayed in the products.razor, as follows:

protected override async Task OnParametersSetAsync()    
{    
  var response = await ProductService.GetProductsAsync(ProcessUrl());    
    
  if (response.StatusCode == (int) System.Net.HttpStatusCode.OK)    
  {    
    _productsModel =JsonConvert.DeserializeObject<ProductsModel>(response.Content);    
  }    
  else    
  {    
    _errorMessage = $"Error: {response.Error}";    
    _productsModel = new ProductsModel();    
  }    
}

The response above contains the products and the count. Finally, the products are displayed, as shown below.

protected override async Task OnParametersSetAsync()    
{    
  var response = await ProductService.GetProductsAsync(ProcessUrl());    
    
  if (response.StatusCode == (int) System.Net.HttpStatusCode.OK)    
  {    
    _productsModel =JsonConvert.DeserializeObject<ProductsModel>(response.Content);    
  }    
  else    
  {    
    _errorMessage = $"Error: {response.Error}";    
    _productsModel = new ProductsModel();    
  }    
} 

ModernArchitectureShop.BasketApi

It contains tow controllers: ItemController.cs and ItemsController.cs

ItemController creates and deletes items to/from the basket.

ItemsController retrieves items from the database.

Again, here I have used MediatR:

\\Application\\UsesCases\\AddItemHandler    
    
public async Task<ItemDto> Handle(AddItemCommand command, CancellationToken cancellationToken)    
{    
  var itemFromCommand = _mapper.Map<Item>(command);    
  var items = _dbContext.Set<Item>();    
    
  var itemFromDb = await items.SingleOrDefaultAsync(x => x.ItemId ==  command.ItemId, cancellationToken: cancellationToken);    
    
  if (itemFromDb != null)    
  {    
    _mapper.Map(itemFromCommand, itemFromDb);    
    items.Update(itemFromDb);    
  }    
  else    
  {    
    await _dbContext.Items.AddAsync(itemFromCommand, cancellationToken);    
  }    
    
  await _dbContext.SaveChangesAsync(cancellationToken);    
  await _itemCreatedNotificationHandler.Handle(new ItemCreatedMessage(), cancellationToken);    
    
  return _mapper.Map<ItemDto>(itemFromCommand);    
}

Once the items are added to the database, the ItemCreatedMessage.cs (Dapr) message is being published to the Store. We need this message, for example, to update the reserved items.

\\Application\\UsesCases\\GetItemsHandler    
    
public async Task<GetItemsCommandResponse> Handle(GetItemsCommand command, CancellationToken cancellationToken)    
{    
  var query = _dbContext.Set<Item>();    
    
  var totalOfItems = await query.Where(i => i.Username == command.Username).CountAsync(cancellationToken);    
  var items = await query.AsNoTracking()    
    .OrderBy(x => x.Code)    
    .Skip((command.PageIndex - 1) \* command.PageSize)    
    .Take(command.PageSize)    
    .ProjectTo<ItemDto>(_mapper.ConfigurationProvider)    
    .Where(i => i.Username == command.Username)    
    .ToListAsync(cancellationToken);    
    
  var result = new GetItemsCommandResponse    
  {    
    Items = items,    
    TotalOfItems = totalOfItems,    
  };    
    
 return result;    
}

The code above fetches the items and returns them to the UI host, then items.razor can display them.

Summary

ModernArchitectureShop is a modern light microservices application. We have seen that the current implementation is not ideal, and it needs some cleanups. In the next article, I will decouple the application from the infrastructure, and I will extend the project.

Tye Dashboard

Zipkin