public async Task <Models.FpRegradingResultDocs> CustomCodeGenerator(Models.FpRegradingResultDocs Model)
{
var unit = string.Equals(Model.UnitName.ToUpper(), "PRINTING") ? "PR" : "FS";
var lastData = await this.DbSet.Where(w => w.UnitName == Model.UnitName).OrderByDescending(o => o._CreatedUtc).FirstOrDefaultAsync();
DateTime Now = DateTime.Now;
string Year = Now.ToString("yy");
//string Month = Now.ToString("MM");
if (lastData == null)
{
Model.AutoIncrementNumber = 1;
string Number = Model.AutoIncrementNumber.ToString().PadLeft(4, '0');
Model.Code = $"KB{unit}{Year}{Number}";
}
else
{
if (lastData._CreatedUtc.Year < Now.Year)
{
Model.AutoIncrementNumber = 1;
string Number = Model.AutoIncrementNumber.ToString().PadLeft(4, '0');
Model.Code = $"KB{unit}{Year}{Number}";
}
else
{
Model.AutoIncrementNumber = lastData.AutoIncrementNumber + 1;
string Number = Model.AutoIncrementNumber.ToString().PadLeft(4, '0');
Model.Code = $"KB{unit}{Year}{Number}";
}
}
return(Model);
}
public async Task <int> CreateInventoryDocumentAsync(Models.FpRegradingResultDocs Model, string Type)
{
string storageURI = "master/storages";
string uomURI = "master/uoms";
IHttpService httpClient = (IHttpService)this.ServiceProvider.GetService(typeof(IHttpService));
/* Get UOM */
Dictionary <string, object> filterUOM = new Dictionary <string, object> {
{ "unit", "MTR" }
};
var responseUOM = httpClient.GetAsync($@"{APIEndpoint.Core}{uomURI}?filter=" + JsonConvert.SerializeObject(filterUOM)).Result.Content.ReadAsStringAsync();
Dictionary <string, object> resultUOM = JsonConvert.DeserializeObject <Dictionary <string, object> >(responseUOM.Result);
var jsonUOM = resultUOM.Single(p => p.Key.Equals("data")).Value;
Dictionary <string, object> uom = JsonConvert.DeserializeObject <List <Dictionary <string, object> > >(jsonUOM.ToString())[0];
/* Get Storage */
var storageName = Model.UnitName.Equals("PRINTING") ? "Gudang Greige Printing" : "Gudang Greige Finishing";
Dictionary <string, object> filterStorage = new Dictionary <string, object> {
{ "name", storageName }
};
var responseStorage = httpClient.GetAsync($@"{APIEndpoint.Core}{storageURI}?filter=" + JsonConvert.SerializeObject(filterStorage)).Result.Content.ReadAsStringAsync();
Dictionary <string, object> resultStorage = JsonConvert.DeserializeObject <Dictionary <string, object> >(responseStorage.Result);
var jsonStorage = resultStorage.Single(p => p.Key.Equals("data")).Value;
Dictionary <string, object> storage = JsonConvert.DeserializeObject <List <Dictionary <string, object> > >(jsonStorage.ToString())[0];
/* Create Inventory Document */
List <InventoryDocumentItem> inventoryDocumentItems = new List <InventoryDocumentItem>();
InventoryDocumentItem inventoryDocumentItem = new InventoryDocumentItem();
double TotalLength = 0;
foreach (FpRegradingResultDocsDetails o in Model.Details)
{
TotalLength += o.Length;
}
inventoryDocumentItem.ProductId = int.Parse(Model.ProductId);
inventoryDocumentItem.ProductCode = Model.ProductCode;
inventoryDocumentItem.ProductName = Model.ProductName;
inventoryDocumentItem.Quantity = TotalLength;
inventoryDocumentItem.UomId = int.Parse(uom["Id"].ToString());
inventoryDocumentItem.UomUnit = uom["Unit"].ToString();
inventoryDocumentItems.Add(inventoryDocumentItem);
InventoryDocument inventoryDocument = new InventoryDocument
{
Date = DateTimeOffset.UtcNow,
ReferenceNo = Model.Code,
ReferenceType = "Bon Hasil Re-grading",
Type = Type,
StorageId = int.Parse(storage["_id"].ToString()),
StorageCode = storage["code"].ToString(),
StorageName = storage["name"].ToString(),
Items = inventoryDocumentItems
};
var inventoryDocumentFacade = ServiceProvider.GetService <IInventoryDocumentService>();
return(await inventoryDocumentFacade.Create(inventoryDocument));
}
public async Task <int> CreateAsync(Models.FpRegradingResultDocs model)
{
int Created = 0;
using (var transaction = this.DbContext.Database.BeginTransaction())
{
try
{
model = await this.CustomCodeGenerator(model);
model.FlagForCreate(IdentityService.Username, UserAgent);
model.FlagForUpdate(IdentityService.Username, UserAgent);
foreach (var item in model.Details)
{
item.FlagForCreate(IdentityService.Username, UserAgent);
item.FlagForUpdate(IdentityService.Username, UserAgent);
}
DbSet.Add(model);
Created = await DbContext.SaveChangesAsync();
await CreateInventoryDocumentAsync(model, "IN");
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
throw new Exception(e.Message);
}
}
return(Created);
}
public Models.FpRegradingResultDocs MapToModel(FpRegradingResultDocsViewModel viewModel)
{
Models.FpRegradingResultDocs model = new Models.FpRegradingResultDocs();
PropertyCopier <FpRegradingResultDocsViewModel, Models.FpRegradingResultDocs> .Copy(viewModel, model);
model.NoBon = viewModel.Bon.no;
model.NoBonId = viewModel.Bon._id;
model.UnitName = viewModel.Bon.unitName;
model.SupplierId = viewModel.Supplier._id;
model.SupplierName = viewModel.Supplier.name;
model.SupplierCode = viewModel.Supplier.code;
model.ProductId = viewModel.Product.Id;
model.ProductCode = viewModel.Product.Code;
model.ProductName = viewModel.Product.Name;
model.Shift = viewModel.Shift;
model.MachineName = viewModel.Machine.name;
model.MachineId = viewModel.Machine._id;
model.MachineCode = viewModel.Machine.code;
model.Operator = viewModel.Operator;
model.Remark = viewModel.Remark;
model.Details = new List <FpRegradingResultDocsDetails>();
foreach (FpRegradingResultDetailsDocsViewModel data in viewModel.Details)
{
FpRegradingResultDocsDetails detail = new FpRegradingResultDocsDetails
{
//detail.SupplierId = viewModel.Supplier._id;
ProductId = viewModel.Product.Id,
ProductCode = viewModel.Product.Code,
ProductName = viewModel.Product.Name,
Quantity = data.Quantity,
Length = data.Length,
Remark = data.Remark,
Grade = data.Grade,
//detail.GradeBefore = data.GradeBefore;
Retur = data.Retur,
Id = data.Id
};
//detail.LengthBeforeReGrade = data.LengthBeforeReGrade;
model.Details.Add(detail);
}
return(model);
}
public async Task <int> DeleteAsync(int id)
{
int Count = 0;
using (var Transaction = this.DbContext.Database.BeginTransaction())
{
try
{
Models.FpRegradingResultDocs fpReturProInvDocs = await ReadByIdAsync(id);
fpReturProInvDocs.FlagForDelete(IdentityService.Username, UserAgent);
foreach (var item in fpReturProInvDocs.Details)
{
item.FlagForDelete(IdentityService.Username, UserAgent);
}
Count = await DbContext.SaveChangesAsync();
//FpRegradingResultDetailsDocsService fpReturProInvDocsDetailsService = ServiceProvider.GetService<FpRegradingResultDetailsDocsService>();
//fpReturProInvDocsDetailsService.Username = this.Username;
//HashSet<int> fpReturProInvDocsDetails = new HashSet<int>(this.DbContext.fpRegradingResultDocsDetails.Where(p => p.FpReturProInvDocsId.Equals(Id)).Select(p => p.Id));
//foreach (int detail in fpReturProInvDocsDetails)
//{
// await fpReturProInvDocsDetailsService.DeleteAsync(detail);
//}
await CreateInventoryDocumentAsync(fpReturProInvDocs, "OUT");
Transaction.Commit();
}
catch (Exception e)
{
Transaction.Rollback();
throw e;
}
}
return(Count);
}
public async Task <int> UpdateAsync(int id, Models.FpRegradingResultDocs model)
{
int updated = 0;
using (var transaction = DbContext.Database.BeginTransaction())
{
try
{
if (id != model.Id)
{
throw new Exception("data not found");
}
var dbModel = await ReadByIdAsync(id);
dbModel.Date = model.Date;
dbModel.IsReturn = model.IsReturn;
dbModel.IsReturnedToPurchasing = model.IsReturnedToPurchasing;
dbModel.MachineCode = model.MachineCode;
dbModel.MachineId = model.MachineId;
dbModel.MachineName = model.MachineName;
dbModel.NoBon = model.NoBon;
dbModel.NoBonId = model.NoBonId;
dbModel.Operator = model.Operator;
dbModel.OriginalGrade = model.OriginalGrade;
dbModel.ProductCode = model.ProductCode;
dbModel.ProductId = model.ProductId;
dbModel.ProductName = model.ProductName;
dbModel.Remark = model.Remark;
dbModel.Shift = model.Shift;
dbModel.SupplierCode = model.SupplierCode;
dbModel.SupplierName = model.SupplierName;
dbModel.SupplierId = model.SupplierId;
dbModel.TotalLength = model.TotalLength;
dbModel.UnitName = model.UnitName;
dbModel.FlagForUpdate(IdentityService.Username, UserAgent);
//DbSet.Update(dbModel);
var deletedItems = dbModel.Details.Where(x => !model.Details.Any(y => x.Id == y.Id));
var updatedItems = dbModel.Details.Where(x => model.Details.Any(y => x.Id == y.Id));
var addedItems = model.Details.Where(x => !dbModel.Details.Any(y => y.Id == x.Id));
foreach (var item in deletedItems)
{
item.FlagForDelete(IdentityService.Username, UserAgent);
}
foreach (var item in updatedItems)
{
var selectedItem = model.Details.FirstOrDefault(x => x.Id == item.Id);
item.Grade = selectedItem.Grade;
item.Length = selectedItem.Length;
item.ProductCode = selectedItem.ProductCode;
item.ProductId = selectedItem.ProductId;
item.ProductName = selectedItem.ProductName;
item.Quantity = selectedItem.Quantity;
item.Remark = selectedItem.Remark;
item.Retur = selectedItem.Retur;
item.FlagForUpdate(IdentityService.Username, UserAgent);
}
foreach (var item in addedItems)
{
item.FpReturProInvDocsId = id;
item.FlagForCreate(IdentityService.Username, UserAgent);
item.FlagForUpdate(IdentityService.Username, UserAgent);
}
updated = await DbContext.SaveChangesAsync();
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
throw ex;
}
}
return(updated);
}
public FpRegradingResultDocsViewModel MapToViewModel(Models.FpRegradingResultDocs model)
{
FpRegradingResultDocsViewModel viewModel = new FpRegradingResultDocsViewModel();
PropertyCopier <Models.FpRegradingResultDocs, FpRegradingResultDocsViewModel> .Copy(model, viewModel);
viewModel.Details = new List <FpRegradingResultDetailsDocsViewModel>();
viewModel.Bon = new FpRegradingResultDocsViewModel.noBon
{
_id = model.NoBonId,
no = model.NoBon,
unitName = model.UnitName
};
viewModel.Supplier = new FpRegradingResultDocsViewModel.supplier
{
name = model.SupplierName,
_id = model.SupplierId,
code = model.SupplierCode
};
viewModel._CreatedUtc = model._CreatedUtc;
viewModel.Product = new FpRegradingResultDocsViewModel.product
{
Name = model.ProductName,
Id = model.ProductId,
Code = model.SupplierCode
};
viewModel.Shift = model.Shift;
viewModel.Remark = model.Remark;
viewModel.Operator = model.Operator;
viewModel.Machine = new FpRegradingResultDocsViewModel.machine
{
name = model.MachineName,
code = model.MachineCode,
_id = model.MachineId
};
foreach (FpRegradingResultDocsDetails data in model.Details)
{
FpRegradingResultDetailsDocsViewModel detail = new FpRegradingResultDetailsDocsViewModel
{
Product = new FpRegradingResultDetailsDocsViewModel.product()
};
detail.Product.Id = data.ProductId;
detail.Product.Name = data.ProductName;
detail.Product.Length = data.Length;
//detail.Product.Quantity = data.Quantity;
//detail.Quantity = data.Quantity;
detail.Remark = data.Remark;
detail.Quantity = data.Quantity;
detail.Length = data.Length;
//detail.GradeBefore = data.GradeBefore;
detail.Grade = data.Grade;
detail.Retur = data.Retur;
detail.Id = data.Id;
//detail.LengthBeforeReGrade = data.LengthBeforeReGrade;
viewModel.Details.Add(detail);
}
return(viewModel);
}
