public sealed class OrderService : IOrderService
{
private readonly IOrderRepository _repository;
private readonly ILogger<OrderService> _logger;
public OrderService(IOrderRepository repository, ILogger<OrderService> logger)
{
_repository = repository;
_logger = logger;
}
public async Task<Result<OrderDto>> CreateAsync(CreateOrderRequest request, CancellationToken ct)
{
var order = Order.Create(request.CustomerId, request.Items);
await _repository.AddAsync(order, ct);
await _repository.SaveChangesAsync(ct);
_logger.LogInformation("Order {OrderId} created for customer {CustomerId}", order.Id, order.CustomerId);
return Result.Success(order.ToDto());
}
}
[ApiController]
[Route("api/v1/[controller]")]
public class OrdersController : ControllerBase
{
private readonly IOrderService _orderService;
public OrdersController(IOrderService orderService) => _orderService = orderService;
[HttpPost]
public async Task<IActionResult> Create([FromBody] CreateOrderRequest request, CancellationToken ct)
{
var result = await _orderService.CreateAsync(request, ct);
return result.IsSuccess ? Ok(result.Value) : BadRequest(result.Error);
}
}
public sealed class OrderService : IOrderService
{
private readonly IOrderRepository _repository;
private readonly ILogger<OrderService> _logger;
public OrderService(IOrderRepository repository, ILogger<OrderService> logger)
{
_repository = repository;
_logger = logger;
}
public async Task<Result<OrderDto>> CreateAsync(CreateOrderRequest request, CancellationToken ct)
{
var order = Order.Create(request.CustomerId, request.Items);
await _repository.AddAsync(order, ct);
await _repository.SaveChangesAsync(ct);
_logger.LogInformation("Order {OrderId} created for customer {CustomerId}", order.Id, order.CustomerId);
return Result.Success(order.ToDto());
}
}
[ApiController]
[Route("api/v1/[controller]")]
public class OrdersController : ControllerBase
{
private readonly IOrderService _orderService;
public OrdersController(IOrderService orderService) => _orderService = orderService;
[HttpPost]
public async Task<IActionResult> Create([FromBody] CreateOrderRequest request, CancellationToken ct)
{
var result = await _orderService.CreateAsync(request, ct);
return result.IsSuccess ? Ok(result.Value) : BadRequest(result.Error);
}
}
public sealed class OrderService : IOrderService
{
private readonly IOrderRepository _repository;
private readonly ILogger<OrderService> _logger;
public OrderService(IOrderRepository repository, ILogger<OrderService> logger)
{
_repository = repository;
_logger = logger;
}
public async Task<Result<OrderDto>> CreateAsync(CreateOrderRequest request, CancellationToken ct)
{
var order = Order.Create(request.CustomerId, request.Items);
await _repository.AddAsync(order, ct);
await _repository.SaveChangesAsync(ct);
_logger.LogInformation("Order {OrderId} created for customer {CustomerId}", order.Id, order.CustomerId);
return Result.Success(order.ToDto());
}
}
[ApiController]
[Route("api/v1/[controller]")]
public class OrdersController : ControllerBase
{
private readonly IOrderService _orderService;
public OrdersController(IOrderService orderService) => _orderService = orderService;
[HttpPost]
public async Task<IActionResult> Create([FromBody] CreateOrderRequest request, CancellationToken ct)
{
var result = await _orderService.CreateAsync(request, ct);
return result.IsSuccess ? Ok(result.Value) : BadRequest(result.Error);
}
}
public sealed class OrderService : IOrderService
{
private readonly IOrderRepository _repository;
private readonly ILogger<OrderService> _logger;
public OrderService(IOrderRepository repository, ILogger<OrderService> logger)
{
_repository = repository;
_logger = logger;
}
public async Task<Result<OrderDto>> CreateAsync(CreateOrderRequest request, CancellationToken ct)
{
var order = Order.Create(request.CustomerId, request.Items);
await _repository.AddAsync(order, ct);
await _repository.SaveChangesAsync(ct);
_logger.LogInformation("Order {OrderId} created for customer {CustomerId}", order.Id, order.CustomerId);
return Result.Success(order.ToDto());
}
}
[ApiController]
[Route("api/v1/[controller]")]
public class OrdersController : ControllerBase
{
private readonly IOrderService _orderService;
public OrdersController(IOrderService orderService) => _orderService = orderService;
[HttpPost]
public async Task<IActionResult> Create([FromBody] CreateOrderRequest request, CancellationToken ct)
{
var result = await _orderService.CreateAsync(request, ct);
return result.IsSuccess ? Ok(result.Value) : BadRequest(result.Error);
}
}
public sealed class OrderService : IOrderService
{
private readonly IOrderRepository _repository;
private readonly ILogger<OrderService> _logger;
public OrderService(IOrderRepository repository, ILogger<OrderService> logger)
{
_repository = repository;
_logger = logger;
}
public async Task<Result<OrderDto>> CreateAsync(CreateOrderRequest request, CancellationToken ct)
{
var order = Order.Create(request.CustomerId, request.Items);
await _repository.AddAsync(order, ct);
await _repository.SaveChangesAsync(ct);
_logger.LogInformation("Order {OrderId} created for customer {CustomerId}", order.Id, order.CustomerId);
return Result.Success(order.ToDto());
}
}
[ApiController]
[Route("api/v1/[controller]")]
public class OrdersController : ControllerBase
{
private readonly IOrderService _orderService;
public OrdersController(IOrderService orderService) => _orderService = orderService;
[HttpPost]
public async Task<IActionResult> Create([FromBody] CreateOrderRequest request, CancellationToken ct)
{
var result = await _orderService.CreateAsync(request, ct);
return result.IsSuccess ? Ok(result.Value) : BadRequest(result.Error);
}
}
public sealed class OrderService : IOrderService
{
private readonly IOrderRepository _repository;
private readonly ILogger<OrderService> _logger;
public OrderService(IOrderRepository repository, ILogger<OrderService> logger)
{
_repository = repository;
_logger = logger;
}
public async Task<Result<OrderDto>> CreateAsync(CreateOrderRequest request, CancellationToken ct)
{
var order = Order.Create(request.CustomerId, request.Items);
await _repository.AddAsync(order, ct);
await _repository.SaveChangesAsync(ct);
_logger.LogInformation("Order {OrderId} created for customer {CustomerId}", order.Id, order.CustomerId);
return Result.Success(order.ToDto());
}
}
[ApiController]
[Route("api/v1/[controller]")]
public class OrdersController : ControllerBase
{
private readonly IOrderService _orderService;
public OrdersController(IOrderService orderService) => _orderService = orderService;
[HttpPost]
public async Task<IActionResult> Create([FromBody] CreateOrderRequest request, CancellationToken ct)
{
var result = await _orderService.CreateAsync(request, ct);
return result.IsSuccess ? Ok(result.Value) : BadRequest(result.Error);
}
}
public sealed class OrderService : IOrderService
{
private readonly IOrderRepository _repository;
private readonly ILogger<OrderService> _logger;
public OrderService(IOrderRepository repository, ILogger<OrderService> logger)
{
_repository = repository;
_logger = logger;
}
public async Task<Result<OrderDto>> CreateAsync(CreateOrderRequest request, CancellationToken ct)
{
var order = Order.Create(request.CustomerId, request.Items);
await _repository.AddAsync(order, ct);
await _repository.SaveChangesAsync(ct);
_logger.LogInformation("Order {OrderId} created for customer {CustomerId}", order.Id, order.CustomerId);
return Result.Success(order.ToDto());
}
}
[ApiController]
[Route("api/v1/[controller]")]
public class OrdersController : ControllerBase
{
private readonly IOrderService _orderService;
public OrdersController(IOrderService orderService) => _orderService = orderService;
[HttpPost]
public async Task<IActionResult> Create([FromBody] CreateOrderRequest request, CancellationToken ct)
{
var result = await _orderService.CreateAsync(request, ct);
return result.IsSuccess ? Ok(result.Value) : BadRequest(result.Error);
}
}
public sealed class OrderService : IOrderService
{
private readonly IOrderRepository _repository;
private readonly ILogger<OrderService> _logger;
public OrderService(IOrderRepository repository, ILogger<OrderService> logger)
{
_repository = repository;
_logger = logger;
}
public async Task<Result<OrderDto>> CreateAsync(CreateOrderRequest request, CancellationToken ct)
{
var order = Order.Create(request.CustomerId, request.Items);
await _repository.AddAsync(order, ct);
await _repository.SaveChangesAsync(ct);
_logger.LogInformation("Order {OrderId} created for customer {CustomerId}", order.Id, order.CustomerId);
return Result.Success(order.ToDto());
}
}
[ApiController]
[Route("api/v1/[controller]")]
public class OrdersController : ControllerBase
{
private readonly IOrderService _orderService;
public OrdersController(IOrderService orderService) => _orderService = orderService;
[HttpPost]
public async Task<IActionResult> Create([FromBody] CreateOrderRequest request, CancellationToken ct)
{
var result = await _orderService.CreateAsync(request, ct);
return result.IsSuccess ? Ok(result.Value) : BadRequest(result.Error);
}
}
public sealed class OrderService : IOrderService
{
private readonly IOrderRepository _repository;
private readonly ILogger<OrderService> _logger;
public OrderService(IOrderRepository repository, ILogger<OrderService> logger)
{
_repository = repository;
_logger = logger;
}
public async Task<Result<OrderDto>> CreateAsync(CreateOrderRequest request, CancellationToken ct)
{
var order = Order.Create(request.CustomerId, request.Items);
await _repository.AddAsync(order, ct);
await _repository.SaveChangesAsync(ct);
_logger.LogInformation("Order {OrderId} created for customer {CustomerId}", order.Id, order.CustomerId);
return Result.Success(order.ToDto());
}
}
[ApiController]
[Route("api/v1/[controller]")]
public class OrdersController : ControllerBase
{
private readonly IOrderService _orderService;
public OrdersController(IOrderService orderService) => _orderService = orderService;
[HttpPost]
public async Task<IActionResult> Create([FromBody] CreateOrderRequest request, CancellationToken ct)
{
var result = await _orderService.CreateAsync(request, ct);
return result.IsSuccess ? Ok(result.Value) : BadRequest(result.Error);
}
}
public sealed class OrderService : IOrderService
{
private readonly IOrderRepository _repository;
private readonly ILogger<OrderService> _logger;
public OrderService(IOrderRepository repository, ILogger<OrderService> logger)
{
_repository = repository;
_logger = logger;
}
public async Task<Result<OrderDto>> CreateAsync(CreateOrderRequest request, CancellationToken ct)
{
var order = Order.Create(request.CustomerId, request.Items);
await _repository.AddAsync(order, ct);
await _repository.SaveChangesAsync(ct);
_logger.LogInformation("Order {OrderId} created for customer {CustomerId}", order.Id, order.CustomerId);
return Result.Success(order.ToDto());
}
}
[ApiController]
[Route("api/v1/[controller]")]
public class OrdersController : ControllerBase
{
private readonly IOrderService _orderService;
public OrdersController(IOrderService orderService) => _orderService = orderService;
[HttpPost]
public async Task<IActionResult> Create([FromBody] CreateOrderRequest request, CancellationToken ct)
{
var result = await _orderService.CreateAsync(request, ct);
return result.IsSuccess ? Ok(result.Value) : BadRequest(result.Error);
}
}
Hi, I'm
Weronika Głąbik
— senior backend developer.
.NET / C# Developer · Azure/AWS Cloud · 6 + years in production systems
Poland
I design and build reliable APIs and cloud-native systems in C# and Azure/AWS —
full-scale platforms used by multicultural, international teams. Clean code,
clear documentation.
C# · ASP.NET
Azure/AWS
REST API
SQL Server · PostgreSQL
DDD · CQRS
Scrum