public async Task <bool> Delete(CustomerSalesOrderContent CustomerSalesOrderContent)
{
if (await ValidateId(CustomerSalesOrderContent))
{
}
return(CustomerSalesOrderContent.IsValidated);
}
public Customer_CustomerSalesOrderContentDTO(CustomerSalesOrderContent CustomerSalesOrderContent)
{
this.Id = CustomerSalesOrderContent.Id;
this.CustomerSalesOrderId = CustomerSalesOrderContent.CustomerSalesOrderId;
this.ItemId = CustomerSalesOrderContent.ItemId;
this.UnitOfMeasureId = CustomerSalesOrderContent.UnitOfMeasureId;
this.Quantity = CustomerSalesOrderContent.Quantity;
this.RequestedQuantity = CustomerSalesOrderContent.RequestedQuantity;
this.PrimaryUnitOfMeasureId = CustomerSalesOrderContent.PrimaryUnitOfMeasureId;
this.SalePrice = CustomerSalesOrderContent.SalePrice;
this.PrimaryPrice = CustomerSalesOrderContent.PrimaryPrice;
this.DiscountPercentage = CustomerSalesOrderContent.DiscountPercentage;
this.DiscountAmount = CustomerSalesOrderContent.DiscountAmount;
this.GeneralDiscountPercentage = CustomerSalesOrderContent.GeneralDiscountPercentage;
this.GeneralDiscountAmount = CustomerSalesOrderContent.GeneralDiscountAmount;
this.TaxPercentage = CustomerSalesOrderContent.TaxPercentage;
this.TaxAmount = CustomerSalesOrderContent.TaxAmount;
this.TaxPercentageOther = CustomerSalesOrderContent.TaxPercentageOther;
this.TaxAmountOther = CustomerSalesOrderContent.TaxAmountOther;
this.Amount = CustomerSalesOrderContent.Amount;
this.Factor = CustomerSalesOrderContent.Factor;
this.EditedPriceStatusId = CustomerSalesOrderContent.EditedPriceStatusId;
this.TaxTypeId = CustomerSalesOrderContent.TaxTypeId;
this.EditedPriceStatus = CustomerSalesOrderContent.EditedPriceStatus == null ? null : new Customer_EditedPriceStatusDTO(CustomerSalesOrderContent.EditedPriceStatus);
this.Item = CustomerSalesOrderContent.Item == null ? null : new Customer_ItemDTO(CustomerSalesOrderContent.Item);
this.PrimaryUnitOfMeasure = CustomerSalesOrderContent.PrimaryUnitOfMeasure == null ? null : new Customer_UnitOfMeasureDTO(CustomerSalesOrderContent.PrimaryUnitOfMeasure);
this.UnitOfMeasure = CustomerSalesOrderContent.UnitOfMeasure == null ? null : new Customer_UnitOfMeasureDTO(CustomerSalesOrderContent.UnitOfMeasure);
this.TaxType = CustomerSalesOrderContent.TaxType == null ? null : new Customer_TaxTypeDTO(CustomerSalesOrderContent.TaxType);
this.Errors = CustomerSalesOrderContent.Errors;
}
public async Task <CustomerSalesOrderContent> Get(long Id)
{
CustomerSalesOrderContent CustomerSalesOrderContent = await UOW.CustomerSalesOrderContentRepository.Get(Id);
if (CustomerSalesOrderContent == null)
{
return(null);
}
return(CustomerSalesOrderContent);
}
public async Task <bool> ValidateId(CustomerSalesOrderContent CustomerSalesOrderContent)
{
CustomerSalesOrderContentFilter CustomerSalesOrderContentFilter = new CustomerSalesOrderContentFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = CustomerSalesOrderContent.Id
},
Selects = CustomerSalesOrderContentSelect.Id
};
int count = await UOW.CustomerSalesOrderContentRepository.Count(CustomerSalesOrderContentFilter);
if (count == 0)
{
CustomerSalesOrderContent.AddError(nameof(CustomerSalesOrderContentValidator), nameof(CustomerSalesOrderContent.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public async Task <CustomerSalesOrderContent> Delete(CustomerSalesOrderContent CustomerSalesOrderContent)
{
if (!await CustomerSalesOrderContentValidator.Delete(CustomerSalesOrderContent))
{
return(CustomerSalesOrderContent);
}
try
{
await UOW.CustomerSalesOrderContentRepository.Delete(CustomerSalesOrderContent);
await Logging.CreateAuditLog(new { }, CustomerSalesOrderContent, nameof(CustomerSalesOrderContentService));
return(CustomerSalesOrderContent);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(CustomerSalesOrderContentService));
}
return(null);
}
public async Task <CustomerSalesOrderContent> Update(CustomerSalesOrderContent CustomerSalesOrderContent)
{
if (!await CustomerSalesOrderContentValidator.Update(CustomerSalesOrderContent))
{
return(CustomerSalesOrderContent);
}
try
{
var oldData = await UOW.CustomerSalesOrderContentRepository.Get(CustomerSalesOrderContent.Id);
await UOW.CustomerSalesOrderContentRepository.Update(CustomerSalesOrderContent);
CustomerSalesOrderContent = await UOW.CustomerSalesOrderContentRepository.Get(CustomerSalesOrderContent.Id);
await Logging.CreateAuditLog(CustomerSalesOrderContent, oldData, nameof(CustomerSalesOrderContentService));
return(CustomerSalesOrderContent);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(CustomerSalesOrderContentService));
}
return(null);
}
public async Task <bool> Create(CustomerSalesOrderContent CustomerSalesOrderContent)
{
return(CustomerSalesOrderContent.IsValidated);
}
private async Task <bool> ValidateContent(CustomerSalesOrder CustomerSalesOrder)
{
if (CustomerSalesOrder.CustomerSalesOrderContents != null && CustomerSalesOrder.CustomerSalesOrderContents.Any())
{
var ItemIds = CustomerSalesOrder.CustomerSalesOrderContents.Select(x => x.ItemId).ToList();
var ProductIds = CustomerSalesOrder.CustomerSalesOrderContents.Select(x => x.Item.ProductId).ToList();
List <Item> Items = await UOW.ItemRepository.List(new ItemFilter
{
Skip = 0,
Take = int.MaxValue,
Id = new IdFilter {
In = ItemIds
},
Selects = ItemSelect.Id | ItemSelect.SalePrice | ItemSelect.ProductId
});
var Products = await UOW.ProductRepository.List(new ProductFilter
{
Id = new IdFilter {
In = ProductIds
},
Skip = 0,
Take = int.MaxValue,
Selects = ProductSelect.UnitOfMeasure | ProductSelect.UnitOfMeasureGrouping | ProductSelect.Id | ProductSelect.TaxType
});
var UOMGs = await UOW.UnitOfMeasureGroupingRepository.List(new UnitOfMeasureGroupingFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = UnitOfMeasureGroupingSelect.Id | UnitOfMeasureGroupingSelect.UnitOfMeasure | UnitOfMeasureGroupingSelect.UnitOfMeasureGroupingContents
});
foreach (var CustomerSalesOrderContent in CustomerSalesOrder.CustomerSalesOrderContents)
{
if (CustomerSalesOrderContent.UnitOfMeasureId == 0)
{
CustomerSalesOrderContent.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrderContent.UnitOfMeasure), ErrorCode.UnitOfMeasureEmpty);
}
else
{
var Item = Items.Where(x => x.Id == CustomerSalesOrderContent.ItemId).FirstOrDefault();
if (Item == null)
{
CustomerSalesOrderContent.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrderContent.Item), ErrorCode.ItemNotExisted);
}
else
{
var Product = Products.Where(x => Item.ProductId == x.Id).FirstOrDefault();
List <UnitOfMeasure> UnitOfMeasures = new List <UnitOfMeasure>();
if (Product.UnitOfMeasureGroupingId.HasValue)
{
var UOMG = UOMGs.Where(x => x.Id == Product.UnitOfMeasureGroupingId).FirstOrDefault();
UnitOfMeasures = UOMG.UnitOfMeasureGroupingContents.Select(x => new UnitOfMeasure
{
Id = x.UnitOfMeasure.Id,
Code = x.UnitOfMeasure.Code,
Name = x.UnitOfMeasure.Name,
Description = x.UnitOfMeasure.Description,
StatusId = x.UnitOfMeasure.StatusId,
Factor = x.Factor
}).ToList();
}
UnitOfMeasures.Add(new UnitOfMeasure
{
Id = Product.UnitOfMeasure.Id,
Code = Product.UnitOfMeasure.Code,
Name = Product.UnitOfMeasure.Name,
Description = Product.UnitOfMeasure.Description,
StatusId = Product.UnitOfMeasure.StatusId,
Factor = 1
});
var UOM = UnitOfMeasures.Where(x => CustomerSalesOrderContent.UnitOfMeasureId == x.Id).FirstOrDefault();
if (UOM == null)
{
CustomerSalesOrderContent.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrderContent.UnitOfMeasure), ErrorCode.UnitOfMeasureNotExisted);
}
//else
//{
// if(CustomerSalesOrder.EditedPriceStatusId == EditedPriceStatusEnum.ACTIVE.Id)
// {
// if(CustomerSalesOrderContent.SalePrice < (Item.SalePrice * UOM.Factor.Value) * 0.9m
// || CustomerSalesOrderContent.SalePrice > (Item.SalePrice * UOM.Factor.Value) * 1.1m)
// CustomerSalesOrderContent.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrderContent.SalePrice), ErrorCode.PriceOutOfRange);
// }
//}
}
if (CustomerSalesOrderContent.Quantity <= 0)
{
CustomerSalesOrderContent.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrderContent.Quantity), ErrorCode.QuantityEmpty);
}
}
}
}
else
{
if (CustomerSalesOrder.CustomerSalesOrderPromotions == null || !CustomerSalesOrder.CustomerSalesOrderPromotions.Any())
{
CustomerSalesOrder.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrder.Id), ErrorCode.ContentEmpty);
}
}
return(CustomerSalesOrder.IsValidated);
}
