public async Task <ActionResult> Post([FromBody] List <PurchasingDispositionExpeditionViewModel> viewModel)
{
try
{
VerifyUser();
ValidateService.Validate(viewModel);
foreach (var vm in viewModel)
{
ValidateService.Validate(viewModel);
PurchasingDispositionExpeditionModel model = Mapper.Map <PurchasingDispositionExpeditionModel>(vm);
await Service.CreateAsync(model);
}
Dictionary <string, object> Result =
new ResultFormatter(ApiVersion, General.CREATED_STATUS_CODE, General.OK_MESSAGE)
.Ok();
return(Created(String.Concat(Request.Path, "/", 0), Result));
}
catch (ServiceValidationException e)
{
Dictionary <string, object> Result =
new ResultFormatter(ApiVersion, General.BAD_REQUEST_STATUS_CODE, General.BAD_REQUEST_MESSAGE)
.Fail(e);
return(BadRequest(Result));
}
catch (Exception e)
{
Dictionary <string, object> Result =
new ResultFormatter(ApiVersion, General.INTERNAL_ERROR_STATUS_CODE, e.Message)
.Fail();
return(StatusCode(General.INTERNAL_ERROR_STATUS_CODE, Result));
}
}
public async Task <IActionResult> GetById([FromRoute] int id)
{
try
{
PurchasingDispositionExpeditionModel model = await Service.ReadByIdAsync(id);
if (model == null)
{
Dictionary <string, object> Result =
new ResultFormatter(ApiVersion, General.NOT_FOUND_STATUS_CODE, General.NOT_FOUND_MESSAGE)
.Fail();
return(NotFound(Result));
}
else
{
PurchasingDispositionExpeditionViewModel viewModel = Mapper.Map <PurchasingDispositionExpeditionViewModel>(model);
Dictionary <string, object> Result =
new ResultFormatter(ApiVersion, General.OK_STATUS_CODE, General.OK_MESSAGE)
.Ok <PurchasingDispositionExpeditionViewModel>(Mapper, viewModel);
return(Ok(Result));
}
}
catch (Exception e)
{
Dictionary <string, object> Result =
new ResultFormatter(ApiVersion, General.INTERNAL_ERROR_STATUS_CODE, e.Message)
.Fail();
return(StatusCode(General.INTERNAL_ERROR_STATUS_CODE, Result));
}
}
public async Task DeleteModel(int id)
{
PurchasingDispositionExpeditionModel model = await ReadByIdAsync(id);
foreach (var item in model.Items)
{
EntityExtension.FlagForDelete(item, IdentityService.Username, UserAgent, true);
}
List <string> dispoNo = new List <string>();
dispoNo.Add(model.DispositionNo);
var dispoCount = this.DbSet.Count(x => x.DispositionNo == model.DispositionNo && x.IsDeleted == false && x.Id != model.Id);
if (dispoCount > 0)
{
UpdateDispositionPosition(dispoNo, ExpeditionPosition.SEND_TO_PURCHASING_DIVISION);
}
else
{
UpdateDispositionPosition(dispoNo, ExpeditionPosition.PURCHASING_DIVISION);
}
EntityExtension.FlagForDelete(model, IdentityService.Username, UserAgent, true);
DbSet.Update(model);
}
public async Task <PurchasingDispositionExpeditionModel> GetTestData()
{
PurchasingDispositionExpeditionModel model = GetNewData();
await Service.CreateAsync(model);
return(await Service.ReadByIdAsync(model.Id));
}
public void Should_Success_Map_Purchasing_Disposition()
{
var mapper = new MapperConfiguration(configuration => configuration.AddProfile <PurchasingDispositionExpeditionProfile>()).CreateMapper();
var model = new PurchasingDispositionExpeditionModel();
var vm = mapper.Map <PurchasingDispositionExpeditionViewModel>(model);
Assert.True(true);
}
public async Task Should_Success_Create_Data()
{
PurchasingDispositionExpeditionService service = new PurchasingDispositionExpeditionService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
PurchasingDispositionExpeditionModel model = _dataUtil(service).GetNewData();
var Response = await service.CreateAsync(model);
Assert.NotEqual(0, Response);
}
public async Task <int> DeletePurchasingDispositionAcceptance(int id)
{
int count = 0;
if (DbContext.PurchasingDispositionExpeditions.Count(x => x.Id == id && !x.IsDeleted).Equals(0))
{
return(0);
}
using (var transaction = DbContext.Database.BeginTransaction())
{
try
{
PurchasingDispositionExpeditionModel purchasingDispositionExpedition = DbContext.PurchasingDispositionExpeditions.Single(x => x.Id == id);
if (purchasingDispositionExpedition.Position == ExpeditionPosition.VERIFICATION_DIVISION)
{
purchasingDispositionExpedition.VerificationDivisionBy = null;
purchasingDispositionExpedition.VerificationDivisionDate = null;
purchasingDispositionExpedition.Position = ExpeditionPosition.SEND_TO_VERIFICATION_DIVISION;
EntityExtension.FlagForUpdate(purchasingDispositionExpedition, IdentityService.Username, UserAgent);
count = await DbContext.SaveChangesAsync();
UpdateDispositionPosition(new List <string>()
{
purchasingDispositionExpedition.DispositionNo
}, ExpeditionPosition.SEND_TO_VERIFICATION_DIVISION);
}
else if (purchasingDispositionExpedition.Position == ExpeditionPosition.CASHIER_DIVISION)
{
purchasingDispositionExpedition.CashierDivisionBy = null;
purchasingDispositionExpedition.CashierDivisionDate = null;
purchasingDispositionExpedition.Position = ExpeditionPosition.SEND_TO_CASHIER_DIVISION;
EntityExtension.FlagForUpdate(purchasingDispositionExpedition, IdentityService.Username, UserAgent);
count = await DbContext.SaveChangesAsync();
UpdateDispositionPosition(new List <string>()
{
purchasingDispositionExpedition.DispositionNo
}, ExpeditionPosition.SEND_TO_CASHIER_DIVISION);
}
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
throw e;
}
}
return(count);
}
public async Task Update_Throws_NotImplementedException()
{
PurchasingDispositionExpeditionService service = new PurchasingDispositionExpeditionService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
PurchasingDispositionExpeditionModel model = await _dataUtil(service).GetTestData2();
var newModel = await service.ReadByIdAsync(model.Id);
await Assert.ThrowsAsync <NotImplementedException>(() => service.Update(newModel.Id, newModel, "", 7));
}
public async Task Should_Success_Get_Data_By_Id()
{
PurchasingDispositionExpeditionService service = new PurchasingDispositionExpeditionService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
PurchasingDispositionExpeditionModel model = await _dataUtil(service).GetTestData();
var Response = await service.ReadByIdAsync(model.Id);
Assert.NotNull(Response);
}
public async Task <int> PurchasingDispositionAcceptance(PurchasingDispositionAcceptanceViewModel data)
{
int updated = 0;
using (var transaction = DbContext.Database.BeginTransaction())
{
try
{
List <string> dispositions = new List <string>();
if (data.Role.Equals("VERIFICATION"))
{
foreach (var item in data.PurchasingDispositionExpedition)
{
dispositions.Add(item.DispositionNo);
PurchasingDispositionExpeditionModel model = DbContext.PurchasingDispositionExpeditions.Single(x => x.Id == item.Id);
model.VerificationDivisionBy = IdentityService.Username;
model.VerificationDivisionDate = DateTimeOffset.UtcNow;
model.Position = ExpeditionPosition.VERIFICATION_DIVISION;
EntityExtension.FlagForUpdate(model, IdentityService.Username, UserAgent);
}
updated = await DbContext.SaveChangesAsync();
UpdateDispositionPosition(dispositions, ExpeditionPosition.VERIFICATION_DIVISION);
}
else if (data.Role.Equals("CASHIER"))
{
foreach (var item in data.PurchasingDispositionExpedition)
{
dispositions.Add(item.DispositionNo);
PurchasingDispositionExpeditionModel model = DbContext.PurchasingDispositionExpeditions.Single(x => x.Id == item.Id);
model.CashierDivisionBy = IdentityService.Username;
model.CashierDivisionDate = DateTimeOffset.UtcNow;
model.Position = ExpeditionPosition.CASHIER_DIVISION;
EntityExtension.FlagForUpdate(model, IdentityService.Username, UserAgent);
}
updated = await DbContext.SaveChangesAsync();
UpdateDispositionPosition(dispositions, ExpeditionPosition.CASHIER_DIVISION);
}
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
throw e;
}
}
return(updated);
}
public async Task Should_Success_Delete_With_two_Datas()
{
PurchasingDispositionExpeditionService service = new PurchasingDispositionExpeditionService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
PurchasingDispositionExpeditionModel model = await _dataUtil(service).GetTestData2();
var newModel = await service.ReadByIdAsync(model.Id);
var Response = await service.DeleteAsync(newModel.Id);
Assert.NotEqual(0, Response);
}
public async Task Should_Fail_Post_Disposition_Verification()
{
PurchasingDispositionExpeditionService service = new PurchasingDispositionExpeditionService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
PurchasingDispositionExpeditionModel model = await _dataUtil(service).GetTestData();
PurchasingDispositionVerificationViewModel data = new PurchasingDispositionVerificationViewModel()
{
DispositionNo = model.DispositionNo,
Id = 0,
Reason = "Reason",
SubmitPosition = ExpeditionPosition.SEND_TO_PURCHASING_DIVISION,
VerifyDate = DateTimeOffset.UtcNow
};
await Assert.ThrowsAnyAsync <Exception>(() => service.PurchasingDispositionVerification(null));
}
public void CreateModel(PurchasingDispositionExpeditionModel m)
{
EntityExtension.FlagForCreate(m, IdentityService.Username, UserAgent);
m.Position = ExpeditionPosition.SEND_TO_VERIFICATION_DIVISION;
foreach (var item in m.Items)
{
EntityExtension.FlagForCreate(item, IdentityService.Username, UserAgent);
}
List <string> dispoNo = new List <string>();
dispoNo.Add(m.DispositionNo);
UpdateDispositionPosition(dispoNo, ExpeditionPosition.SEND_TO_VERIFICATION_DIVISION);
DbSet.Add(m);
}
public void UpdateModel(int id, PaymentDispositionNoteModel model)
{
PaymentDispositionNoteModel exist = DbSet
.Include(d => d.Items)
.ThenInclude(d => d.Details)
.Single(dispo => dispo.Id == id && !dispo.IsDeleted);
exist.BGCheckNumber = model.BGCheckNumber;
exist.PaymentDate = model.PaymentDate;
foreach (var item in exist.Items)
{
PaymentDispositionNoteItemModel itemModel = model.Items.FirstOrDefault(prop => prop.Id.Equals(item.Id));
if (itemModel == null)
{
PurchasingDispositionExpeditionModel expedition = DbContext.PurchasingDispositionExpeditions.FirstOrDefault(ex => ex.Id.Equals(item.PurchasingDispositionExpeditionId));
expedition.IsPaid = false;
expedition.BankExpenditureNoteNo = null;
expedition.BankExpenditureNoteDate = DateTimeOffset.MinValue;
EntityExtension.FlagForDelete(item, IdentityService.Username, UserAgent, true);
foreach (var detail in item.Details)
{
EntityExtension.FlagForDelete(detail, IdentityService.Username, UserAgent, true);
//DbContext.PaymentDispositionNoteDetails.Update(detail);
}
//DbContext.PaymentDispositionNoteItems.Update(item);
}
else
{
EntityExtension.FlagForUpdate(item, IdentityService.Username, UserAgent);
foreach (var detail in DbContext.PaymentDispositionNoteDetails.AsNoTracking().Where(p => p.PaymentDispositionNoteItemId == item.Id))
{
EntityExtension.FlagForUpdate(detail, IdentityService.Username, UserAgent);
}
}
}
EntityExtension.FlagForUpdate(exist, IdentityService.Username, UserAgent);
//DbSet.Update(exist);
}
public void CreateModel(PaymentDispositionNoteModel model)
{
EntityExtension.FlagForCreate(model, IdentityService.Username, UserAgent);
foreach (var item in model.Items)
{
PurchasingDispositionExpeditionModel expedition = DbContext.PurchasingDispositionExpeditions.FirstOrDefault(ex => ex.Id.Equals(item.PurchasingDispositionExpeditionId));
EntityExtension.FlagForCreate(item, IdentityService.Username, UserAgent);
expedition.IsPaid = true;
expedition.BankExpenditureNoteNo = model.PaymentDispositionNo;
expedition.BankExpenditureNoteDate = model.PaymentDate;
foreach (var detail in item.Details)
{
EntityExtension.FlagForCreate(detail, IdentityService.Username, UserAgent);
}
}
DbSet.Add(model);
}
public async Task Should_Success_Post_Disposition_Verification_Create_Purchasing()
{
PurchasingDispositionExpeditionService service = new PurchasingDispositionExpeditionService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
PurchasingDispositionExpeditionModel model = await _dataUtil(service).GetTestData();
PurchasingDispositionVerificationViewModel data = new PurchasingDispositionVerificationViewModel()
{
DispositionNo = model.DispositionNo,
Id = 0,
Reason = "Reason",
SubmitPosition = ExpeditionPosition.SEND_TO_PURCHASING_DIVISION,
VerifyDate = DateTimeOffset.UtcNow
};
var response = await service.PurchasingDispositionVerification(data);
Assert.NotEqual(0, response);
}
public async Task Should_Fail_Post_Acceptance_Verification()
{
PurchasingDispositionExpeditionService service = new PurchasingDispositionExpeditionService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
PurchasingDispositionExpeditionModel model = await _dataUtil(service).GetTestData();
PurchasingDispositionAcceptanceViewModel data = new PurchasingDispositionAcceptanceViewModel()
{
Role = "VERIFICATION",
PurchasingDispositionExpedition = new List <PurchasingDispositionAcceptanceItemViewModel>()
{
new PurchasingDispositionAcceptanceItemViewModel()
{
DispositionNo = model.DispositionNo,
Id = model.Id
}
}
};
await Assert.ThrowsAnyAsync <Exception>(() => service.PurchasingDispositionAcceptance(null));
}
public async Task DeleteModel(int id)
{
PaymentDispositionNoteModel model = await ReadByIdAsync(id);
foreach (var item in model.Items)
{
PurchasingDispositionExpeditionModel expedition = DbContext.PurchasingDispositionExpeditions.FirstOrDefault(ex => ex.Id.Equals(item.PurchasingDispositionExpeditionId));
EntityExtension.FlagForDelete(item, IdentityService.Username, UserAgent, true);
expedition.IsPaid = false;
expedition.BankExpenditureNoteNo = null;
expedition.BankExpenditureNoteDate = DateTimeOffset.MinValue;
foreach (var detail in item.Details)
{
EntityExtension.FlagForDelete(detail, IdentityService.Username, UserAgent, true);
}
}
EntityExtension.FlagForDelete(model, IdentityService.Username, UserAgent, true);
DbSet.Update(model);
}
public async Task Should_Success_Get_All_Data()
{
PurchasingDispositionExpeditionService service = new PurchasingDispositionExpeditionService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
PurchasingDispositionExpeditionModel model = await _dataUtil(service).GetTestData();
PurchasingDispositionVerificationViewModel data = new PurchasingDispositionVerificationViewModel()
{
DispositionNo = model.DispositionNo,
Id = 0,
Reason = "Reason",
SubmitPosition = ExpeditionPosition.SEND_TO_PURCHASING_DIVISION,
VerifyDate = DateTimeOffset.UtcNow
};
await service.PurchasingDispositionVerification(data);
DateTimeOffset tomorrow = DateTimeOffset.UtcNow.AddDays(1);
PaymentDispositionNotVerifiedReportService report = new PaymentDispositionNotVerifiedReportService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
var response = report.GetReport("", "", "", model.VerifyDate.GetValueOrDefault().AddDays(-30), tomorrow, 1, 25, "{}", 7, "notHistory");
Assert.NotNull(response.Item1);
}
public async Task Should_Success_GenerateExcel_WithDateIsNull()
{
PurchasingDispositionExpeditionService service = new PurchasingDispositionExpeditionService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
PurchasingDispositionExpeditionModel model = await _dataUtil(service).GetTestData();
PurchasingDispositionVerificationViewModel data = new PurchasingDispositionVerificationViewModel()
{
DispositionNo = model.DispositionNo,
Id = 0,
Reason = "Reason",
SubmitPosition = ExpeditionPosition.SEND_TO_PURCHASING_DIVISION,
VerifyDate = DateTimeOffset.UtcNow
};
await service.PurchasingDispositionVerification(data);
PaymentDispositionNotVerifiedReportService report = new PaymentDispositionNotVerifiedReportService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
var reportResponse = report.GenerateExcel("", "", "", null, null, 7, "history");
Assert.NotNull(reportResponse);
}
public async Task Should_Success_Post_Acceptance_Cashier()
{
PurchasingDispositionExpeditionService service = new PurchasingDispositionExpeditionService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
PurchasingDispositionExpeditionModel model = await _dataUtil(service).GetTestData();
PurchasingDispositionAcceptanceViewModel data = new PurchasingDispositionAcceptanceViewModel()
{
Role = "CASHIER",
PurchasingDispositionExpedition = new List <PurchasingDispositionAcceptanceItemViewModel>()
{
new PurchasingDispositionAcceptanceItemViewModel()
{
DispositionNo = model.DispositionNo,
Id = model.Id
}
}
};
var response = await service.PurchasingDispositionAcceptance(data);
Assert.NotEqual(0, response);
}
public async Task <int> CreateAsync(PurchasingDispositionExpeditionModel m)
{
CreateModel(m);
return(await DbContext.SaveChangesAsync());
}
public Task <int> Update(int id, PurchasingDispositionExpeditionModel m, string user, int clientTimeZoneOffset = 7)
{
throw new NotImplementedException();
}
public Task <int> UpdateAsync(int id, PurchasingDispositionExpeditionModel model)
{
throw new NotImplementedException();
}
