public async Task <IActionResult> Handle(ChangePasswordCommand request, CancellationToken cancellationToken)
{
_logger.LogDebug("Change password attempt for user ID {0}", request.UserId);
var user = await _context.Users.FindAsync(request.UserId);
if (user == null)
{
return(new NotFoundObjectResult(new ErrorModel(ErrorMessages.NotFound, ErrorCodes.NotFound)));
}
if (request.NewPassword != request.RepeatPassword)
{
return(new BadRequestObjectResult(new ErrorModel("Password baru tidak cocok",
ErrorCodes.ModelValidation)));
}
if (!BCrypt.Net.BCrypt.Verify(request.OldPassword, user.Password))
{
return(new UnauthorizedObjectResult(new ErrorModel("Password lama tidak cocok", ErrorCodes.Forbidden)));
}
user.Password = BCrypt.Net.BCrypt.HashPassword(request.NewPassword);
_context.Users.Update(user);
await _context.SaveChangesAsync(cancellationToken);
_logger.LogInformation("Change password attempt for user ID {0} success", user.UserId);
return(new OkResult());
}
public async Task <IActionResult> Handle(CreateSupplierOrderCommand request, CancellationToken cancellationToken)
{
var user = await _context.Users.FindAsync(_httpContext.GetUserIdFromClaim());
var supplier = await _context.Suppliers.FindAsync(request.SupplierId);
var order = new Order
{
Supplier = supplier,
PicUser = user
};
var orderDetails = await Task.WhenAll(request.Products.Select(async x =>
{
var product = await _context.Products.FindAsync(x.ProductId);
return(new OrderDetail
{
UnitPrice = product.Price,
TotalPrice = product.Price *x.Quantity,
TotalWeight = product.Weight *x.Quantity,
Quantity = x.Quantity,
Unit = product.Unit,
Product = product,
Order = order
});
}));
var orderStatusHistory = new List <OrderStatus>
{
new()
{
Code = OrderStatusCode.Requested,
Message = "Pesanan disimpan dan menunggu diproses.",
Order = order
}
};
order.Type = OrderType.Supplier;
order.StatusHistory = orderStatusHistory;
order.OrderDetails = orderDetails;
order.TotalSales = orderDetails.Sum(x => x.TotalPrice);
order.TotalWeight = orderDetails.Sum(x => x.TotalWeight);
order.TotalShipping = supplier.ShippingCost * (decimal)order.TotalWeight; // shipping from supplier
order.TotalTax = order.TotalSales * _config.TaxRate;
order.SubTotal = order.TotalSales + order.TotalShipping + order.TotalTax;
await _context.Orders.AddAsync(order, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
_logger.LogInformation("Created order with ID {0}", order.OrderId);
return(new JsonResult(_mapper.Map <OrderDto>(order)));
}
}
public async Task <IActionResult> Handle(EditUserCommand request, CancellationToken cancellationToken)
{
var user = await _context.Users.FindAsync(request.UserId);
if (user == null)
{
return(new NotFoundObjectResult(new ErrorModel(ErrorMessages.NotFound, ErrorCodes.NotFound)));
}
// make sure no duplicate fullname
if (request.Body?.FullName != null && !string.Equals(user.FullName, request.Body.FullName, StringComparison.InvariantCultureIgnoreCase))
{
if (await _context.Users.AnyAsync(x => x.FullName.ToLower() == request.Body.FullName.ToLower(),
cancellationToken))
{
return(new ConflictObjectResult(new ErrorModel("Nama sudah digunakan oleh akun lain",
ErrorCodes.DataDuplicated)));
}
}
// make sure no duplicate username
if (request.Body?.Username != null && !string.Equals(user.Username, request.Body.Username, StringComparison.InvariantCultureIgnoreCase))
{
if (await _context.Users.AnyAsync(x => x.FullName.ToLower() == request.Body.Username.ToLower(),
cancellationToken))
{
return(new ConflictObjectResult(new ErrorModel("Username sudah digunakan oleh akun lain",
ErrorCodes.DataDuplicated)));
}
}
// calculate shipping cost
if (request.Body?.Latitude != null &&
request.Body?.Longitude != null &&
_bingMaps.IsPointDifferent(user.Latitude,
user.Longitude,
request.Body.Latitude.Value,
request.Body.Longitude.Value))
{
var distance = await _bingMaps.CalculateDistance(request.Body.Latitude.Value,
request.Body.Longitude.Value, _config.CompanyLatitude, _config.CompanyLongitude, cancellationToken);
user.ShippingCost = _config.FlatShippingCost * (decimal)distance;
}
// project and save the entity
var updatedEntity = _mapper.Map(request.Body, user);
_context.Users.Update(updatedEntity);
await _context.SaveChangesAsync(cancellationToken);
_logger.LogInformation("Updated user with ID {0}", user.UserId);
return(new JsonResult(_mapper.Map <UserProfileDto>(user)));
}
public async Task <IActionResult> Handle(CreateManufactureCommand request, CancellationToken cancellationToken)
{
// find the manufactured product
var product = await _context.Products.FindAsync(new object[] { request.ProductId }, cancellationToken);
// check if we can manufacture the product
if (!product.CanManufacture)
{
return(new ConflictObjectResult(new ErrorModel("Barang tidak dapat diproduksi",
ErrorCodes.ModelValidation)));
}
// create new manufacture job
var job = new ManufactureJob
{
Product = product,
ExpectedProduce = request.ExpectedProduce,
ExpectedCompletion = request.ExpectedCompletion
};
// get all the required materials
job.Materials = await Task.WhenAll(request.Materials.Select(async x =>
{
var material = await _context.Products.FindAsync(new object[] { x.ProductId }, cancellationToken);
return(new ManufactureMaterial
{
Order = job,
Product = material,
Quantity = x.Quantity
});
}));
// create history
job.StatusHistory = new List <ManufactureStatus>
{
new()
{
Code = ManufactureStatusCode.Queued,
Message = "Manufaktur diantrekan.",
Order = job
}
};
// save changes
await _context.Manufacture.AddAsync(job, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
_logger.LogInformation("Created manufacture job with ID {0}", job);
return(new JsonResult(_mapper.Map <SimpleManufactureJobDto>(job)));
}
}
public async Task<IActionResult> Handle(DeleteSupplierCommand request, CancellationToken cancellationToken)
{
var supplier = await _context.Suppliers.FindAsync(new object[] {request.SupplierId}, cancellationToken);
if (supplier == null)
{
return new NotFoundObjectResult(new ErrorModel(ErrorMessages.NotFound, ErrorCodes.NotFound));
}
_context.Suppliers.Remove(supplier);
await _context.SaveChangesAsync(cancellationToken);
_logger.LogInformation("Deleted supplier with ID {0}", request.SupplierId);
return new OkResult();
}
public async Task <IActionResult> Handle(DeleteProductCommand request, CancellationToken cancellationToken)
{
var product = await _context.Products.FindAsync(new object[] { request.ProductId }, cancellationToken);
if (product == null)
{
return(new NotFoundObjectResult(new ErrorModel(ErrorMessages.NotFound, ErrorCodes.NotFound)));
}
_context.Products.Remove(product);
await _context.SaveChangesAsync(cancellationToken);
_logger.LogInformation("Deleted product with ID {0}", request.ProductId);
return(new OkResult());
}
public async Task <IActionResult> Handle(CreateProductCommand request, CancellationToken cancellationToken)
{
if (await _context.Products.AnyAsync(x =>
x.Name.ToLower() == request.Name.ToLower() ||
x.Barcode.ToLower() == request.Barcode.ToLower(), cancellationToken))
{
return(new ConflictObjectResult(new ErrorModel("Nama barang atau barcode sudah ada sebelumnya",
ErrorCodes.ModelValidation)));
}
var product = _mapper.Map <Product>(request);
await _context.Products.AddAsync(product, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
_logger.LogInformation("Created product {0} with ID", product.Name, product.ProductId);
return(new JsonResult(product));
}
public async Task <IActionResult> Handle(EditSupplierCommand request, CancellationToken cancellationToken)
{
var supplier = await _context.Suppliers.FindAsync(new object[] { request.SupplierId }, cancellationToken);
if (supplier == null)
{
return(new NotFoundObjectResult(new ErrorModel(ErrorMessages.NotFound, ErrorCodes.NotFound)));
}
// make sure no duplicate name
if (request.Body?.Name != null && !string.Equals(supplier.Name, request.Body.Name, StringComparison.InvariantCultureIgnoreCase))
{
if (await _context.Suppliers.AnyAsync(x => x.Name.ToLower() == request.Body.Name.ToLower(),
cancellationToken))
{
return(new ConflictObjectResult(new ErrorModel("Nama sudah digunakan pada supplier sebelumnya.",
ErrorCodes.DataDuplicated)));
}
}
// calculate shipping cost
if (request.Body?.Latitude != null &&
request.Body?.Longitude != null &&
_bingMaps.IsPointDifferent(supplier.Latitude,
supplier.Longitude,
request.Body.Latitude.Value,
request.Body.Longitude.Value))
{
var distance = await _bingMaps.CalculateDistance(request.Body.Latitude.Value,
request.Body.Longitude.Value, _config.CompanyLatitude, _config.CompanyLongitude, cancellationToken);
supplier.ShippingCost = _config.FlatShippingCost * (decimal)distance;
}
var updatedEntity = _mapper.Map(request.Body, supplier);
_context.Suppliers.Update(updatedEntity);
await _context.SaveChangesAsync(cancellationToken);
_logger.LogInformation("Updated supplier with ID {0}", supplier.SupplierId);
return(new JsonResult(supplier));
}
public async Task <IActionResult> Handle(CreateUserCommand request, CancellationToken cancellationToken)
{
if (await _context.Users.AnyAsync(x =>
x.Username.ToLower() == request.Username.ToLower() ||
x.FullName.ToLower() == request.FullName.ToLower(), cancellationToken))
{
return(new ConflictObjectResult(new ErrorModel("Username atau nama lengkap sudah ada sebelumnya",
ErrorCodes.ModelValidation)));
}
var user = _mapper.Map <User>(request);
var distance = await _bingMaps.CalculateDistance(user.Latitude, user.Longitude, _config.CompanyLatitude,
_config.CompanyLongitude, cancellationToken);
user.ShippingCost = _config.FlatShippingCost * (decimal)distance;
await _context.Users.AddAsync(user, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
_logger.LogInformation("Created user {0} with ID {1}", user.FullName, user.UserId);
return(new JsonResult(_mapper.Map <UserProfileDto>(user)));
}
public async Task <IActionResult> Handle(EditProductCommand request, CancellationToken cancellationToken)
{
var product = await _context.Products.FindAsync(new object[] { request.ProductId }, cancellationToken);
if (product == null)
{
return(new NotFoundObjectResult(new ErrorModel(ErrorMessages.NotFound, ErrorCodes.NotFound)));
}
if (request.Body?.Name != null && !string.Equals(request.Body.Name, product.Name, StringComparison.InvariantCultureIgnoreCase))
{
if (await _context.Products.AnyAsync(x => x.Name.ToLower() == request.Body.Name.ToLower(),
cancellationToken))
{
return(new ConflictObjectResult(new ErrorModel("Nama sudah digunakan pada produk sebelumnya.",
ErrorCodes.DataDuplicated)));
}
}
if (request.Body?.Barcode != null && !string.Equals(request.Body.Barcode, product.Barcode, StringComparison.InvariantCultureIgnoreCase))
{
if (await _context.Products.AnyAsync(x => x.Barcode.ToLower() == request.Body.Barcode.ToLower(),
cancellationToken))
{
return(new ConflictObjectResult(new ErrorModel("Barcode sudah digunakan pada produk sebelumnya.",
ErrorCodes.DataDuplicated)));
}
}
var updatedEntity = _mapper.Map(request.Body, product);
_context.Products.Update(updatedEntity);
await _context.SaveChangesAsync(cancellationToken);
_logger.LogInformation("Updated product with ID {0}", product.ProductId);
return(new JsonResult(product));
}
public async Task <IActionResult> Handle(CreateSupplierCommand request, CancellationToken cancellationToken)
{
if (await _context.Suppliers.AnyAsync(x =>
x.Name.ToLower() == request.Name.ToLower(), cancellationToken))
{
return(new ConflictObjectResult(new ErrorModel("Nama supplier sudah ada sebelumnya",
ErrorCodes.ModelValidation)));
}
var supplier = _mapper.Map <Supplier>(request);
var distance = await _bingMaps.CalculateDistance(supplier.Latitude, supplier.Longitude,
_config.CompanyLatitude,
_config.CompanyLongitude, cancellationToken);
supplier.ShippingCost = _config.FlatShippingCost * (decimal)distance;
await _context.Suppliers.AddAsync(supplier, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
_logger.LogInformation("Created supplier {0} with ID {1}", supplier.Name, supplier.SupplierId);
return(new JsonResult(
await _context.Suppliers.FindAsync(new object[] { supplier.SupplierId }, cancellationToken)));
}