public async Task <int> Create(UnitPaymentCorrectionNote m, string user, int clientTimeZoneOffset = 7)
{
int Created = 0;
using (var transaction = this.dbContext.Database.BeginTransaction())
{
try
{
EntityExtension.FlagForCreate(m, user, USER_AGENT);
var supplier = GetSupplier(m.SupplierId);
var supplierImport = false;
m.SupplierNpwp = null;
if (supplier != null)
{
m.SupplierNpwp = supplier.npwp;
supplierImport = supplier.import;
}
m.UPCNo = await GenerateNo(m, clientTimeZoneOffset, supplierImport, m.DivisionName);
if (m.useVat == true)
{
m.ReturNoteNo = await GeneratePONo(m, clientTimeZoneOffset);
}
UnitPaymentOrder unitPaymentOrder = this.dbContext.UnitPaymentOrders.Where(s => s.Id == m.UPOId).Include(p => p.Items).ThenInclude(i => i.Details).FirstOrDefault();
unitPaymentOrder.IsCorrection = true;
foreach (var item in m.Items)
{
EntityExtension.FlagForCreate(item, user, USER_AGENT);
foreach (var itemSpb in unitPaymentOrder.Items)
{
foreach (var detailSpb in itemSpb.Details)
{
if (item.UPODetailId == detailSpb.Id)
{
detailSpb.QuantityCorrection = detailSpb.QuantityCorrection - item.Quantity;
ExternalPurchaseOrderDetail epoDetail = dbContext.ExternalPurchaseOrderDetails.FirstOrDefault(a => a.Id.Equals(detailSpb.EPODetailId));
epoDetail.DOQuantity -= item.Quantity;
}
}
}
}
this.dbSet.Add(m);
Created = await dbContext.SaveChangesAsync();
Created += await AddCorrections(m, user);
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
}
return(Created);
}
private void SetPOItemIdEPONo(UnitPaymentOrderDetail detail)
{
ExternalPurchaseOrderDetail EPODetail = dbContext.ExternalPurchaseOrderDetails.Single(m => m.Id == detail.EPODetailId);
detail.POItemId = EPODetail.POItemId;
detail.EPONo = dbContext.ExternalPurchaseOrders.Single(m => m.Items.Any(i => i.Id == EPODetail.EPOItemId)).EPONo;
}
public async Task <int> Create(DeliveryOrder model, string username)
{
int Created = 0;
using (var transaction = this.dbContext.Database.BeginTransaction())
{
try
{
EntityExtension.FlagForCreate(model, username, USER_AGENT);
foreach (var item in model.Items)
{
EntityExtension.FlagForCreate(item, username, USER_AGENT);
foreach (var detail in item.Details)
{
EntityExtension.FlagForCreate(detail, username, USER_AGENT);
ExternalPurchaseOrderDetail externalPurchaseOrderDetail = this.dbContext.ExternalPurchaseOrderDetails.SingleOrDefault(m => m.Id == detail.EPODetailId);
if (externalPurchaseOrderDetail != null)
{
externalPurchaseOrderDetail.DOQuantity += detail.DOQuantity;
EntityExtension.FlagForUpdate(externalPurchaseOrderDetail, username, USER_AGENT);
SetStatus(externalPurchaseOrderDetail, detail, username);
}
}
}
this.dbSet.Add(model);
Created = await dbContext.SaveChangesAsync();
Created += await AddFulfillmentAsync(model, username);
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
while (e.InnerException != null)
{
e = e.InnerException;
}
throw e;
}
}
return(Created);
}
public POExternalItemDto(ExternalPurchaseOrderDetail element, ExternalPurchaseOrder entity)
{
Product = new ProductDto(element.ProductCode, element.ProductId, element.ProductName, element.DefaultUomId, element.DefaultUomUnit);
DefaultQuantity = element.DefaultQuantity;
DealQuantity = element.DealQuantity;
DealUOM = new UOMDto(element.DealUomId, element.DealUomUnit);
Conversion = element.Conversion;
Price = element.PricePerDealUnit;
UseVat = entity.UseVat;
Unit = new UnitDto(entity.UnitId, entity.UnitCode, entity.UnitName, entity.DivisionCode, entity.DivisionId, entity.DivisionName);
IncomeTax = new IncomeTaxDto(entity.IncomeTaxId, entity.IncomeTaxName, entity.IncomeTaxRate);
IncomeTaxBy = entity.IncomeTaxBy;
UseIncomeTax = entity.UseIncomeTax;
EPOId = (int)entity.Id;
}
public async Task <int> Create(PurchasingDisposition m, string user, int clientTimeZoneOffset)
{
int Created = 0;
using (var transaction = this.dbContext.Database.BeginTransaction())
{
try
{
EntityExtension.FlagForCreate(m, user, "Facade");
m.DispositionNo = await GenerateNo(m, clientTimeZoneOffset);
m.Position = 1;
if (m.IncomeTaxBy == "Supplier")
{
m.Amount = m.DPP + m.VatValue + m.PaymentCorrection;
}
else
{
m.Amount = m.DPP + m.VatValue - m.IncomeTaxValue + m.PaymentCorrection;
}
foreach (var item in m.Items)
{
EntityExtension.FlagForCreate(item, user, "Facade");
foreach (var detail in item.Details)
{
ExternalPurchaseOrderDetail epoDetail = this.dbContext.ExternalPurchaseOrderDetails.Where(s => s.Id.ToString() == detail.EPODetailId && s.IsDeleted == false).FirstOrDefault();
epoDetail.DispositionQuantity += detail.PaidQuantity;
EntityExtension.FlagForCreate(detail, user, "Facade");
}
}
this.dbSet.Add(m);
Created = await dbContext.SaveChangesAsync();
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
}
return(Created);
}
public int Delete(int id, string username)
{
int Deleted = 0;
using (var transaction = this.dbContext.Database.BeginTransaction())
{
try
{
var model = this.dbSet
.Include(d => d.Items)
.ThenInclude(d => d.Details)
.SingleOrDefault(pr => pr.Id == id && !pr.IsDeleted);
EntityExtension.FlagForDelete(model, username, USER_AGENT);
foreach (var item in model.Items)
{
EntityExtension.FlagForDelete(item, username, USER_AGENT);
foreach (var detail in item.Details)
{
ExternalPurchaseOrderDetail externalPurchaseOrderDetail = this.dbContext.ExternalPurchaseOrderDetails.SingleOrDefault(m => m.Id == detail.EPODetailId);
externalPurchaseOrderDetail.DOQuantity -= detail.DOQuantity;
EntityExtension.FlagForUpdate(externalPurchaseOrderDetail, username, USER_AGENT);
SetStatus(externalPurchaseOrderDetail, detail, username);
EntityExtension.FlagForDelete(detail, username, USER_AGENT);
}
}
Deleted = dbContext.SaveChanges();
Deleted += RemoveFulfillment(model, username);
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
while (e.InnerException != null)
{
e = e.InnerException;
}
throw e;
}
}
return(Deleted);
}
private void SetStatus(UnitPaymentOrderDetail detail, string username)
{
ExternalPurchaseOrderDetail EPODetail = dbContext.ExternalPurchaseOrderDetails.Single(m => m.Id == detail.EPODetailId);
InternalPurchaseOrderItem POItem = dbContext.InternalPurchaseOrderItems.Single(m => m.Id == EPODetail.POItemId);
List <long> EPODetailIds = dbContext.ExternalPurchaseOrderDetails.Where(m => m.POItemId == POItem.Id).Select(m => m.Id).ToList();
List <long> URNItemIds = dbContext.UnitReceiptNoteItems.Where(m => EPODetailIds.Contains(m.EPODetailId)).Select(m => m.Id).ToList();
var totalReceiptQuantity = dbContext.UnitPaymentOrderDetails.AsNoTracking().Where(m => m.IsDeleted == false && URNItemIds.Contains(m.URNItemId)).Sum(m => m.ReceiptQuantity);
if (totalReceiptQuantity > 0)
{
if (totalReceiptQuantity < EPODetail.DealQuantity)
{
POItem.Status = "Sudah dibuat SPB sebagian";
}
else
{
POItem.Status = "Sudah dibuat SPB semua";
}
}
else if (totalReceiptQuantity == 0)
{
if (EPODetail.DOQuantity >= EPODetail.DealQuantity)
{
if (EPODetail.ReceiptQuantity < EPODetail.DealQuantity)
{
POItem.Status = "Barang sudah diterima Unit parsial";
}
else
{
POItem.Status = "Barang sudah diterima Unit semua";
}
}
else
{
POItem.Status = "Barang sudah diterima Unit parsial";
}
}
EntityExtension.FlagForUpdate(POItem, username, USER_AGENT);
}
public int Delete(int id, string user)
{
int Deleted = 0;
using (var transaction = this.dbContext.Database.BeginTransaction())
{
try
{
var m = this.dbSet
.Include(d => d.Items)
.ThenInclude(d => d.Details)
.SingleOrDefault(epo => epo.Id == id && !epo.IsDeleted);
EntityExtension.FlagForDelete(m, user, "Facade");
foreach (var item in m.Items)
{
EntityExtension.FlagForDelete(item, user, "Facade");
foreach (var detail in item.Details)
{
ExternalPurchaseOrderDetail epoDetail = this.dbContext.ExternalPurchaseOrderDetails.Where(s => s.Id.ToString() == detail.EPODetailId && s.IsDeleted == false).FirstOrDefault();
epoDetail.DispositionQuantity -= detail.PaidQuantity;
EntityExtension.FlagForDelete(detail, user, "Facade");
}
}
Deleted = dbContext.SaveChanges();
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
}
return(Deleted);
}
private void SetStatus(ExternalPurchaseOrderDetail externalPurchaseOrderDetail, DeliveryOrderDetail detail, string username)
{
if (externalPurchaseOrderDetail.ReceiptQuantity == 0)
{
if (dbContext.UnitPaymentOrderDetails.FirstOrDefault(d => d.POItemId == externalPurchaseOrderDetail.POItemId) == null)
{
//PurchaseRequestItem purchaseRequestItem = this.dbContext.PurchaseRequestItems.SingleOrDefault(i => i.Id == detail.PRItemId);
InternalPurchaseOrderItem internalPurchaseOrderItem = this.dbContext.InternalPurchaseOrderItems.SingleOrDefault(i => i.Id == detail.POItemId);
if (externalPurchaseOrderDetail.DOQuantity == 0)
{
//purchaseRequestItem.Status = "Sudah diorder ke Supplier";
internalPurchaseOrderItem.Status = "Sudah diorder ke Supplier";
//EntityExtension.FlagForUpdate(purchaseRequestItem, username, USER_AGENT);
EntityExtension.FlagForUpdate(internalPurchaseOrderItem, username, USER_AGENT);
}
else if (externalPurchaseOrderDetail.DOQuantity > 0 && externalPurchaseOrderDetail.DOQuantity < externalPurchaseOrderDetail.DealQuantity)
{
//purchaseRequestItem.Status = "Barang sudah datang parsial";
internalPurchaseOrderItem.Status = "Barang sudah datang parsial";
//EntityExtension.FlagForUpdate(purchaseRequestItem, username, USER_AGENT);
EntityExtension.FlagForUpdate(internalPurchaseOrderItem, username, USER_AGENT);
}
else if (externalPurchaseOrderDetail.DOQuantity > 0 && externalPurchaseOrderDetail.DOQuantity >= externalPurchaseOrderDetail.DealQuantity)
{
//purchaseRequestItem.Status = "Barang sudah datang semua";
internalPurchaseOrderItem.Status = "Barang sudah datang semua";
//EntityExtension.FlagForUpdate(purchaseRequestItem, username, USER_AGENT);
EntityExtension.FlagForUpdate(internalPurchaseOrderItem, username, USER_AGENT);
}
}
}
}
public async Task <PurchasingDisposition> GetNewData()
{
var s = await Task.Run(() => externalPurchaseOrderDataUtil.GetTestData("unit-test"));
ExternalPurchaseOrderDetail d = new ExternalPurchaseOrderDetail();
ExternalPurchaseOrderItem i = new ExternalPurchaseOrderItem();
var itemData = s.Items;
foreach (var item in itemData)
{
i = item; break;
}
foreach (var detail in i.Details)
{
d = detail; break;
}
EPODetailViewModel detailEPO = new EPODetailViewModel
{
_id = d.Id,
poItemId = d.POItemId,
prItemId = d.PRItemId,
product = new ProductViewModel
{
_id = d.ProductId,
code = d.ProductCode,
name = d.ProductName,
},
dealQuantity = d.DealQuantity,
dealUom = new UomViewModel
{
_id = d.DealUomId,
unit = d.DealUomUnit,
},
doQuantity = d.DOQuantity,
dispositionQuantity = d.DispositionQuantity,
productRemark = d.ProductRemark,
priceBeforeTax = d.PriceBeforeTax,
pricePerDealUnit = d.PricePerDealUnit,
};
EPOItemViewModel itemEPO = new EPOItemViewModel
{
_id = i.Id,
IsDeleted = i.IsDeleted,
prId = i.PRId,
poId = i.POId,
prNo = i.PRNo,
category = new CategoryViewModel
{
_id = "CategoryId",
code = "CategoryCode",
name = "CategoryName"
},
details = new List <EPODetailViewModel>()
{
detailEPO
}
};
EPOViewModel dataEPO = new EPOViewModel
{
_id = s.Id,
no = s.EPONo,
unit = new UnitViewModel
{
_id = s.UnitId,
name = s.UnitName,
code = s.UnitCode,
},
useVat = s.UseVat,
useIncomeTax = s.UseIncomeTax,
incomeTax = new IncomeTaxViewModel
{
_id = s.IncomeTaxId,
name = s.IncomeTaxName,
rate = s.IncomeTaxRate,
},
items = new List <EPOItemViewModel>()
{
itemEPO
}
};
return(new PurchasingDisposition
{
SupplierId = "1",
SupplierCode = "Supplier1",
SupplierName = "supplier1",
Bank = "Bank",
Amount = 1000,
Calculation = "axb+c",
//InvoiceNo="test",
ConfirmationOrderNo = "test",
//Investation = "test",
PaymentDueDate = new DateTimeOffset(),
ProformaNo = "aaa",
PaymentMethod = "Test",
Remark = "Remark1",
CategoryCode = "test",
CategoryId = "1",
CategoryName = "test",
Items = new List <PurchasingDispositionItem>
{
new PurchasingDispositionItem
{
EPOId = dataEPO._id.ToString(),
EPONo = dataEPO.no,
IncomeTaxId = "1",
IncomeTaxName = "tax",
IncomeTaxRate = 1,
UseIncomeTax = true,
UseVat = true,
Details = new List <PurchasingDispositionDetail>
{
new PurchasingDispositionDetail
{
EPODetailId = detailEPO._id.ToString(),
DealQuantity = 10,
PaidQuantity = 1000,
DealUomId = "1",
DealUomUnit = "test",
PaidPrice = 1000,
PricePerDealUnit = 100,
PriceTotal = 10000,
PRId = "1",
PRNo = "test",
ProductCode = "test",
ProductName = "test",
ProductId = "1",
UnitName = "test",
UnitCode = "test",
UnitId = "1",
}
}
}
}
});
}
public async Task <int> Update(int id, PurchasingDisposition purchasingDisposition, string user)
{
int Updated = 0;
using (var transaction = this.dbContext.Database.BeginTransaction())
{
try
{
var existingModel = this.dbSet.AsNoTracking()
.Include(d => d.Items)
.ThenInclude(d => d.Details)
.Single(epo => epo.Id == id && !epo.IsDeleted);
foreach (var oldIem in existingModel.Items)
{
foreach (var oldDetail in oldIem.Details)
{
ExternalPurchaseOrderDetail epoDetail = this.dbContext.ExternalPurchaseOrderDetails.Where(s => s.Id.ToString() == oldDetail.EPODetailId && s.IsDeleted == false).FirstOrDefault();
epoDetail.DispositionQuantity -= oldDetail.PaidQuantity;
}
}
if (existingModel != null && id == purchasingDisposition.Id)
{
if (purchasingDisposition.IncomeTaxBy == "Supplier")
{
purchasingDisposition.Amount = purchasingDisposition.DPP + purchasingDisposition.VatValue + purchasingDisposition.PaymentCorrection;
}
else
{
purchasingDisposition.Amount = purchasingDisposition.DPP + purchasingDisposition.VatValue - purchasingDisposition.IncomeTaxValue + purchasingDisposition.PaymentCorrection;
}
EntityExtension.FlagForUpdate(purchasingDisposition, user, "Facade");
foreach (var item in purchasingDisposition.Items.ToList())
{
var existingItem = existingModel.Items.SingleOrDefault(m => m.Id == item.Id);
List <PurchasingDispositionItem> duplicateDispositionItems = purchasingDisposition.Items.Where(i => i.EPOId == item.EPOId && i.Id != item.Id).ToList();
if (item.Id == 0)
{
if (duplicateDispositionItems.Count <= 0)
{
EntityExtension.FlagForCreate(item, user, "Facade");
foreach (var detail in item.Details)
{
ExternalPurchaseOrderDetail epoDetail = this.dbContext.ExternalPurchaseOrderDetails.Where(s => s.Id.ToString() == detail.EPODetailId && s.IsDeleted == false).FirstOrDefault();
epoDetail.DispositionQuantity += detail.PaidQuantity;
EntityExtension.FlagForCreate(detail, user, "Facade");
}
}
}
else
{
EntityExtension.FlagForUpdate(item, user, "Facade");
if (duplicateDispositionItems.Count > 0)
{
//foreach (var detail in item.Details.ToList())
//{
// if (detail.Id != 0)
// {
// EntityExtension.FlagForUpdate(detail, user, "Facade");
// foreach (var duplicateItem in duplicateDispositionItems.ToList())
// {
// foreach (var duplicateDetail in duplicateItem.Details.ToList())
// {
// if (item.Details.Count(d => d.EPODetailId.Equals(duplicateDetail.EPODetailId)) < 1)
// {
// ExternalPurchaseOrderDetail epoDetail = this.dbContext.ExternalPurchaseOrderDetails.Where(s => s.Id == detail.EPODetailId && s.IsDeleted == false).FirstOrDefault();
// epoDetail.DispositionQuantity += detail.PaidQuantity;
// EntityExtension.FlagForCreate(duplicateDetail, user, "Facade");
// item.Details.Add(duplicateDetail);
// }
// }
// purchasingDisposition.Items.Remove(duplicateItem);
// }
// }
//}
}
else
{
foreach (var detail in item.Details)
{
if (detail.Id != 0)
{
ExternalPurchaseOrderDetail epoDetail = this.dbContext.ExternalPurchaseOrderDetails.Where(s => s.Id.ToString() == detail.EPODetailId && s.IsDeleted == false).FirstOrDefault();
epoDetail.DispositionQuantity += detail.PaidQuantity;
EntityExtension.FlagForUpdate(detail, user, "Facade");
}
}
}
}
}
this.dbContext.Update(purchasingDisposition);
foreach (var existingItem in existingModel.Items)
{
var newItem = purchasingDisposition.Items.FirstOrDefault(i => i.Id == existingItem.Id);
if (newItem == null)
{
EntityExtension.FlagForDelete(existingItem, user, "Facade");
this.dbContext.PurchasingDispositionItems.Update(existingItem);
foreach (var existingDetail in existingItem.Details)
{
EntityExtension.FlagForDelete(existingDetail, user, "Facade");
this.dbContext.PurchasingDispositionDetails.Update(existingDetail);
}
}
else
{
foreach (var existingDetail in existingItem.Details)
{
var newDetail = newItem.Details.FirstOrDefault(d => d.Id == existingDetail.Id);
if (newDetail == null)
{
EntityExtension.FlagForDelete(existingDetail, user, "Facade");
this.dbContext.PurchasingDispositionDetails.Update(existingDetail);
}
}
}
}
Updated = await dbContext.SaveChangesAsync();
transaction.Commit();
}
else
{
throw new Exception("Error");
}
}
catch (Exception e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
}
return(Updated);
}
public async Task Should_Success_Update_Data()
{
ExternalPurchaseOrder model = await DataUtil.GetTestData("Unit test");
model.UseIncomeTax = false;
foreach (var item in model.Items)
{
foreach (var detail in item.Details)
{
detail.DealQuantity -= 1;
}
}
var Response = await Facade.Update((int)model.Id, model, "Unit test");
Assert.NotEqual(Response, 0);
ExternalPurchaseOrderItem oldItem = model.Items.FirstOrDefault();
ExternalPurchaseOrderDetail oldDetail = oldItem.Details.FirstOrDefault();
ExternalPurchaseOrderItem newDuplicateItem = new ExternalPurchaseOrderItem
{
POId = oldItem.POId,
PONo = oldItem.PONo,
PRId = oldItem.PRId,
PRNo = oldItem.PRNo,
UnitId = oldItem.UnitId,
UnitCode = oldItem.UnitCode,
UnitName = oldItem.UnitName,
Details = new List <ExternalPurchaseOrderDetail>()
};
ExternalPurchaseOrderDetail oldDuplicateDetail = new ExternalPurchaseOrderDetail
{
PRItemId = oldDetail.PRItemId,
ProductId = oldDetail.ProductId,
ProductCode = oldDetail.ProductCode,
ProductName = oldDetail.ProductName,
ProductRemark = oldDetail.ProductRemark,
DOQuantity = oldDetail.DOQuantity,
DealQuantity = oldDetail.DealQuantity,
DealUomId = oldDetail.DealUomId,
DealUomUnit = oldDetail.DealUomUnit,
ReceiptQuantity = oldDetail.ReceiptQuantity,
DefaultUomId = oldDetail.DefaultUomId,
DefaultUomUnit = oldDetail.DefaultUomUnit,
POItemId = oldDetail.POItemId
};
ExternalPurchaseOrderDetail newDuplicateDetail = new ExternalPurchaseOrderDetail
{
PRItemId = oldDetail.PRItemId,
ProductRemark = oldDetail.ProductRemark,
DOQuantity = oldDetail.DOQuantity,
DealQuantity = oldDetail.DealQuantity,
DealUomId = oldDetail.DealUomId,
DealUomUnit = oldDetail.DealUomUnit,
ReceiptQuantity = oldDetail.ReceiptQuantity,
DefaultUomId = oldDetail.DefaultUomId,
DefaultUomUnit = oldDetail.DefaultUomUnit,
POItemId = oldDetail.POItemId,
ProductId = "PrdId2",
ProductCode = "PrdCode2",
ProductName = "PrdName2",
};
newDuplicateItem.Details.Add(oldDuplicateDetail);
newDuplicateItem.Details.Add(newDuplicateDetail);
model.Items.Add(newDuplicateItem);
var ResponseAddDuplicateItem = await Facade.Update((int)model.Id, model, "Unit test");
Assert.NotEqual(ResponseAddDuplicateItem, 0);
var newModelForAddItem = await DataUtil.GetNewData("Unit test");
ExternalPurchaseOrderItem newModelItem = newModelForAddItem.Items.FirstOrDefault();
model.Items.Add(newModelItem);
var ResponseAddItem = await Facade.Update((int)model.Id, model, "Unit test");
Assert.NotEqual(ResponseAddItem, 0);
model.Items.Remove(newModelItem);
model.Items.FirstOrDefault().Details.Remove(oldDetail);
var ResponseRemoveItemDetail = await Facade.Update((int)model.Id, model, "Unit test");
Assert.NotEqual(ResponseRemoveItemDetail, 0);
}
public async Task <int> Update(int id, DeliveryOrder model, string user)
{
int Updated = 0;
using (var transaction = this.dbContext.Database.BeginTransaction())
{
try
{
var existingModel = this.dbSet.AsNoTracking()
.Include(d => d.Items)
.ThenInclude(d => d.Details)
.AsNoTracking()
.SingleOrDefault(pr => pr.Id == id && !pr.IsDeleted);
if (existingModel != null && id == model.Id)
{
EntityExtension.FlagForUpdate(model, user, USER_AGENT);
foreach (var item in model.Items.ToList())
{
var existingItem = existingModel.Items.SingleOrDefault(m => m.Id == item.Id);
List <DeliveryOrderItem> duplicateDeliveryOrderItems = model.Items.Where(i => i.EPOId == item.EPOId && i.Id != item.Id).ToList();
if (item.Id == 0)
{
if (duplicateDeliveryOrderItems.Count <= 0)
{
if (model.Items.Count(i => i.EPOId == item.EPOId && !string.IsNullOrWhiteSpace(i.CreatedBy)) < 1)
{
EntityExtension.FlagForCreate(item, user, USER_AGENT);
var itemDetails = new List <DeliveryOrderDetail>();
foreach (var duplicateItem in model.Items.Where(i => i.EPOId == item.EPOId).ToList())
{
foreach (var duplicateDetail in duplicateItem.Details.ToList())
{
if (itemDetails.Count(d => d.PRId.Equals(duplicateDetail.PRId) && d.ProductId.Equals(duplicateDetail.ProductId)) < 1)
{
EntityExtension.FlagForCreate(duplicateDetail, user, USER_AGENT);
itemDetails.Add(duplicateDetail);
}
else
{
var oldDetail = itemDetails.FirstOrDefault(d => d.PRId.Equals(duplicateDetail.PRId) && d.ProductId.Equals(duplicateDetail.ProductId));
if (oldDetail != null)
{
oldDetail.DOQuantity += duplicateDetail.DOQuantity;
oldDetail.ProductRemark = String.Concat(oldDetail.ProductRemark, Environment.NewLine, duplicateDetail.ProductRemark).Trim();
}
}
}
}
item.Details = itemDetails;
foreach (var detail in item.Details.ToList())
{
ExternalPurchaseOrderDetail externalPurchaseOrderDetail = this.dbContext.ExternalPurchaseOrderDetails.SingleOrDefault(m => m.Id == detail.EPODetailId);
if (externalPurchaseOrderDetail != null)
{
externalPurchaseOrderDetail.DOQuantity += detail.DOQuantity;
EntityExtension.FlagForUpdate(externalPurchaseOrderDetail, user, USER_AGENT);
SetStatus(externalPurchaseOrderDetail, detail, user);
}
}
}
else
{
model.Items.Remove(item);
}
}
}
else
{
EntityExtension.FlagForUpdate(item, user, USER_AGENT);
if (duplicateDeliveryOrderItems.Count > 0)
{
foreach (var detail in item.Details.ToList())
{
if (detail.Id != 0)
{
EntityExtension.FlagForUpdate(detail, user, USER_AGENT);
foreach (var duplicateItem in duplicateDeliveryOrderItems.ToList())
{
foreach (var duplicateDetail in duplicateItem.Details.ToList())
{
if (detail.PRId.Equals(duplicateDetail.PRId) && detail.ProductId.Equals(duplicateDetail.ProductId))
{
detail.DOQuantity += duplicateDetail.DOQuantity;
detail.ProductRemark = String.Concat(detail.ProductRemark, Environment.NewLine, duplicateDetail.ProductRemark).Trim();
}
else if (item.Details.Count(d => d.PRId.Equals(duplicateDetail.PRId) && d.ProductId.Equals(duplicateDetail.ProductId)) < 1)
{
double duplicateDetailDOQuantity = 0;
string duplicateDetailProductRemark = string.Empty;
foreach (var duplicateItemAgain in duplicateDeliveryOrderItems.ToList())
{
var duplicateDetailAgain = duplicateItemAgain.Details.SingleOrDefault(d => d.PRId.Equals(duplicateDetail.PRId) && d.ProductId.Equals(duplicateDetail.ProductId));
duplicateDetailDOQuantity += duplicateDetailAgain.DOQuantity;
duplicateDetailProductRemark = String.Concat(duplicateDetailProductRemark, Environment.NewLine, duplicateDetailAgain.ProductRemark).Trim();
}
duplicateDetail.DOQuantity = duplicateDetailDOQuantity;
duplicateDetail.ProductRemark = duplicateDetailProductRemark;
EntityExtension.FlagForCreate(duplicateDetail, user, USER_AGENT);
item.Details.Add(duplicateDetail);
ExternalPurchaseOrderDetail externalPurchaseOrderDetail = this.dbContext.ExternalPurchaseOrderDetails.SingleOrDefault(m => m.Id == duplicateDetail.EPODetailId);
if (externalPurchaseOrderDetail != null)
{
externalPurchaseOrderDetail.DOQuantity += duplicateDetail.DOQuantity;
EntityExtension.FlagForUpdate(externalPurchaseOrderDetail, user, USER_AGENT);
SetStatus(externalPurchaseOrderDetail, duplicateDetail, user);
}
}
}
model.Items.Remove(duplicateItem);
}
var existingDetail = existingItem.Details.SingleOrDefault(m => m.Id == detail.Id);
if (existingDetail != null)
{
ExternalPurchaseOrderDetail externalPurchaseOrderDetail = this.dbContext.ExternalPurchaseOrderDetails.SingleOrDefault(m => m.Id == detail.EPODetailId);
externalPurchaseOrderDetail.DOQuantity = externalPurchaseOrderDetail.DOQuantity - existingDetail.DOQuantity + detail.DOQuantity;
EntityExtension.FlagForUpdate(externalPurchaseOrderDetail, user, USER_AGENT);
SetStatus(externalPurchaseOrderDetail, detail, user);
}
}
}
}
else
{
foreach (var detail in item.Details)
{
if (detail.Id != 0)
{
EntityExtension.FlagForUpdate(detail, user, USER_AGENT);
var existingDetail = existingItem.Details.SingleOrDefault(m => m.Id == detail.Id);
ExternalPurchaseOrderDetail externalPurchaseOrderDetail = this.dbContext.ExternalPurchaseOrderDetails.SingleOrDefault(m => m.Id == detail.EPODetailId);
if (externalPurchaseOrderDetail != null)
{
externalPurchaseOrderDetail.DOQuantity = externalPurchaseOrderDetail.DOQuantity - existingDetail.DOQuantity + detail.DOQuantity;
EntityExtension.FlagForUpdate(externalPurchaseOrderDetail, user, USER_AGENT);
SetStatus(externalPurchaseOrderDetail, detail, user);
}
}
}
}
}
}
this.dbContext.Update(model);
foreach (var existingItem in existingModel.Items)
{
var newItem = model.Items.FirstOrDefault(i => i.Id == existingItem.Id);
if (newItem == null)
{
EntityExtension.FlagForDelete(existingItem, user, USER_AGENT);
this.dbContext.DeliveryOrderItems.Update(existingItem);
foreach (var existingDetail in existingItem.Details)
{
EntityExtension.FlagForDelete(existingDetail, user, USER_AGENT);
dbContext.Entry(existingDetail).State = EntityState.Modified;
//this.dbContext.DeliveryOrderDetails.Update(existingDetail);
ExternalPurchaseOrderDetail externalPurchaseOrderDetail = this.dbContext.ExternalPurchaseOrderDetails.SingleOrDefault(m => m.Id == existingDetail.EPODetailId);
if (externalPurchaseOrderDetail != null)
{
externalPurchaseOrderDetail.DOQuantity -= existingDetail.DOQuantity;
EntityExtension.FlagForUpdate(externalPurchaseOrderDetail, user, USER_AGENT);
SetStatus(externalPurchaseOrderDetail, existingDetail, user);
}
}
}
else
{
foreach (var existingDetail in existingItem.Details)
{
var newDetail = newItem.Details.FirstOrDefault(d => d.Id == existingDetail.Id);
if (newDetail == null)
{
EntityExtension.FlagForDelete(existingDetail, user, USER_AGENT);
dbContext.Entry(existingDetail).State = EntityState.Modified;
//this.dbContext.DeliveryOrderDetails.Update(existingDetail);
ExternalPurchaseOrderDetail externalPurchaseOrderDetail = this.dbContext.ExternalPurchaseOrderDetails.SingleOrDefault(m => m.Id == existingDetail.EPODetailId);
if (externalPurchaseOrderDetail != null)
{
externalPurchaseOrderDetail.DOQuantity -= existingDetail.DOQuantity;
EntityExtension.FlagForUpdate(externalPurchaseOrderDetail, user, USER_AGENT);
SetStatus(externalPurchaseOrderDetail, existingDetail, user);
}
}
}
}
}
Updated = await dbContext.SaveChangesAsync();
var updatedModel = this.dbSet.AsNoTracking()
.Include(d => d.Items)
.ThenInclude(d => d.Details)
.SingleOrDefault(pr => pr.Id == model.Id && !pr.IsDeleted);
Updated += await EditFulfillmentAsync(updatedModel, user);
transaction.Commit();
}
else
{
throw new Exception("Invalid Id");
}
}
catch (Exception e)
{
transaction.Rollback();
while (e.InnerException != null)
{
e = e.InnerException;
}
throw e;
}
}
return(Updated);
}
public PurchasingDisposition GetNewData()
{
var datas = Task.Run(() => externalPurchaseOrderDataUtil.GetTestData("unit-test")).Result;
var itemData = datas.Items;
ExternalPurchaseOrderDetail detailData = new ExternalPurchaseOrderDetail();
ExternalPurchaseOrderItem itemdata = new ExternalPurchaseOrderItem();
foreach (var item in itemData)
{
itemdata = item; break;
}
foreach (var detail in itemdata.Details)
{
detailData = detail; break;
}
return(new PurchasingDisposition
{
SupplierId = "1",
SupplierCode = "Supplier1",
SupplierName = "supplier1",
Bank = "Bank",
Amount = 1000,
Calculation = "axb+c",
//InvoiceNo="test",
ConfirmationOrderNo = "test",
//Investation = "test",
PaymentDueDate = new DateTimeOffset(),
ProformaNo = "aaa",
PaymentMethod = "Test",
Remark = "Remark1",
Items = new List <PurchasingDispositionItem>
{
new PurchasingDispositionItem
{
EPOId = datas.Id.ToString(),
EPONo = datas.EPONo,
IncomeTaxId = "1",
IncomeTaxName = "tax",
IncomeTaxRate = 1,
UseIncomeTax = true,
UseVat = true,
Details = new List <PurchasingDispositionDetail>
{
new PurchasingDispositionDetail
{
//EPODetailId=detailData.Id.ToString(),
CategoryCode = "test",
CategoryId = "1",
CategoryName = "test",
DealQuantity = 10,
PaidQuantity = 1000,
DealUomId = "1",
DealUomUnit = "test",
PaidPrice = 1000,
PricePerDealUnit = 100,
PriceTotal = 10000,
PRId = "1",
PRNo = "test",
ProductCode = "test",
ProductName = "test",
ProductId = "1",
UnitName = "test",
UnitCode = "test",
UnitId = "1",
}
}
}
}
});
}
public int Delete(int id, string user)
{
int Deleted = 0;
using (var transaction = this.dbContext.Database.BeginTransaction())
{
try
{
var m = this.dbSet
.Include(d => d.Items)
.SingleOrDefault(pr => pr.Id == id && !pr.IsDeleted);
EntityExtension.FlagForDelete(m, user, USER_AGENT);
foreach (var item in m.Items)
{
EntityExtension.FlagForDelete(item, user, USER_AGENT);
ExternalPurchaseOrderDetail externalPurchaseOrderDetail = this.dbContext.ExternalPurchaseOrderDetails.FirstOrDefault(s => s.IsDeleted == false && s.Id == item.EPODetailId);
PurchaseRequestItem prItem = this.dbContext.PurchaseRequestItems.FirstOrDefault(s => s.IsDeleted == false && s.Id == externalPurchaseOrderDetail.PRItemId);
InternalPurchaseOrderItem poItem = this.dbContext.InternalPurchaseOrderItems.FirstOrDefault(s => s.IsDeleted == false && s.Id == externalPurchaseOrderDetail.POItemId);
DeliveryOrderDetail doDetail = dbContext.DeliveryOrderDetails.FirstOrDefault(s => s.IsDeleted == false && s.Id == item.DODetailId);
UnitPaymentOrderDetail upoDetail = dbContext.UnitPaymentOrderDetails.FirstOrDefault(s => s.IsDeleted == false && s.POItemId == poItem.Id);
doDetail.ReceiptQuantity -= item.ReceiptQuantity;
externalPurchaseOrderDetail.ReceiptQuantity -= item.ReceiptQuantity;
if (externalPurchaseOrderDetail.ReceiptQuantity == 0 && upoDetail == null)
{
if (externalPurchaseOrderDetail.DOQuantity > 0 && externalPurchaseOrderDetail.DOQuantity >= externalPurchaseOrderDetail.DealQuantity)
{
//prItem.Status = "Barang sudah diterima Unit semua";
poItem.Status = "Barang sudah datang semua";
}
else if (externalPurchaseOrderDetail.DOQuantity > 0 && externalPurchaseOrderDetail.DOQuantity < externalPurchaseOrderDetail.DealQuantity)
{
//prItem.Status = "Barang sudah diterima Unit parsial";
poItem.Status = "Barang sudah datang parsial";
}
}
else if (externalPurchaseOrderDetail.ReceiptQuantity > 0 && upoDetail == null)
{
if (externalPurchaseOrderDetail.DOQuantity >= externalPurchaseOrderDetail.DealQuantity)
{
if (externalPurchaseOrderDetail.ReceiptQuantity < externalPurchaseOrderDetail.DealQuantity)
{
//prItem.Status = "Barang sudah diterima Unit parsial";
poItem.Status = "Barang sudah diterima Unit parsial";
}
else if (externalPurchaseOrderDetail.ReceiptQuantity >= externalPurchaseOrderDetail.DealQuantity)
{
//prItem.Status = "Barang sudah diterima Unit semua";
poItem.Status = "Barang sudah diterima Unit semua";
}
else if (externalPurchaseOrderDetail.DOQuantity < externalPurchaseOrderDetail.DealQuantity)
{
poItem.Status = "Barang sudah diterima Unit parsial";
}
}
}
}
if (m.IsStorage == true)
{
insertStorage(m, user, "OUT");
}
Deleted = dbContext.SaveChanges();
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
}
return(Deleted);
}
public async Task <int> Create(UnitReceiptNote m, string user)
{
int Created = 0;
using (var transaction = this.dbContext.Database.BeginTransaction())
{
try
{
EntityExtension.FlagForCreate(m, user, "Facade");
m.URNNo = await GenerateNo(m);
if (m.Items != null)
{
foreach (var item in m.Items)
{
EntityExtension.FlagForCreate(item, user, "Facade");
ExternalPurchaseOrderDetail externalPurchaseOrderDetail = this.dbContext.ExternalPurchaseOrderDetails.FirstOrDefault(s => s.Id == item.EPODetailId);
PurchaseRequestItem prItem = this.dbContext.PurchaseRequestItems.FirstOrDefault(s => s.Id == externalPurchaseOrderDetail.PRItemId);
InternalPurchaseOrderItem poItem = this.dbContext.InternalPurchaseOrderItems.FirstOrDefault(s => s.Id == externalPurchaseOrderDetail.POItemId);
DeliveryOrderDetail doDetail = dbContext.DeliveryOrderDetails.FirstOrDefault(s => s.Id == item.DODetailId);
UnitPaymentOrderDetail upoDetail = dbContext.UnitPaymentOrderDetails.FirstOrDefault(s => s.IsDeleted == false && s.POItemId == poItem.Id);
item.PRItemId = doDetail.PRItemId;
item.PricePerDealUnit = externalPurchaseOrderDetail.PricePerDealUnit;
doDetail.ReceiptQuantity += item.ReceiptQuantity;
externalPurchaseOrderDetail.ReceiptQuantity += item.ReceiptQuantity;
if (upoDetail == null)
{
if (externalPurchaseOrderDetail.DOQuantity >= externalPurchaseOrderDetail.DealQuantity)
{
if (externalPurchaseOrderDetail.ReceiptQuantity < externalPurchaseOrderDetail.DealQuantity)
{
//prItem.Status = "Barang sudah diterima Unit parsial";
poItem.Status = "Barang sudah diterima Unit parsial";
}
else
{
//prItem.Status = "Barang sudah diterima Unit semua";
poItem.Status = "Barang sudah diterima Unit semua";
}
}
else
{
//prItem.Status = "Barang sudah diterima Unit parsial";
poItem.Status = "Barang sudah diterima Unit parsial";
}
}
}
}
if (m.IsStorage == true)
{
insertStorage(m, user, "IN");
}
this.dbSet.Add(m);
Created = await dbContext.SaveChangesAsync();
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
}
return(Created);
}
