public async Task <BankExpenditureNoteDetailModel> GetNewDetailGarmentData()
{
PurchasingDocumentExpedition purchasingDocumentExpedition = await Task.Run(() => this.pdaDataUtil.GetCashierTestData());
List <BankExpenditureNoteItemModel> Items = new List <BankExpenditureNoteItemModel>();
foreach (var item in purchasingDocumentExpedition.Items)
{
BankExpenditureNoteItemModel Item = new BankExpenditureNoteItemModel
{
Price = item.Price,
ProductCode = item.ProductCode,
ProductId = item.ProductId,
ProductName = item.ProductName,
Quantity = item.Quantity,
UnitCode = item.UnitCode,
UnitId = item.UnitId,
UnitName = item.UnitName,
Uom = item.Uom
};
Items.Add(Item);
}
return(new BankExpenditureNoteDetailModel()
{
Id = 0,
UnitPaymentOrderId = purchasingDocumentExpedition.Id,
UnitPaymentOrderNo = purchasingDocumentExpedition.UnitPaymentOrderNo,
DivisionCode = purchasingDocumentExpedition.DivisionCode,
DivisionName = "GARMENT",
Currency = purchasingDocumentExpedition.Currency,
DueDate = purchasingDocumentExpedition.DueDate,
InvoiceNo = purchasingDocumentExpedition.InvoiceNo,
SupplierCode = purchasingDocumentExpedition.SupplierCode,
SupplierName = purchasingDocumentExpedition.SupplierName,
TotalPaid = purchasingDocumentExpedition.TotalPaid,
UPODate = purchasingDocumentExpedition.UPODate,
Vat = purchasingDocumentExpedition.Vat,
Items = Items
});
}
public PurchasingDocumentAcceptanceViewModel GetNewData()
{
purchasingDocumentExpedition = Task.Run(() => this.sendToVerificationDataUtil.GetTestData()).Result;
PurchasingDocumentAcceptanceItem item = new PurchasingDocumentAcceptanceItem()
{
Id = purchasingDocumentExpedition.Id,
UnitPaymentOrderNo = purchasingDocumentExpedition.UnitPaymentOrderNo
};
PurchasingDocumentAcceptanceViewModel TestData = new PurchasingDocumentAcceptanceViewModel()
{
PurchasingDocumentExpedition = new List <PurchasingDocumentAcceptanceItem>()
{
item
}
};
return(TestData);
}
public async Task <PPHBankExpenditureNote> GetNewData()
{
PurchasingDocumentExpedition purchasingDocumentExpedition1 = await Task.Run(() => this.pdaDataUtil.GetCashierTestData());
PurchasingDocumentExpedition purchasingDocumentExpedition2 = await Task.Run(() => this.pdaDataUtil.GetCashierTestData());
List <PPHBankExpenditureNoteItem> Items = new List <PPHBankExpenditureNoteItem>()
{
new PPHBankExpenditureNoteItem()
{
PurchasingDocumentExpeditionId = purchasingDocumentExpedition1.Id,
UnitPaymentOrderNo = purchasingDocumentExpedition1.UnitPaymentOrderNo,
},
new PPHBankExpenditureNoteItem()
{
PurchasingDocumentExpeditionId = purchasingDocumentExpedition2.Id,
UnitPaymentOrderNo = purchasingDocumentExpedition2.UnitPaymentOrderNo,
}
};
PPHBankExpenditureNote TestData = new PPHBankExpenditureNote()
{
Date = DateTimeOffset.UtcNow,
BankAccountNumber = "100020003000",
BankAccountName = "BankAccountName",
BankCode = "BankCode",
BankId = "BankId",
BankName = "BankName",
BGNo = "BGNo",
IncomeTaxId = "IncomeTaxId",
IncomeTaxName = "IncomeTaxName",
IncomeTaxRate = 2,
Items = Items,
No = "No",
TotalDPP = 1100000,
TotalIncomeTax = 100000,
Currency = "IDR"
};
return(TestData);
}
public async Task <int> Delete(int id)
{
int Count = 0;
if (this.dbContext.PurchasingDocumentExpeditions.Count(p => p.Id == id && p.IsDeleted == false).Equals(0))
{
return(0);
}
using (var transaction = this.dbContext.Database.BeginTransaction())
{
try
{
IdentityService identityService = serviceProvider.GetService <IdentityService>();
PurchasingDocumentExpedition purchasingDocumentExpedition = dbContext.PurchasingDocumentExpeditions.Single(p => p.Id == id && p.Position == ExpeditionPosition.SEND_TO_VERIFICATION_DIVISION);
EntityExtension.FlagForDelete(purchasingDocumentExpedition, identityService.Username, "Facade");
this.dbSet.Update(purchasingDocumentExpedition);
Count = await this.dbContext.SaveChangesAsync();
UpdateUnitPaymentOrderPosition(new List <string>()
{
purchasingDocumentExpedition.UnitPaymentOrderNo
}, ExpeditionPosition.PURCHASING_DIVISION);
transaction.Commit();
}
catch (DbUpdateConcurrencyException e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
catch (Exception e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
}
return(Count);
}
public async Task Should_Success_Get_Unit_Payment_Order_With_Date()
{
var numberGeneratorMock = new Mock <IBankDocumentNumberGenerator>();
var serviceProvider = new Mock <IServiceProvider>();
serviceProvider
.Setup(x => x.GetService(typeof(IHttpClientService)))
.Returns(new HttpClientTestService());
var services = new ServiceCollection();
services.AddMemoryCache();
var serviceProviders = services.BuildServiceProvider();
var memoryCache = serviceProviders.GetService <IMemoryCache>();
var mockMemoryCache = new Mock <IMemoryCacheManager>();
mockMemoryCache.Setup(x => x.Get(MemoryCacheConstant.Divisions, It.IsAny <Func <ICacheEntry, List <IdCOAResult> > >()))
.Returns(new List <IdCOAResult>());
mockMemoryCache.Setup(x => x.Get(MemoryCacheConstant.BankAccounts, It.IsAny <Func <ICacheEntry, List <BankAccountCOAResult> > >()))
.Returns(new List <BankAccountCOAResult>());
mockMemoryCache.Setup(x => x.Get(MemoryCacheConstant.IncomeTaxes, It.IsAny <Func <ICacheEntry, List <IncomeTaxCOAResult> > >()))
.Returns(new List <IncomeTaxCOAResult>());
serviceProvider
.Setup(x => x.GetService(typeof(IMemoryCacheManager)))
.Returns(mockMemoryCache.Object);
PPHBankExpenditureNoteFacade facade = new PPHBankExpenditureNoteFacade(_dbContext(GetCurrentMethod()), numberGeneratorMock.Object, serviceProvider.Object);
_dataUtil(facade, GetCurrentMethod());
PurchasingDocumentExpedition model = await pdaDataUtil.GetCashierTestData();
var Response = facade.GetUnitPaymentOrder(model.DueDate, model.DueDate, model.IncomeTaxName, model.IncomeTaxRate, model.Currency, model.DivisionCode);
Assert.NotEmpty(Response);
}
public async Task <BankExpenditureNoteModel> GetNewData()
{
PurchasingDocumentExpedition purchasingDocumentExpedition1 = await Task.Run(() => this.pdaDataUtil.GetCashierTestData());
PurchasingDocumentExpedition purchasingDocumentExpedition2 = await Task.Run(() => this.pdaDataUtil.GetCashierTestData());
List <BankExpenditureNoteDetailModel> Details = new List <BankExpenditureNoteDetailModel>()
{
await GetNewDetailSpinningData(),
await GetNewDetailWeavingData(),
await GetNewDetailFinishingPrintingData(),
await GetNewDetailGarmentData()
};
BankExpenditureNoteModel TestData = new BankExpenditureNoteModel()
{
BankAccountNumber = "100020003000",
BankAccountCOA = "BankAccountCOA",
BankAccountName = "BankAccountName",
BankCode = "BankCode",
BankId = 1,
BankName = "BankName",
BankCurrencyCode = "CurrencyCode",
BankCurrencyId = 1,
BankCurrencyRate = "1",
GrandTotal = 120,
BGCheckNumber = "BGNo",
SupplierImport = false,
CurrencyRate = 1,
CurrencyId = 1,
CurrencyCode = "Code",
Details = Details,
};
return(TestData);
}
public async Task <int> Delete(int id, string username)
{
int Count = 0;
if (this.dbContext.PPHBankExpenditureNotes.Count(p => p.Id == id && p.IsDeleted == false).Equals(0))
{
return(0);
}
using (var transaction = this.dbContext.Database.BeginTransaction())
{
try
{
PPHBankExpenditureNote PPHBankExpenditureNote = dbContext.PPHBankExpenditureNotes.Single(p => p.Id == id);
ICollection <PPHBankExpenditureNoteItem> Items = new List <PPHBankExpenditureNoteItem>(this.dbContext.PPHBankExpenditureNoteItems.Where(p => p.PPHBankExpenditureNoteId.Equals(id)));
foreach (PPHBankExpenditureNoteItem item in Items)
{
EntityExtension.FlagForDelete(item, username, UserAgent);
this.dbContext.PPHBankExpenditureNoteItems.Update(item);
PurchasingDocumentExpedition pde = new PurchasingDocumentExpedition
{
Id = item.PurchasingDocumentExpeditionId,
IsPaidPPH = false,
BankExpenditureNotePPHNo = null,
BankExpenditureNotePPHDate = null
};
EntityExtension.FlagForUpdate(pde, username, UserAgent);
//dbContext.Attach(pde);
dbContext.Entry(pde).Property(x => x.IsPaidPPH).IsModified = true;
dbContext.Entry(pde).Property(x => x.BankExpenditureNotePPHNo).IsModified = true;
dbContext.Entry(pde).Property(x => x.BankExpenditureNotePPHDate).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedAgent).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedBy).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedUtc).IsModified = true;
}
EntityExtension.FlagForDelete(PPHBankExpenditureNote, username, UserAgent);
this.dbSet.Update(PPHBankExpenditureNote);
Count = await this.dbContext.SaveChangesAsync();
//await ReverseJournalTransaction(PPHBankExpenditureNote.No);
//await DeleteDailyBankTransaction(PPHBankExpenditureNote.No);
transaction.Commit();
}
catch (DbUpdateConcurrencyException e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
catch (Exception e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
}
return(Count);
}
public async Task <int> Update(int id, PPHBankExpenditureNote model, string username)
{
int Updated = 0;
using (var transaction = this.dbContext.Database.BeginTransaction())
{
try
{
EntityExtension.FlagForUpdate(model, username, UserAgent);
dbContext.Entry(model).Property(x => x.Date).IsModified = true;
dbContext.Entry(model).Property(x => x.TotalDPP).IsModified = true;
dbContext.Entry(model).Property(x => x.TotalIncomeTax).IsModified = true;
dbContext.Entry(model).Property(x => x.BGNo).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedAgent).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedBy).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedUtc).IsModified = true;
foreach (var item in model.Items)
{
if (item.Id == 0)
{
EntityExtension.FlagForCreate(item, username, UserAgent);
dbContext.PPHBankExpenditureNoteItems.Add(item);
PurchasingDocumentExpedition pde = new PurchasingDocumentExpedition
{
Id = item.PurchasingDocumentExpeditionId,
IsPaidPPH = true,
BankExpenditureNotePPHNo = model.No,
BankExpenditureNotePPHDate = model.Date
};
EntityExtension.FlagForUpdate(pde, username, UserAgent);
//dbContext.Attach(pde);
dbContext.Entry(pde).Property(x => x.IsPaidPPH).IsModified = true;
dbContext.Entry(pde).Property(x => x.BankExpenditureNotePPHNo).IsModified = true;
dbContext.Entry(pde).Property(x => x.BankExpenditureNotePPHDate).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedAgent).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedBy).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedUtc).IsModified = true;
}
}
foreach (var item in dbContext.PPHBankExpenditureNoteItems.AsNoTracking().Where(p => p.PPHBankExpenditureNoteId == model.Id))
{
PPHBankExpenditureNoteItem itemModel = model.Items.FirstOrDefault(prop => prop.Id.Equals(item.Id));
if (itemModel == null)
{
EntityExtension.FlagForDelete(item, username, UserAgent);
this.dbContext.PPHBankExpenditureNoteItems.Update(item);
PurchasingDocumentExpedition pde = new PurchasingDocumentExpedition
{
Id = item.PurchasingDocumentExpeditionId,
IsPaidPPH = false,
BankExpenditureNotePPHDate = null,
BankExpenditureNotePPHNo = null
};
EntityExtension.FlagForUpdate(pde, username, UserAgent);
//dbContext.Attach(pde);
dbContext.Entry(pde).Property(x => x.IsPaidPPH).IsModified = true;
dbContext.Entry(pde).Property(x => x.BankExpenditureNotePPHNo).IsModified = true;
dbContext.Entry(pde).Property(x => x.BankExpenditureNotePPHDate).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedAgent).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedBy).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedUtc).IsModified = true;
}
}
Updated = await dbContext.SaveChangesAsync();
//await ReverseJournalTransaction(model.No);
//await AutoCreateJournalTransaction(model);
//await DeleteDailyBankTransaction(model.No);
//await CreateDailyBankTransaction(model);
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
}
return(Updated);
}
public async Task <int> Delete(int Id, IdentityService identityService)
{
int Count = 0;
string username = identityService.Username;
if (dbSet.Count(p => p.Id == Id && p.IsDeleted == false).Equals(0))
{
return(0);
}
using (var transaction = dbContext.Database.BeginTransaction())
{
try
{
BankExpenditureNoteModel bankExpenditureNote = dbContext.BankExpenditureNotes.Include(entity => entity.Details).Single(p => p.Id == Id);
ICollection <BankExpenditureNoteDetailModel> Details = new List <BankExpenditureNoteDetailModel>(dbContext.BankExpenditureNoteDetails.Where(p => p.BankExpenditureNoteId.Equals(Id)));
foreach (var detail in Details)
{
ICollection <BankExpenditureNoteItemModel> Items = new List <BankExpenditureNoteItemModel>(dbContext.BankExpenditureNoteItems.Where(p => p.BankExpenditureNoteDetailId.Equals(detail.Id)));
foreach (var item in Items)
{
EntityExtension.FlagForDelete(item, username, USER_AGENT);
dbContext.BankExpenditureNoteItems.Update(item);
}
EntityExtension.FlagForDelete(detail, username, USER_AGENT);
dbContext.BankExpenditureNoteDetails.Update(detail);
PurchasingDocumentExpedition pde = new PurchasingDocumentExpedition
{
Id = (int)detail.UnitPaymentOrderId,
IsPaid = false,
BankExpenditureNoteNo = null,
BankExpenditureNoteDate = null
};
EntityExtension.FlagForUpdate(pde, username, USER_AGENT);
//dbContext.Attach(pde);
dbContext.Entry(pde).Property(x => x.IsPaid).IsModified = true;
dbContext.Entry(pde).Property(x => x.BankExpenditureNoteNo).IsModified = true;
dbContext.Entry(pde).Property(x => x.BankExpenditureNoteDate).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedAgent).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedBy).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedUtc).IsModified = true;
}
EntityExtension.FlagForDelete(bankExpenditureNote, username, USER_AGENT);
dbSet.Update(bankExpenditureNote);
Count = await dbContext.SaveChangesAsync();
DeleteDailyBankTransaction(bankExpenditureNote.DocumentNo, identityService);
DeleteCreditorAccount(bankExpenditureNote, identityService);
ReverseJournalTransaction(bankExpenditureNote);
transaction.Commit();
}
catch (DbUpdateConcurrencyException e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
catch (Exception e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
}
return(Count);
}
public async Task <int> Update(int id, BankExpenditureNoteModel model, IdentityService identityService)
{
int Updated = 0;
string username = identityService.Username;
using (var transaction = this.dbContext.Database.BeginTransaction())
{
try
{
EntityExtension.FlagForUpdate(model, username, USER_AGENT);
dbContext.Entry(model).Property(x => x.GrandTotal).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedAgent).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedBy).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedUtc).IsModified = true;
foreach (var detail in model.Details)
{
if (detail.Id == 0)
{
EntityExtension.FlagForCreate(detail, username, USER_AGENT);
dbContext.BankExpenditureNoteDetails.Add(detail);
PurchasingDocumentExpedition pde = new PurchasingDocumentExpedition
{
Id = (int)detail.UnitPaymentOrderId,
IsPaid = true,
BankExpenditureNoteNo = model.DocumentNo,
BankExpenditureNoteDate = model.Date
};
EntityExtension.FlagForUpdate(pde, username, USER_AGENT);
//dbContext.Attach(pde);
dbContext.Entry(pde).Property(x => x.IsPaid).IsModified = true;
dbContext.Entry(pde).Property(x => x.BankExpenditureNoteNo).IsModified = true;
dbContext.Entry(pde).Property(x => x.BankExpenditureNoteDate).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedAgent).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedBy).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedUtc).IsModified = true;
foreach (var item in detail.Items)
{
EntityExtension.FlagForCreate(item, username, USER_AGENT);
}
}
}
foreach (var detail in dbContext.BankExpenditureNoteDetails.AsNoTracking().Where(p => p.BankExpenditureNoteId == model.Id))
{
BankExpenditureNoteDetailModel detailModel = model.Details.FirstOrDefault(prop => prop.Id.Equals(detail.Id));
if (detailModel == null)
{
EntityExtension.FlagForDelete(detail, username, USER_AGENT);
foreach (var item in dbContext.BankExpenditureNoteItems.AsNoTracking().Where(p => p.BankExpenditureNoteDetailId == detail.Id))
{
EntityExtension.FlagForDelete(item, username, USER_AGENT);
dbContext.BankExpenditureNoteItems.Update(item);
}
dbContext.BankExpenditureNoteDetails.Update(detail);
PurchasingDocumentExpedition pde = new PurchasingDocumentExpedition
{
Id = (int)detail.UnitPaymentOrderId,
IsPaid = false,
BankExpenditureNoteNo = null,
BankExpenditureNoteDate = null
};
EntityExtension.FlagForUpdate(pde, username, USER_AGENT);
//dbContext.Attach(pde);
dbContext.Entry(pde).Property(x => x.IsPaid).IsModified = true;
dbContext.Entry(pde).Property(x => x.BankExpenditureNoteNo).IsModified = true;
dbContext.Entry(pde).Property(x => x.BankExpenditureNoteDate).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedAgent).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedBy).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedUtc).IsModified = true;
}
}
Updated = await dbContext.SaveChangesAsync();
DeleteDailyBankTransaction(model.DocumentNo, identityService);
CreateDailyBankTransaction(model, identityService);
UpdateCreditorAccount(model, identityService);
ReverseJournalTransaction(model);
CreateJournalTransaction(model, identityService);
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
}
return(Updated);
}
public async Task <int> Create(BankExpenditureNoteModel model, IdentityService identityService)
{
int Created = 0;
string username = identityService.Username;
using (var transaction = dbContext.Database.BeginTransaction())
{
try
{
EntityExtension.FlagForCreate(model, username, USER_AGENT);
model.DocumentNo = await bankDocumentNumberGenerator.GenerateDocumentNumber("K", model.BankCode, username);
if (model.BankCurrencyCode != "IDR")
{
var garmentCurrency = await GetGarmentCurrency(model.CurrencyCode);
model.CurrencyRate = garmentCurrency.Rate.GetValueOrDefault();
}
foreach (var detail in model.Details)
{
EntityExtension.FlagForCreate(detail, username, USER_AGENT);
PurchasingDocumentExpedition pde = new PurchasingDocumentExpedition
{
Id = (int)detail.UnitPaymentOrderId,
IsPaid = true,
BankExpenditureNoteNo = model.DocumentNo,
BankExpenditureNoteDate = model.Date
};
EntityExtension.FlagForUpdate(pde, username, USER_AGENT);
dbContext.Attach(pde);
dbContext.Entry(pde).Property(x => x.IsPaid).IsModified = true;
dbContext.Entry(pde).Property(x => x.BankExpenditureNoteNo).IsModified = true;
dbContext.Entry(pde).Property(x => x.BankExpenditureNoteDate).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedAgent).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedBy).IsModified = true;
dbContext.Entry(pde).Property(x => x.LastModifiedUtc).IsModified = true;
foreach (var item in detail.Items)
{
EntityExtension.FlagForCreate(item, username, USER_AGENT);
}
}
dbSet.Add(model);
Created = await dbContext.SaveChangesAsync();
//await CreateJournalTransaction(model, identityService);
//CreateDailyBankTransaction(model, identityService);
//CreateCreditorAccount(model, identityService);
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
}
return(Created);
}
public async Task <int> UnitPaymentOrderVerification(PurchasingDocumentExpedition data, string username)
{
int Count = 0;
using (var transaction = this.dbContext.Database.BeginTransaction())
{
try
{
PurchasingDocumentExpedition purchasingDocumentExpedition;
if (!data.Id.Equals(0))
{
purchasingDocumentExpedition = this.dbSet.AsNoTracking().Single(d => d.Id == data.Id);
}
else
{
purchasingDocumentExpedition = this.dbSet.AsNoTracking().Single(d => d.UnitPaymentOrderNo == data.UnitPaymentOrderNo && d.IsDeleted == false && d.Active == true);
}
if (data.Position.Equals(ExpeditionPosition.SEND_TO_PURCHASING_DIVISION))
{
purchasingDocumentExpedition.UnitPaymentOrderNo = data.UnitPaymentOrderNo;
purchasingDocumentExpedition.VerifyDate = data.VerifyDate;
purchasingDocumentExpedition.SendToPurchasingDivisionDate = data.VerifyDate;
purchasingDocumentExpedition.SendToPurchasingDivisionBy = username;
purchasingDocumentExpedition.Position = ExpeditionPosition.SEND_TO_PURCHASING_DIVISION;
purchasingDocumentExpedition.Active = false;
purchasingDocumentExpedition.NotVerifiedReason = data.NotVerifiedReason;
EntityExtension.FlagForUpdate(purchasingDocumentExpedition, username, "Facade");
dbContext.Attach(purchasingDocumentExpedition);
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.SendToPurchasingDivisionDate).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.SendToPurchasingDivisionBy).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.Active).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.VerifyDate).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.Position).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.NotVerifiedReason).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.LastModifiedAgent).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.LastModifiedBy).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.LastModifiedUtc).IsModified = true;
await dbContext.SaveChangesAsync();
UpdateUnitPaymentOrderPosition(new List <string>()
{
purchasingDocumentExpedition.UnitPaymentOrderNo
}, ExpeditionPosition.SEND_TO_PURCHASING_DIVISION, username);
}
else if (data.Position.Equals(ExpeditionPosition.SEND_TO_CASHIER_DIVISION))
{
purchasingDocumentExpedition.VerifyDate = data.VerifyDate;
purchasingDocumentExpedition.SendToCashierDivisionDate = data.VerifyDate;
purchasingDocumentExpedition.SendToCashierDivisionBy = username;
purchasingDocumentExpedition.Position = ExpeditionPosition.SEND_TO_CASHIER_DIVISION;
purchasingDocumentExpedition.Active = true;
EntityExtension.FlagForUpdate(purchasingDocumentExpedition, username, "Facade");
dbContext.Attach(purchasingDocumentExpedition);
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.SendToCashierDivisionDate).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.SendToCashierDivisionBy).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.Active).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.VerifyDate).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.Position).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.LastModifiedAgent).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.LastModifiedBy).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.LastModifiedUtc).IsModified = true;
await dbContext.SaveChangesAsync();
UpdateUnitPaymentOrderPosition(new List <string>()
{
purchasingDocumentExpedition.UnitPaymentOrderNo
}, ExpeditionPosition.SEND_TO_CASHIER_DIVISION, username);
}
else if (data.Position.Equals(ExpeditionPosition.SEND_TO_ACCOUNTING_DIVISION))
{
purchasingDocumentExpedition.VerifyDate = data.VerifyDate;
purchasingDocumentExpedition.SendToAccountingDivisionDate = data.VerifyDate;
purchasingDocumentExpedition.SendToAccountingDivisionBy = username;
purchasingDocumentExpedition.Position = ExpeditionPosition.SEND_TO_ACCOUNTING_DIVISION;
purchasingDocumentExpedition.Active = true;
EntityExtension.FlagForUpdate(purchasingDocumentExpedition, username, "Facade");
dbContext.Attach(purchasingDocumentExpedition);
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.SendToAccountingDivisionDate).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.SendToAccountingDivisionBy).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.Active).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.VerifyDate).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.Position).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.LastModifiedAgent).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.LastModifiedBy).IsModified = true;
dbContext.Entry(purchasingDocumentExpedition).Property(x => x.LastModifiedUtc).IsModified = true;
await dbContext.SaveChangesAsync();
UpdateUnitPaymentOrderPosition(new List <string>()
{
purchasingDocumentExpedition.UnitPaymentOrderNo
}, ExpeditionPosition.SEND_TO_ACCOUNTING_DIVISION, username);
}
transaction.Commit();
}
catch (DbUpdateConcurrencyException e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
catch (Exception e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
}
return(Count);
}
public async Task <int> DeletePurchasingDocumentAcceptance(int id)
{
int Count = 0;
if (this.dbContext.PurchasingDocumentExpeditions.Count(p => p.Id == id && p.IsDeleted == false).Equals(0))
{
return(0);
}
using (var transaction = this.dbContext.Database.BeginTransaction())
{
try
{
PurchasingDocumentExpedition model;
PurchasingDocumentExpedition purchasingDocumentExpedition = this.dbSet.AsNoTracking().Single(p => p.Id == id);
IdentityService identityService = serviceProvider.GetService <IdentityService>();
if (purchasingDocumentExpedition.Position == ExpeditionPosition.VERIFICATION_DIVISION)
{
model = new PurchasingDocumentExpedition
{
Id = id,
VerificationDivisionBy = null,
VerificationDivisionDate = null,
Position = ExpeditionPosition.SEND_TO_VERIFICATION_DIVISION,
};
EntityExtension.FlagForUpdate(model, identityService.Username, "Facade");
dbContext.Attach(model);
dbContext.Entry(model).Property(x => x.VerificationDivisionBy).IsModified = true;
dbContext.Entry(model).Property(x => x.VerificationDivisionDate).IsModified = true;
dbContext.Entry(model).Property(x => x.Position).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedAgent).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedBy).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedUtc).IsModified = true;
Count = await dbContext.SaveChangesAsync();
UpdateUnitPaymentOrderPosition(new List <string>()
{
purchasingDocumentExpedition.UnitPaymentOrderNo
}, ExpeditionPosition.SEND_TO_VERIFICATION_DIVISION, identityService.Username);
}
else if (purchasingDocumentExpedition.Position == ExpeditionPosition.CASHIER_DIVISION)
{
model = new PurchasingDocumentExpedition
{
Id = id,
CashierDivisionBy = null,
CashierDivisionDate = null,
Position = ExpeditionPosition.SEND_TO_CASHIER_DIVISION,
};
EntityExtension.FlagForUpdate(model, identityService.Username, "Facade");
dbContext.Attach(model);
dbContext.Entry(model).Property(x => x.CashierDivisionBy).IsModified = true;
dbContext.Entry(model).Property(x => x.CashierDivisionDate).IsModified = true;
dbContext.Entry(model).Property(x => x.Position).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedAgent).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedBy).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedUtc).IsModified = true;
Count = await dbContext.SaveChangesAsync();
UpdateUnitPaymentOrderPosition(new List <string>()
{
purchasingDocumentExpedition.UnitPaymentOrderNo
}, ExpeditionPosition.SEND_TO_CASHIER_DIVISION, identityService.Username);
}
/*
* else if (purchasingDocumentExpedition.Position == ExpeditionPosition.FINANCE_DIVISION)
* {
* model = new PurchasingDocumentExpedition
* {
* Id = id,
* FinanceDivisionBy = null,
* SendToFinanceDivisionDate = null,
* Position = ExpeditionPosition.SEND_TO_FINANCE_DIVISION,
* };
*
* EntityExtension.FlagForUpdate(model, identityService.Username, "Facade");
* dbContext.Attach(model);
* dbContext.Entry(model).Property(x => x.FinanceDivisionBy).IsModified = true;
* dbContext.Entry(model).Property(x => x.SendToFinanceDivisionDate).IsModified = true;
* dbContext.Entry(model).Property(x => x.Position).IsModified = true;
* dbContext.Entry(model).Property(x => x.LastModifiedAgent).IsModified = true;
* dbContext.Entry(model).Property(x => x.LastModifiedBy).IsModified = true;
* dbContext.Entry(model).Property(x => x.LastModifiedUtc).IsModified = true;
*
* Count = await dbContext.SaveChangesAsync();
* UpdateUnitPaymentOrderPosition(new List<string>() { purchasingDocumentExpedition.UnitPaymentOrderNo }, ExpeditionPosition.SEND_TO_FINANCE_DIVISION);
* }
*/
transaction.Commit();
}
catch (DbUpdateConcurrencyException e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
catch (Exception e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
}
return(Count);
}
public async Task <int> PurchasingDocumentAcceptance(PurchasingDocumentAcceptanceViewModel data, string username)
{
int Updated = 0;
using (var transaction = this.dbContext.Database.BeginTransaction())
{
try
{
List <string> unitPaymentOrders = new List <string>();
#region Verification
if (data.Role.Equals("VERIFICATION"))
{
foreach (PurchasingDocumentAcceptanceItem item in data.PurchasingDocumentExpedition)
{
unitPaymentOrders.Add(item.UnitPaymentOrderNo);
PurchasingDocumentExpedition model = new PurchasingDocumentExpedition
{
Id = item.Id,
VerificationDivisionBy = username,
VerificationDivisionDate = DateTimeOffset.UtcNow,
Position = ExpeditionPosition.VERIFICATION_DIVISION,
};
EntityExtension.FlagForUpdate(model, username, "Facade");
//dbContext.Attach(model);
dbContext.Entry(model).Property(x => x.VerificationDivisionBy).IsModified = true;
dbContext.Entry(model).Property(x => x.VerificationDivisionDate).IsModified = true;
dbContext.Entry(model).Property(x => x.Position).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedAgent).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedBy).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedUtc).IsModified = true;
}
Updated = await dbContext.SaveChangesAsync();
UpdateUnitPaymentOrderPosition(unitPaymentOrders, ExpeditionPosition.VERIFICATION_DIVISION, username);
}
#endregion Verification
#region Cashier
else if (data.Role.Equals("CASHIER"))
{
foreach (PurchasingDocumentAcceptanceItem item in data.PurchasingDocumentExpedition)
{
unitPaymentOrders.Add(item.UnitPaymentOrderNo);
PurchasingDocumentExpedition model = new PurchasingDocumentExpedition
{
Id = item.Id,
CashierDivisionBy = username,
CashierDivisionDate = DateTimeOffset.UtcNow,
Position = ExpeditionPosition.CASHIER_DIVISION,
};
EntityExtension.FlagForUpdate(model, username, "Facade");
//dbContext.Attach(model);
dbContext.Entry(model).Property(x => x.CashierDivisionBy).IsModified = true;
dbContext.Entry(model).Property(x => x.CashierDivisionDate).IsModified = true;
dbContext.Entry(model).Property(x => x.Position).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedAgent).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedBy).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedUtc).IsModified = true;
}
Updated = await dbContext.SaveChangesAsync();
UpdateUnitPaymentOrderPosition(unitPaymentOrders, ExpeditionPosition.CASHIER_DIVISION, username);
}
#endregion Cashier
#region Accounting
else if (data.Role.Equals("ACCOUNTING"))
{
foreach (PurchasingDocumentAcceptanceItem item in data.PurchasingDocumentExpedition)
{
unitPaymentOrders.Add(item.UnitPaymentOrderNo);
PurchasingDocumentExpedition model = new PurchasingDocumentExpedition
{
Id = item.Id,
AccountingDivisionBy = username,
AccountingDivisionDate = DateTimeOffset.UtcNow,
Position = ExpeditionPosition.FINANCE_DIVISION,
};
EntityExtension.FlagForUpdate(model, username, "Facade");
//dbContext.Attach(model);
dbContext.Entry(model).Property(x => x.AccountingDivisionBy).IsModified = true;
dbContext.Entry(model).Property(x => x.AccountingDivisionDate).IsModified = true;
dbContext.Entry(model).Property(x => x.Position).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedAgent).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedBy).IsModified = true;
dbContext.Entry(model).Property(x => x.LastModifiedUtc).IsModified = true;
}
Updated = await dbContext.SaveChangesAsync();
UpdateUnitPaymentOrderPosition(unitPaymentOrders, ExpeditionPosition.FINANCE_DIVISION, username);
}
#endregion Accounting
/*
#region Finance
* else if (data.Role.Equals("FINANCE"))
* {
* foreach (PurchasingDocumentAcceptanceItem item in data.PurchasingDocumentExpedition)
* {
* unitPaymentOrders.Add(item.UnitPaymentOrderNo);
*
* PurchasingDocumentExpedition model = new PurchasingDocumentExpedition
* {
* Id = item.Id,
* FinanceDivisionBy = username,
* FinanceDivisionDate = DateTimeOffset.UtcNow,
* Position = ExpeditionPosition.FINANCE_DIVISION,
* };
*
* EntityExtension.FlagForUpdate(model, username, "Facade");
* dbContext.Attach(model);
* dbContext.Entry(model).Property(x => x.FinanceDivisionBy).IsModified = true;
* dbContext.Entry(model).Property(x => x.FinanceDivisionDate).IsModified = true;
* dbContext.Entry(model).Property(x => x.Position).IsModified = true;
* dbContext.Entry(model).Property(x => x.LastModifiedAgent).IsModified = true;
* dbContext.Entry(model).Property(x => x.LastModifiedBy).IsModified = true;
* dbContext.Entry(model).Property(x => x.LastModifiedUtc).IsModified = true;
* }
*
* Updated = await dbContext.SaveChangesAsync();
* UpdateUnitPaymentOrderPosition(unitPaymentOrders, ExpeditionPosition.FINANCE_DIVISION);
* }
#endregion Finance
*/
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
}
return(Updated);
}
public async Task<PurchasingDocumentExpedition> GetTestData()
{
PurchasingDocumentExpedition model = GetNewData();
await Facade.SendToVerification(new List<PurchasingDocumentExpedition>() { model }, "Unit Test");
return model;
}
public async Task <BankExpenditureNoteDetailModel> GetNewDetailFinishingPrintingData()
{
PurchasingDocumentExpedition purchasingDocumentExpedition = await Task.Run(() => this.pdaDataUtil.GetCashierTestData());
List <BankExpenditureNoteItemModel> Items = new List <BankExpenditureNoteItemModel>();
foreach (var item in purchasingDocumentExpedition.Items)
{
BankExpenditureNoteItemModel Item = new BankExpenditureNoteItemModel
{
Price = item.Price,
ProductCode = item.ProductCode,
ProductId = item.ProductId,
ProductName = item.ProductName,
Quantity = item.Quantity,
UnitCode = "UnitCode1",
UnitId = item.UnitId,
UnitName = item.UnitName,
Uom = item.Uom,
URNNo = "URNNo1"
};
Items.Add(Item);
}
BankExpenditureNoteItemModel Item1 = new BankExpenditureNoteItemModel
{
Price = 1,
ProductCode = "ProductCode",
ProductId = "ProductID",
ProductName = "ProductName",
Quantity = 1,
UnitCode = "UnitCode2",
UnitId = "UnitId",
UnitName = "UnitName",
Uom = "Uom",
URNNo = "URNNo1"
};
Items.Add(Item1);
return(new BankExpenditureNoteDetailModel()
{
Id = 0,
UnitPaymentOrderId = purchasingDocumentExpedition.Id,
UnitPaymentOrderNo = purchasingDocumentExpedition.UnitPaymentOrderNo,
DivisionCode = purchasingDocumentExpedition.DivisionCode,
DivisionName = "FINISHING & PRINTING",
Currency = purchasingDocumentExpedition.Currency,
DueDate = purchasingDocumentExpedition.DueDate,
InvoiceNo = purchasingDocumentExpedition.InvoiceNo,
SupplierCode = purchasingDocumentExpedition.SupplierCode,
SupplierName = purchasingDocumentExpedition.SupplierName,
TotalPaid = purchasingDocumentExpedition.TotalPaid,
UPODate = purchasingDocumentExpedition.UPODate,
Vat = purchasingDocumentExpedition.Vat,
Items = Items,
AmountPaid = 1,
SupplierPayment = 20000
});
}
