public async Task <CustomerSalesOrder> Create(CustomerSalesOrder CustomerSalesOrder)
{
if (!await CustomerSalesOrderValidator.Create(CustomerSalesOrder))
{
return(CustomerSalesOrder);
}
try
{
var SalesEmployee = await UOW.AppUserRepository.Get(CustomerSalesOrder.SalesEmployeeId);
CustomerSalesOrder.CreatorId = CurrentContext.UserId;
CustomerSalesOrder.OrganizationId = SalesEmployee.OrganizationId;
CustomerSalesOrder.RequestStateId = RequestStateEnum.NEW.Id;
await Calculator(CustomerSalesOrder);
await UOW.CustomerSalesOrderRepository.Create(CustomerSalesOrder);
CustomerSalesOrder = await UOW.CustomerSalesOrderRepository.Get(CustomerSalesOrder.Id);
await Logging.CreateAuditLog(CustomerSalesOrder, new { }, nameof(CustomerSalesOrderService));
return(CustomerSalesOrder);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(CustomerSalesOrderService));
}
return(null);
}
private async Task <bool> ValidateItem(CustomerSalesOrder CustomerSalesOrder)
{
if (CustomerSalesOrder.CustomerSalesOrderPromotions != null)
{
var Ids = CustomerSalesOrder.CustomerSalesOrderPromotions.Select(x => x.ItemId).ToList();
var ItemFilter = new ItemFilter
{
Skip = 0,
Take = int.MaxValue,
Id = new IdFilter {
In = Ids
},
StatusId = new IdFilter {
Equal = Enums.StatusEnum.ACTIVE.Id
},
Selects = ItemSelect.Id
};
var listIdsInDB = (await UOW.ItemRepository.List(ItemFilter)).Select(x => x.Id);
var listIdsNotExisted = Ids.Except(listIdsInDB);
foreach (var CustomerSalesOrderPromotion in CustomerSalesOrder.CustomerSalesOrderPromotions)
{
if (listIdsNotExisted.Contains(CustomerSalesOrderPromotion.ItemId))
{
CustomerSalesOrderPromotion.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrderPromotion.Item), ErrorCode.ItemNotExisted);
}
}
}
return(CustomerSalesOrder.IsValidated);
}
public async Task <bool> Delete(CustomerSalesOrder CustomerSalesOrder)
{
if (await ValidateId(CustomerSalesOrder))
{
}
return(CustomerSalesOrder.IsValidated);
}
private async Task <bool> ValidateEmployee(CustomerSalesOrder CustomerSalesOrder)
{
if (CustomerSalesOrder.SalesEmployeeId == 0)
{
CustomerSalesOrder.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrder.SalesEmployee), ErrorCode.SalesEmployeeEmpty);
}
else
{
AppUserFilter AppUserFilter = new AppUserFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = CustomerSalesOrder.SalesEmployeeId
},
StatusId = new IdFilter {
Equal = Enums.StatusEnum.ACTIVE.Id
},
Selects = AppUserSelect.Id | AppUserSelect.Organization
};
var count = await UOW.AppUserRepository.Count(AppUserFilter);
if (count == 0)
{
CustomerSalesOrder.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrder.SalesEmployee), ErrorCode.SalesEmployeeNotExisted);
}
}
return(CustomerSalesOrder.IsValidated);
}
private async Task <bool> ValidateOrderDate(CustomerSalesOrder CustomerSalesOrder)
{
if (CustomerSalesOrder.OrderDate == default(DateTime))
{
CustomerSalesOrder.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrder.OrderDate), ErrorCode.OrderDateEmpty);
}
return(CustomerSalesOrder.IsValidated);
}
private async Task <bool> ValidateEditedPrice(CustomerSalesOrder CustomerSalesOrder)
{
if (EditedPriceStatusEnum.ACTIVE.Id != CustomerSalesOrder.EditedPriceStatusId && EditedPriceStatusEnum.INACTIVE.Id != CustomerSalesOrder.EditedPriceStatusId)
{
CustomerSalesOrder.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrder.EditedPriceStatus), ErrorCode.EditedPriceStatusNotExisted);
}
return(CustomerSalesOrder.IsValidated);
}
private async Task <bool> ValidateCustomerType(CustomerSalesOrder CustomerSalesOrder)
{
if (CustomerSalesOrder.CustomerTypeId == 0)
{
CustomerSalesOrder.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrder.CustomerType), ErrorCode.CustomerTypeEmpty);
}
return(CustomerSalesOrder.IsValidated);
}
private async Task <bool> ValidateDeliveryDate(CustomerSalesOrder CustomerSalesOrder)
{
if (CustomerSalesOrder.DeliveryDate.HasValue)
{
if (CustomerSalesOrder.DeliveryDate.Value < CustomerSalesOrder.OrderDate)
{
CustomerSalesOrder.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrder.DeliveryDate), ErrorCode.DeliveryDateInvalid);
}
}
return(CustomerSalesOrder.IsValidated);
}
public async Task <bool> Create(CustomerSalesOrder CustomerSalesOrder)
{
await ValidateCustomerType(CustomerSalesOrder);
await ValidateCustomer(CustomerSalesOrder);
await ValidateEmployee(CustomerSalesOrder);
await ValidateOrderDate(CustomerSalesOrder);
await ValidateDeliveryDate(CustomerSalesOrder);
await ValidateContent(CustomerSalesOrder);
await ValidatePromotion(CustomerSalesOrder);
await ValidateItem(CustomerSalesOrder);
await ValidateEditedPrice(CustomerSalesOrder);
return(CustomerSalesOrder.IsValidated);
}
public async Task <ActionResult <Contact_CustomerSalesOrderDTO> > GetCustomerSalesOrder([FromBody] Contact_CustomerSalesOrderDTO Contact_CustomerSalesOrderDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
CustomerSalesOrder CustomerSalesOrder = await CustomerSalesOrderService.Get(Contact_CustomerSalesOrderDTO.Id);
return(new Contact_CustomerSalesOrderDTO(CustomerSalesOrder));
}
public async Task <bool> ValidateId(CustomerSalesOrder CustomerSalesOrder)
{
CustomerSalesOrderFilter CustomerSalesOrderFilter = new CustomerSalesOrderFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = CustomerSalesOrder.Id
},
Selects = CustomerSalesOrderSelect.Id
};
int count = await UOW.CustomerSalesOrderRepository.Count(CustomerSalesOrderFilter);
if (count == 0)
{
CustomerSalesOrder.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrder.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public RepairTicket_CustomerSalesOrderDTO(CustomerSalesOrder CustomerSalesOrder)
{
this.Id = CustomerSalesOrder.Id;
this.Code = CustomerSalesOrder.Code;
this.CustomerTypeId = CustomerSalesOrder.CustomerTypeId;
this.CustomerId = CustomerSalesOrder.CustomerId;
this.OpportunityId = CustomerSalesOrder.OpportunityId;
this.ContractId = CustomerSalesOrder.ContractId;
this.OrderPaymentStatusId = CustomerSalesOrder.OrderPaymentStatusId;
this.RequestStateId = CustomerSalesOrder.RequestStateId;
this.EditedPriceStatusId = CustomerSalesOrder.EditedPriceStatusId;
this.ShippingName = CustomerSalesOrder.ShippingName;
this.OrderDate = CustomerSalesOrder.OrderDate;
this.DeliveryDate = CustomerSalesOrder.DeliveryDate;
this.SalesEmployeeId = CustomerSalesOrder.SalesEmployeeId;
this.Note = CustomerSalesOrder.Note;
this.InvoiceAddress = CustomerSalesOrder.InvoiceAddress;
this.InvoiceNationId = CustomerSalesOrder.InvoiceNationId;
this.InvoiceProvinceId = CustomerSalesOrder.InvoiceProvinceId;
this.InvoiceDistrictId = CustomerSalesOrder.InvoiceDistrictId;
this.InvoiceWardId = CustomerSalesOrder.InvoiceWardId;
this.InvoiceZIPCode = CustomerSalesOrder.InvoiceZIPCode;
this.DeliveryAddress = CustomerSalesOrder.DeliveryAddress;
this.DeliveryNationId = CustomerSalesOrder.DeliveryNationId;
this.DeliveryProvinceId = CustomerSalesOrder.DeliveryProvinceId;
this.DeliveryDistrictId = CustomerSalesOrder.DeliveryDistrictId;
this.DeliveryWardId = CustomerSalesOrder.DeliveryWardId;
this.DeliveryZIPCode = CustomerSalesOrder.DeliveryZIPCode;
this.SubTotal = CustomerSalesOrder.SubTotal;
this.GeneralDiscountPercentage = CustomerSalesOrder.GeneralDiscountPercentage;
this.GeneralDiscountAmount = CustomerSalesOrder.GeneralDiscountAmount;
this.TotalTaxOther = CustomerSalesOrder.TotalTaxOther;
this.TotalTax = CustomerSalesOrder.TotalTax;
this.Total = CustomerSalesOrder.Total;
this.CreatorId = CustomerSalesOrder.CreatorId;
this.OrganizationId = CustomerSalesOrder.OrganizationId;
this.RowId = CustomerSalesOrder.RowId;
this.CreatedAt = CustomerSalesOrder.CreatedAt;
this.UpdatedAt = CustomerSalesOrder.UpdatedAt;
this.Errors = CustomerSalesOrder.Errors;
}
public async Task <CustomerSalesOrder> Delete(CustomerSalesOrder CustomerSalesOrder)
{
if (!await CustomerSalesOrderValidator.Delete(CustomerSalesOrder))
{
return(CustomerSalesOrder);
}
try
{
await UOW.CustomerSalesOrderRepository.Delete(CustomerSalesOrder);
await Logging.CreateAuditLog(new { }, CustomerSalesOrder, nameof(CustomerSalesOrderService));
return(CustomerSalesOrder);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(CustomerSalesOrderService));
}
return(null);
}
private async Task <bool> ValidatePromotion(CustomerSalesOrder CustomerSalesOrder)
{
if (CustomerSalesOrder.CustomerSalesOrderPromotions != null)
{
await ValidateItem(CustomerSalesOrder);
//validate đơn vị tính sản phẩm khuyến mãi
var Ids = CustomerSalesOrder.CustomerSalesOrderPromotions.Select(x => x.UnitOfMeasureId).ToList();
var UnitOfMeasureFilter = new UnitOfMeasureFilter
{
Skip = 0,
Take = int.MaxValue,
Id = new IdFilter {
In = Ids
},
StatusId = new IdFilter {
Equal = Enums.StatusEnum.ACTIVE.Id
},
Selects = UnitOfMeasureSelect.Id
};
var listIdsInDB = (await UOW.UnitOfMeasureRepository.List(UnitOfMeasureFilter)).Select(x => x.Id);
var listIdsNotExisted = Ids.Except(listIdsInDB);
foreach (var CustomerSalesOrderPromotion in CustomerSalesOrder.CustomerSalesOrderPromotions)
{
if (listIdsNotExisted.Contains(CustomerSalesOrderPromotion.UnitOfMeasureId))
{
CustomerSalesOrderPromotion.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrderPromotion.UnitOfMeasure), ErrorCode.UnitOfMeasureEmpty);
}
//validate số lượng
if (CustomerSalesOrderPromotion.Quantity <= 0)
{
CustomerSalesOrderPromotion.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrderPromotion.Quantity), ErrorCode.QuantityEmpty);
}
}
}
return(CustomerSalesOrder.IsValidated);
}
public async Task <CustomerSalesOrder> Get(long Id)
{
CustomerSalesOrder CustomerSalesOrder = await UOW.CustomerSalesOrderRepository.Get(Id);
if (CustomerSalesOrder == null)
{
return(null);
}
if (CustomerSalesOrder.CustomerTypeId == CustomerTypeEnum.COMPANY.Id)
{
var CustomerPhones = await UOW.CustomerPhoneRepository.List(new CustomerPhoneFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = CustomerPhoneSelect.ALL,
OrderBy = CustomerPhoneOrder.Id,
OrderType = OrderType.ASC,
CustomerId = new IdFilter {
Equal = CustomerSalesOrder.CustomerId
}
});
var CustomerEmails = await UOW.CustomerEmailRepository.List(new CustomerEmailFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = CustomerEmailSelect.ALL,
OrderBy = CustomerEmailOrder.Id,
OrderType = OrderType.ASC,
CustomerId = new IdFilter {
Equal = CustomerSalesOrder.CustomerId
}
});
CustomerSalesOrder.Customer.Phone = CustomerPhones.Select(x => x.Phone).FirstOrDefault();
CustomerSalesOrder.Customer.Email = CustomerEmails.Select(x => x.Email).FirstOrDefault();
}
return(CustomerSalesOrder);
}
public async Task <CustomerSalesOrder> Update(CustomerSalesOrder CustomerSalesOrder)
{
if (!await CustomerSalesOrderValidator.Update(CustomerSalesOrder))
{
return(CustomerSalesOrder);
}
try
{
var oldData = await UOW.CustomerSalesOrderRepository.Get(CustomerSalesOrder.Id);
await UOW.CustomerSalesOrderRepository.Update(CustomerSalesOrder);
CustomerSalesOrder = await UOW.CustomerSalesOrderRepository.Get(CustomerSalesOrder.Id);
await Logging.CreateAuditLog(CustomerSalesOrder, oldData, nameof(CustomerSalesOrderService));
return(CustomerSalesOrder);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(CustomerSalesOrderService));
}
return(null);
}
private async Task <bool> ValidateCustomer(CustomerSalesOrder CustomerSalesOrder)
{
if (CustomerSalesOrder.CustomerId == 0)
{
CustomerSalesOrder.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrder.Customer), ErrorCode.CustomerEmpty);
}
else
{
CustomerFilter CustomerFilter = new CustomerFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
In = new List <long> {
CustomerSalesOrder.CustomerId
}
},
CustomerTypeId = new IdFilter {
Equal = CustomerSalesOrder.CustomerTypeId
},
StatusId = new IdFilter {
Equal = Enums.StatusEnum.ACTIVE.Id
},
Selects = CustomerSelect.Id
};
int count = await UOW.CustomerRepository.Count(CustomerFilter);
if (count == 0)
{
CustomerSalesOrder.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrder.Customer), ErrorCode.CustomerNotExisted);
}
}
return(CustomerSalesOrder.IsValidated);
}
private async Task <CustomerSalesOrder> Calculator(CustomerSalesOrder CustomerSalesOrder)
{
var ProductIds = new List <long>();
var ItemIds = new List <long>();
if (CustomerSalesOrder.CustomerSalesOrderContents != null)
{
ProductIds.AddRange(CustomerSalesOrder.CustomerSalesOrderContents.Select(x => x.Item.ProductId).ToList());
ItemIds.AddRange(CustomerSalesOrder.CustomerSalesOrderContents.Select(x => x.ItemId).ToList());
}
if (CustomerSalesOrder.CustomerSalesOrderPromotions != null)
{
ProductIds.AddRange(CustomerSalesOrder.CustomerSalesOrderPromotions.Select(x => x.Item.ProductId).ToList());
ItemIds.AddRange(CustomerSalesOrder.CustomerSalesOrderPromotions.Select(x => x.ItemId).ToList());
}
ProductIds = ProductIds.Distinct().ToList();
ItemIds = ItemIds.Distinct().ToList();
ItemFilter ItemFilter = new ItemFilter
{
Skip = 0,
Take = ItemIds.Count,
Id = new IdFilter {
In = ItemIds
},
Selects = ItemSelect.ALL,
};
var Items = await UOW.ItemRepository.List(ItemFilter);
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
});
//sản phẩm bán
if (CustomerSalesOrder.CustomerSalesOrderContents != null)
{
foreach (var CustomerSalesOrderContent in CustomerSalesOrder.CustomerSalesOrderContents)
{
var Item = Items.Where(x => x.Id == CustomerSalesOrderContent.ItemId).FirstOrDefault();
var Product = Products.Where(x => CustomerSalesOrderContent.Item.ProductId == x.Id).FirstOrDefault();
CustomerSalesOrderContent.PrimaryUnitOfMeasureId = Product.UnitOfMeasureId;
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();
//CustomerSalesOrderContent.TaxPercentage = Product.TaxType.Percentage;
CustomerSalesOrderContent.RequestedQuantity = CustomerSalesOrderContent.Quantity * UOM.Factor.Value;
//Trường hợp không sửa giá, giá bán = giá bán cơ sở của sản phẩm * hệ số quy đổi của đơn vị tính
if (CustomerSalesOrder.EditedPriceStatusId == EditedPriceStatusEnum.INACTIVE.Id)
{
CustomerSalesOrderContent.PrimaryPrice = Item.SalePrice.GetValueOrDefault(0);
CustomerSalesOrderContent.SalePrice = CustomerSalesOrderContent.PrimaryPrice * UOM.Factor.Value;
CustomerSalesOrderContent.EditedPriceStatusId = EditedPriceStatusEnum.INACTIVE.Id;
}
if (CustomerSalesOrder.EditedPriceStatusId == EditedPriceStatusEnum.ACTIVE.Id)
{
CustomerSalesOrderContent.SalePrice = CustomerSalesOrderContent.PrimaryPrice * UOM.Factor.Value;
if (Item.SalePrice == CustomerSalesOrderContent.PrimaryPrice)
{
CustomerSalesOrderContent.EditedPriceStatusId = EditedPriceStatusEnum.INACTIVE.Id;
}
else
{
CustomerSalesOrderContent.EditedPriceStatusId = EditedPriceStatusEnum.ACTIVE.Id;
}
}
//giá tiền từng line trước chiết khấu
var SubAmount = CustomerSalesOrderContent.Quantity * CustomerSalesOrderContent.SalePrice;
if (CustomerSalesOrderContent.DiscountPercentage.HasValue)
{
CustomerSalesOrderContent.DiscountAmount = SubAmount * CustomerSalesOrderContent.DiscountPercentage.Value / 100;
CustomerSalesOrderContent.DiscountAmount = Math.Round(CustomerSalesOrderContent.DiscountAmount ?? 0, 0);
CustomerSalesOrderContent.Amount = SubAmount - CustomerSalesOrderContent.DiscountAmount.Value;
}
else
{
CustomerSalesOrderContent.Amount = SubAmount;
}
}
//tổng trước chiết khấu
CustomerSalesOrder.SubTotal = CustomerSalesOrder.CustomerSalesOrderContents.Sum(x => x.Amount);
//tính tổng chiết khấu theo % chiết khấu chung
if (CustomerSalesOrder.GeneralDiscountPercentage.HasValue && CustomerSalesOrder.GeneralDiscountPercentage > 0)
{
CustomerSalesOrder.GeneralDiscountAmount = CustomerSalesOrder.SubTotal * (CustomerSalesOrder.GeneralDiscountPercentage / 100);
CustomerSalesOrder.GeneralDiscountAmount = Math.Round(CustomerSalesOrder.GeneralDiscountAmount.Value, 0);
}
foreach (var CustomerSalesOrderContent in CustomerSalesOrder.CustomerSalesOrderContents)
{
//phân bổ chiết khấu chung = tổng chiết khấu chung * (tổng từng line/tổng trc chiết khấu)
CustomerSalesOrderContent.GeneralDiscountPercentage = CustomerSalesOrderContent.Amount / CustomerSalesOrder.SubTotal * 100;
CustomerSalesOrderContent.GeneralDiscountAmount = CustomerSalesOrder.GeneralDiscountAmount * CustomerSalesOrderContent.GeneralDiscountPercentage / 100;
CustomerSalesOrderContent.GeneralDiscountAmount = Math.Round(CustomerSalesOrderContent.GeneralDiscountAmount ?? 0, 0);
//thuê từng line = (tổng từng line - chiết khấu phân bổ) * % thuế
CustomerSalesOrderContent.TaxAmount = (CustomerSalesOrderContent.Amount - (CustomerSalesOrderContent.GeneralDiscountAmount.HasValue ? CustomerSalesOrderContent.GeneralDiscountAmount.Value : 0)) * CustomerSalesOrderContent.TaxPercentage / 100;
CustomerSalesOrderContent.TaxAmount = Math.Round(CustomerSalesOrderContent.TaxAmount ?? 0, 0);
}
CustomerSalesOrder.TotalTax = CustomerSalesOrder.CustomerSalesOrderContents.Where(x => x.TaxAmount.HasValue).Sum(x => x.TaxAmount.Value);
CustomerSalesOrder.TotalTax = Math.Round(CustomerSalesOrder.TotalTax, 0);
CustomerSalesOrder.Total = CustomerSalesOrder.SubTotal - (CustomerSalesOrder.GeneralDiscountAmount.HasValue ? CustomerSalesOrder.GeneralDiscountAmount.Value : 0) + CustomerSalesOrder.TotalTax;
}
else
{
CustomerSalesOrder.SubTotal = 0;
CustomerSalesOrder.GeneralDiscountPercentage = null;
CustomerSalesOrder.GeneralDiscountAmount = null;
CustomerSalesOrder.TotalTax = 0;
CustomerSalesOrder.Total = 0;
}
//sản phẩm khuyến mãi
if (CustomerSalesOrder.CustomerSalesOrderPromotions != null)
{
foreach (var CustomerSalesOrderPromotion in CustomerSalesOrder.CustomerSalesOrderPromotions)
{
var Product = Products.Where(x => CustomerSalesOrderPromotion.Item.ProductId == x.Id).FirstOrDefault();
CustomerSalesOrderPromotion.PrimaryUnitOfMeasureId = Product.UnitOfMeasureId;
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 => CustomerSalesOrderPromotion.UnitOfMeasureId == x.Id).FirstOrDefault();
CustomerSalesOrderPromotion.RequestedQuantity = CustomerSalesOrderPromotion.Quantity * UOM.Factor.Value;
}
}
return(CustomerSalesOrder);
}
public Company_CustomerSalesOrderDTO(CustomerSalesOrder CustomerSalesOrder)
{
this.Id = CustomerSalesOrder.Id;
this.Code = CustomerSalesOrder.Code;
this.CustomerTypeId = CustomerSalesOrder.CustomerTypeId;
this.CustomerId = CustomerSalesOrder.CustomerId;
this.OpportunityId = CustomerSalesOrder.OpportunityId;
this.ContractId = CustomerSalesOrder.ContractId;
this.OrderPaymentStatusId = CustomerSalesOrder.OrderPaymentStatusId;
this.RequestStateId = CustomerSalesOrder.RequestStateId;
this.EditedPriceStatusId = CustomerSalesOrder.EditedPriceStatusId;
this.ShippingName = CustomerSalesOrder.ShippingName;
this.OrderDate = CustomerSalesOrder.OrderDate;
this.DeliveryDate = CustomerSalesOrder.DeliveryDate;
this.SalesEmployeeId = CustomerSalesOrder.SalesEmployeeId;
this.Note = CustomerSalesOrder.Note;
this.InvoiceAddress = CustomerSalesOrder.InvoiceAddress;
this.InvoiceNationId = CustomerSalesOrder.InvoiceNationId;
this.InvoiceProvinceId = CustomerSalesOrder.InvoiceProvinceId;
this.InvoiceDistrictId = CustomerSalesOrder.InvoiceDistrictId;
this.InvoiceWardId = CustomerSalesOrder.InvoiceWardId;
this.InvoiceZIPCode = CustomerSalesOrder.InvoiceZIPCode;
this.DeliveryAddress = CustomerSalesOrder.DeliveryAddress;
this.DeliveryNationId = CustomerSalesOrder.DeliveryNationId;
this.DeliveryProvinceId = CustomerSalesOrder.DeliveryProvinceId;
this.DeliveryDistrictId = CustomerSalesOrder.DeliveryDistrictId;
this.DeliveryWardId = CustomerSalesOrder.DeliveryWardId;
this.DeliveryZIPCode = CustomerSalesOrder.DeliveryZIPCode;
this.SubTotal = CustomerSalesOrder.SubTotal;
this.GeneralDiscountPercentage = CustomerSalesOrder.GeneralDiscountPercentage;
this.GeneralDiscountAmount = CustomerSalesOrder.GeneralDiscountAmount;
this.TotalTaxOther = CustomerSalesOrder.TotalTaxOther;
this.TotalTax = CustomerSalesOrder.TotalTax;
this.Total = CustomerSalesOrder.Total;
this.CreatorId = CustomerSalesOrder.CreatorId;
this.OrganizationId = CustomerSalesOrder.OrganizationId;
this.RowId = CustomerSalesOrder.RowId;
this.Contract = CustomerSalesOrder.Contract == null ? null : new Company_ContractDTO(CustomerSalesOrder.Contract);
this.Creator = CustomerSalesOrder.Creator == null ? null : new Company_AppUserDTO(CustomerSalesOrder.Creator);
this.Customer = CustomerSalesOrder.Customer == null ? null : new Company_CustomerDTO(CustomerSalesOrder.Customer);
this.CustomerType = CustomerSalesOrder.CustomerType == null ? null : new Company_CustomerTypeDTO(CustomerSalesOrder.CustomerType);
this.DeliveryDistrict = CustomerSalesOrder.DeliveryDistrict == null ? null : new Company_DistrictDTO(CustomerSalesOrder.DeliveryDistrict);
this.DeliveryNation = CustomerSalesOrder.DeliveryNation == null ? null : new Company_NationDTO(CustomerSalesOrder.DeliveryNation);
this.DeliveryProvince = CustomerSalesOrder.DeliveryProvince == null ? null : new Company_ProvinceDTO(CustomerSalesOrder.DeliveryProvince);
this.DeliveryWard = CustomerSalesOrder.DeliveryWard == null ? null : new Company_WardDTO(CustomerSalesOrder.DeliveryWard);
this.EditedPriceStatus = CustomerSalesOrder.EditedPriceStatus == null ? null : new Company_EditedPriceStatusDTO(CustomerSalesOrder.EditedPriceStatus);
this.InvoiceDistrict = CustomerSalesOrder.InvoiceDistrict == null ? null : new Company_DistrictDTO(CustomerSalesOrder.InvoiceDistrict);
this.InvoiceNation = CustomerSalesOrder.InvoiceNation == null ? null : new Company_NationDTO(CustomerSalesOrder.InvoiceNation);
this.InvoiceProvince = CustomerSalesOrder.InvoiceProvince == null ? null : new Company_ProvinceDTO(CustomerSalesOrder.InvoiceProvince);
this.InvoiceWard = CustomerSalesOrder.InvoiceWard == null ? null : new Company_WardDTO(CustomerSalesOrder.InvoiceWard);
this.Opportunity = CustomerSalesOrder.Opportunity == null ? null : new Company_OpportunityDTO(CustomerSalesOrder.Opportunity);
this.OrderPaymentStatus = CustomerSalesOrder.OrderPaymentStatus == null ? null : new Company_OrderPaymentStatusDTO(CustomerSalesOrder.OrderPaymentStatus);
this.Organization = CustomerSalesOrder.Organization == null ? null : new Company_OrganizationDTO(CustomerSalesOrder.Organization);
this.RequestState = CustomerSalesOrder.RequestState == null ? null : new Company_RequestStateDTO(CustomerSalesOrder.RequestState);
this.SalesEmployee = CustomerSalesOrder.SalesEmployee == null ? null : new Company_AppUserDTO(CustomerSalesOrder.SalesEmployee);
this.CustomerSalesOrderContents = CustomerSalesOrder.CustomerSalesOrderContents?.Select(x => new Company_CustomerSalesOrderContentDTO(x)).ToList();
this.CustomerSalesOrderPromotions = CustomerSalesOrder.CustomerSalesOrderPromotions?.Select(x => new Company_CustomerSalesOrderPromotionDTO(x)).ToList();
this.CreatedAt = CustomerSalesOrder.CreatedAt;
this.UpdatedAt = CustomerSalesOrder.UpdatedAt;
this.Errors = CustomerSalesOrder.Errors;
}
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);
}
