public async Task <ResultModel <bool> > DeleteProduct(int id)
{
try
{
if (id <= 0)
{
return(ResultModel <bool> .Create(new BadRequestError()));
}
var product = await _productRepository.GetByIdAsync(id);
if (product == null)
{
return(ResultModel <bool> .Create(new NotFoundError()));
}
await _productRepository.DeleteAsync(product);
return(true.ToResultModel());
}
catch (Exception ex)
{
if (ex.GetType().FullName ==
"Microsoft.EntityFrameworkCore.DbUpdateConcurrencyException")
{
return(ResultModel <bool> .Create(new NotFoundError()));
}
return(ResultModel <bool> .Create(new InternalServerError()));
}
}
public async Task <ResultModel <bool> > DeleteBasketAsync(int basketId)
{
try
{
var basket = await _basketRepository.GetByIdAsync(basketId);
if (basket == null)
{
return(ResultModel <bool> .Create(new NotFoundError()));
}
foreach (var item in basket.Items.ToList())
{
await _basketItemRepository.DeleteAsync(item);
}
await _basketRepository.DeleteAsync(basket);
return(true.ToResultModel());
}
catch (Exception ex)
{
if (ex.GetType().FullName ==
"Microsoft.EntityFrameworkCore.DbUpdateConcurrencyException")
{
return(ResultModel <bool> .Create(new NotFoundError()));
}
return(ResultModel <bool> .Create(new InternalServerError()));
}
}
public async Task <ResultModel <ProductDto> > Handle(Command request, CancellationToken cancellationToken)
{
var productCode =
await _productCodeRepository.AddAsync(ProductCode.Create(request.Model.ProductCodeName));
if (productCode is null)
{
throw new Exception($"Couldn't find Product Code with name={request.Model.ProductCodeName}");
}
var created = await _productRepository.AddAsync(
Product.Create(
request.Model.Name,
request.Model.Quantity,
request.Model.Cost,
productCode));
return(ResultModel <ProductDto> .Create(new ProductDto
{
Id = created.Id,
Name = created.Name,
Active = created.Active,
Cost = created.Cost,
Quantity = created.Quantity,
Created = created.Created,
Updated = created.Updated,
ProductCodeId = created.ProductCodeId
}));
}
protected override ResultModel<CountryDto> Handle(Query request)
{
if (request == null) throw new ArgumentNullException(nameof(request));
var country = _countryRepository.FindById(request.Id);
return ResultModel<CountryDto>.Create(country.AdaptToDto());
}
public async Task <ResultModel <int> > CreateOrderAsync(int basketId, Address shippingAddress)
{
try
{
var basket = await _basketRepository.GetByIdAsync(basketId);
Guard.Against.NullBasket(basketId, basket);
var items = new List <OrderItem>();
foreach (var item in basket.Items)
{
var productItem = await _productRepository.GetByIdAsync(item.ProductItemId);
Guard.Against.NullProduct(item.ProductItemId, productItem);
Guard.Against.ProductUnavailable(item.Quantity, productItem);
var itemOrdered = new ProductItemOrdered(productItem.Id, productItem.Name);
var orderItem = new OrderItem(itemOrdered, item.Quantity);
items.Add(orderItem);
productItem.Quantity -= item.Quantity;
}
var order = new Order(basket.CustomerId, shippingAddress, items);
return((await _orderRepository.AddAsync(order)).Id.ToResultModel());
}
catch (Exception ex)
{
if (ex.Message.Contains($"No product found with "))
{
return(ResultModel <int> .Create(new BadRequestError()
{
Message = "No product found"
}));
}
if (ex.Message.Contains($"Unavailable product with "))
{
return(ResultModel <int> .Create(new BadRequestError()
{
Message = "Unavailable product"
}));
}
if (ex.Message.Contains($"No basket found with id {basketId}"))
{
return(ResultModel <int> .Create(new NotFoundError()
{
Message = $"No basket found with id {basketId}"
}));
}
return(ResultModel <int> .Create(new InternalServerError()));
}
}
public async Task <ResultModel <ProductDto> > Handle(Query request,
CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var spec = new ProductByIdQuerySpec <ProductDto>(request);
var product = await _productRepository.FindOneAsync(spec);
return(ResultModel <ProductDto> .Create(product.AdaptToDto()));
}
public async Task <ResultModel <int> > AddItemToBasket(int basketId, int productItemId, int quantity)
{
try
{
var basket = await _basketRepository.GetByIdAsync(basketId);
if (basket == null)
{
return(ResultModel <int> .Create(new NotFoundError()));
}
var currentQuntityInBasket = basket.AddItem(productItemId, quantity);
var productItem = await _productRepository.GetByIdAsync(productItemId);
Guard.Against.NullProduct(productItemId, productItem);
Guard.Against.ProductUnavailable(currentQuntityInBasket, productItem);
await _basketRepository.UpdateAsync(basket);
return(basket.Id.ToResultModel());
}
catch (Exception ex)
{
if (ex.GetType().FullName ==
"Microsoft.EntityFrameworkCore.DbUpdateConcurrencyException")
{
return(ResultModel <int> .Create(new NotFoundError()));
}
if (ex.Message.Contains($"No product found with id {basketId}"))
{
return(ResultModel <int> .Create(new NotFoundError()
{
Message = $"No product found with basketId {basketId}"
}));
}
if (ex.Message.Contains($"Unavailable product with "))
{
return(ResultModel <int> .Create(new BadRequestError()
{
Message = $"Unavailable product with basketId {basketId}"
}));
}
return(ResultModel <int> .Create(new InternalServerError()));
}
}
public async Task <ResultModel <ProductIndexViewModel> > GetProductList(int pageIndex, int itemsPage, int?supplierId, int?categoryId)
{
try
{
string cacheKey = String.Format(_productsKey, pageIndex, itemsPage, supplierId, categoryId);
return(await _cache.GetOrCreateAsync(cacheKey, async entry =>
{
entry.SlidingExpiration = _defaultCacheDuration;
return await _productService.GetProductList(pageIndex, itemsPage, supplierId, categoryId);
}));
}
catch
{
return(ResultModel <ProductIndexViewModel> .Create(new InternalServerError()));
}
}
public async Task <ResultModel <ProductDetailViewModel> > GetById(int id)
{
try
{
string cacheKey = String.Format(_productKey, id);
return(await _cache.GetOrCreateAsync(cacheKey, async entry =>
{
entry.SlidingExpiration = _defaultCacheDuration;
return await _productService.GetById(id);
}));
}
catch
{
return(ResultModel <ProductDetailViewModel> .Create(new InternalServerError()));
}
}
protected override ResultModel <CountryDto> Handle(Query request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var country = _countryRepository.FindById(request.Id);
return(ResultModel <CountryDto> .Create(new CountryDto
{
Id = country.Id,
Name = country.Name,
Created = country.Created,
Updated = country.Updated
}));
}
public async Task <ResultModel <BasketViewModel> > GetOrCreateBasketForUser(string userName)
{
try
{
var basketSpec = new BasketWithItemsSpecification(userName);
var basket = (await _basketRepository.ListAsync(basketSpec)).FirstOrDefault();
if (basket == null)
{
return((await CreateBasketForUser(userName)).ToResultModel());
}
return((await CreateViewModelFromBasket(basket)).ToResultModel());
}
catch
{
return(ResultModel <BasketViewModel> .Create(new InternalServerError()));
}
}
public async Task <ResultModel <bool> > UpdateProduct(int productId, int categoryId, int supplierId, string name, int?quantity, string description)
{
try
{
if (categoryId <= 0 || supplierId <= 0 || string.IsNullOrEmpty(name))
{
return(ResultModel <bool> .Create(new BadRequestError()
{
Message = Shared.InvalidProduct
}));
}
var product = await _productRepository.GetByIdAsync(productId);
if (product == null)
{
return(ResultModel <bool> .Create(new NotFoundError()));
}
product.CategoryId = categoryId;
product.SupplierId = supplierId;
product.Name = name;
product.Quantity = quantity;
product.Description = description;
product.Sku = await _productRepository.GenerateSKUAsync(productId, categoryId, supplierId);
await _productRepository.UpdateAsync(product);
return(true.ToResultModel());
}
catch (Exception ex)
{
if (ex.GetType().FullName ==
"Microsoft.EntityFrameworkCore.DbUpdateConcurrencyException")
{
return(ResultModel <bool> .Create(new NotFoundError()));
}
return(ResultModel <bool> .Create(new InternalServerError()));
}
}
public async Task <ResultModel <ProductDetailViewModel> > AddProductWithSKU(int categoryId, int supplierId, string name, int?quantity, string description)
{
try
{
if (string.IsNullOrEmpty(name) || categoryId <= 0 || supplierId <= 0)
{
return(ResultModel <ProductDetailViewModel> .Create(new BadRequestError()
{
Message = Shared.InvalidProduct
}));
}
Product product = new Product()
{
CategoryId = categoryId,
SupplierId = supplierId,
Name = name,
Quantity = quantity,
Description = description,
};
product = await _productRepository.CreateProductWithSKUAsync(product);
return(new ProductDetailViewModel()
{
Id = product.Id,
Name = product.Name,
Sku = product.Sku,
Description = product.Description,
Quantity = product.Quantity,
CategoryId = product.CategoryId,
SupplierId = product.SupplierId
}.ToResultModel());
}
catch
{
return(ResultModel <ProductDetailViewModel> .Create(new InternalServerError()));
}
}
public async Task<ResultModel<CustomerDto>> Handle(Command request,
CancellationToken cancellationToken)
{
var alreadyRegisteredSpec = new CustomerAlreadyRegisteredSpec(request.Model.Email);
var existingCustomer = await _customerRepository.FindOneAsync(alreadyRegisteredSpec);
if (existingCustomer != null)
{
throw new Exception("Customer with this email already exists");
}
// check country is exists and valid
var (countryDto, isError, _) = await _countryApi.GetCountryByIdAsync(request.Model.CountryId);
if (isError || countryDto.Id.Equals(Guid.Empty))
{
throw new Exception("Country Id is not valid.");
}
var customer = Customer.Create(request.Model.FirstName, request.Model.LastName, request.Model.Email, request.Model.CountryId);
//customer.AddDomainEvent(new CustomerCreatedIntegrationEvent());
var created = await _customerRepository.AddAsync(customer);
return ResultModel<CustomerDto>.Create(new CustomerDto
{
Id = created.Id,
FirstName = created.FirstName,
LastName = created.LastName,
Email = created.Email,
CountryId = created.CountryId,
Balance = created.Balance,
Created = created.Created,
Updated = created.Updated
});
}
public async Task <ResultModel <ProductDto> > Handle(Query request,
CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var spec = new ProductByIdQuerySpec <ProductDto>(request);
var product = await _productRepository.FindOneAsync(spec);
return(ResultModel <ProductDto> .Create(new ProductDto
{
Id = product.Id,
Name = product.Name,
Active = product.Active,
Cost = product.Cost,
Quantity = product.Quantity,
Created = product.Created,
Updated = product.Updated,
ProductCodeId = product.ProductCodeId
}));
}
public async Task <ResultModel <ProductDetailViewModel> > GetById(int id)
{
_logger.LogInformation("GetProductById called.");
var product = await _productRepository.GetByIdAsync(id);
if (product == null)
{
return(ResultModel <ProductDetailViewModel> .Create(new NotFoundError()));
}
var vm = new ProductDetailViewModel()
{
Id = product.Id,
Name = product.Name,
Sku = product.Sku,
Quantity = product.Quantity,
Description = product.Description,
CategoryId = product.CategoryId,
SupplierId = product.SupplierId
};
return(vm.ToResultModel());
}
public void CopyWithLinks(
Context context,
SiteSettings ss,
string columnName,
long from,
long to)
{
var column = ss.GetColumn(
context: context,
columnName: columnName);
if (column == null)
{
return;
}
if (View == null)
{
View = new View();
}
if (View.ColumnFilterHash == null)
{
View.ColumnFilterHash = new Dictionary <string, string>();
}
View.GridColumns = new List <string>()
{
Rds.IdColumn(ss.ReferenceType),
columnName
};
View.ColumnFilterHash.AddOrUpdate(columnName, $"[\"{from}\"]");
if (View.ColumnSorterHash == null)
{
View.ColumnSorterHash = new Dictionary <string, SqlOrderBy.Types>();
}
View.ColumnSorterHash.AddOrUpdate("CreatedTime", SqlOrderBy.Types.asc);
var dataRows = new GridData(
context: context,
ss: ss,
view: View,
count: false)
.DataRows;
switch (ss.ReferenceType)
{
case "Issues":
dataRows.ForEach(dataRow =>
{
var issueId = dataRow.Long("IssueId");
var data = GetData(
dataRow: dataRow,
column: column,
from: from,
to: to);
var formData = new Dictionary <string, string>()
{
{ $"Issues_{columnName}", data }
};
if (!context.ContractSettings.ItemsLimit(
context: context,
siteId: ss.SiteId))
{
var issueModel = new IssueModel(
context: context,
ss: ss,
issueId: issueId,
formData: formData);
var invalid = IssueValidators.OnCreating(
context: context,
ss: ss,
issueModel: issueModel);
switch (invalid.Type)
{
case Error.Types.None:
issueModel.IssueId = 0;
issueModel.Ver = 1;
issueModel.Title.Value += CharToAddWhenCopying ?? ss.CharToAddWhenCopying;
if (CopyWithComments != true)
{
issueModel.Comments.Clear();
}
issueModel.SetCopyDefault(
context: context,
ss: ss);
var errorData = issueModel.Create(
context: context,
ss: ss,
copyFrom: issueModel.SavedIssueId,
forceSynchronizeSourceSummary: true,
notice: false,
otherInitValue: true);
break;
}
}
});
break;
case "Results":
dataRows.ForEach(dataRow =>
{
var resultId = dataRow.Long("ResultId");
var data = GetData(
dataRow: dataRow,
column: column,
from: from,
to: to);
var formData = new Dictionary <string, string>()
{
{ $"Results_{columnName}", data }
};
if (!context.ContractSettings.ItemsLimit(
context: context,
siteId: ss.SiteId))
{
var resultModel = new ResultModel(
context: context,
ss: ss,
resultId: resultId,
formData: formData);
var invalid = ResultValidators.OnCreating(
context: context,
ss: ss,
resultModel: resultModel);
switch (invalid.Type)
{
case Error.Types.None:
resultModel.ResultId = 0;
resultModel.Ver = 1;
resultModel.Title.Value += CharToAddWhenCopying ?? ss.CharToAddWhenCopying;
if (CopyWithComments != true)
{
resultModel.Comments.Clear();
}
resultModel.SetCopyDefault(
context: context,
ss: ss);
var errorData = resultModel.Create(
context: context,
ss: ss,
copyFrom: resultModel.SavedResultId,
forceSynchronizeSourceSummary: true,
notice: false,
otherInitValue: true);
break;
}
}
});
break;
}
}
public static ResultModel <T> ToResultModel <T>(this T obj)
{
return(ResultModel <T> .Create(obj));
}