public void Should_Success_ValidateNullDetailVM()
{
var serviceProvider = GetServiceProvider();
InventorySummaryService inventorySummaryService = new InventorySummaryService(serviceProvider.Object, _dbContext(GetCurrentMethod()));
serviceProvider.Setup(s => s.GetService(typeof(IInventorySummaryService)))
.Returns(inventorySummaryService);
InventoryMovementService inventoryMovementService = new InventoryMovementService(serviceProvider.Object, _dbContext(GetCurrentMethod()));
serviceProvider.Setup(s => s.GetService(typeof(IInventoryMovementService)))
.Returns(inventoryMovementService);
InventoryDocumentService service = new InventoryDocumentService(serviceProvider.Object, _dbContext(GetCurrentMethod()));
var vm = new InventoryDocumentViewModel()
{
items = new List <InventoryDocumentItemViewModel>()
{
new InventoryDocumentItemViewModel()
}
};
ValidationContext validationContext = new ValidationContext(vm, serviceProvider.Object, null);
var response = vm.Validate(validationContext);
Assert.True(response.Count() > 0);
}
public async Task <IActionResult> Post([FromBody] InventoryDocumentViewModel viewModel)
{
try
{
VerifyUser();
ValidateService.Validate(viewModel);
InventoryDocument model = Service.MapToModel(viewModel);
await Service.Create(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 (ServiceValidationExeption 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 IActionResult Get(int id)
{
try
{
var indexAcceptPdf = Request.Headers["Accept"].ToList().IndexOf("application/pdf");
InventoryDocument model = _facade.ReadModelById(id);
//InventoryDocumentViewModel viewModel = _mapper.Map<InventoryDocumentViewModel>(model);
List <InventoryDocumentItemViewModel> items = new List <InventoryDocumentItemViewModel>();
foreach (var item in model.Items)
{
items.Add(new InventoryDocumentItemViewModel
{
productCode = item.ProductCode,
productId = item.ProductId,
productName = item.ProductName,
remark = item.ProductRemark,
quantity = item.Quantity,
stockPlanning = item.StockPlanning,
uomId = item.UomId,
uom = item.UomUnit,
});
}
InventoryDocumentViewModel viewModel = new InventoryDocumentViewModel
{
referenceNo = model.ReferenceNo,
referenceType = model.ReferenceType,
remark = model.Remark,
storageCode = model.StorageCode,
storageId = model.StorageId.ToString(),
storageName = model.StorageName,
date = model.Date,
type = model.Type,
items = items
};
if (viewModel == null)
{
throw new Exception("Invalid Id");
}
return(Ok(new
{
apiVersion = ApiVersion,
statusCode = General.OK_STATUS_CODE,
message = General.OK_MESSAGE,
data = viewModel,
}));
}
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 Should_Success_Create_Data()
{
InventoryDocumentViewModel viewModel = DataUtil.GetNewDataViewModel();
HttpContent httpContent = new StringContent(JsonConvert.SerializeObject(viewModel).ToString(), Encoding.UTF8, MediaType);
httpContent.Headers.Add("x-timezone-offset", "0");
var response = await this.Client.PostAsync(URI, httpContent);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
}
public void Should_Success_ValidateNullVM()
{
serviceProvider.Setup(s => s.GetService(typeof(IInventorySummaryRepository)))
.Returns(summaryRepository);
serviceProvider.Setup(s => s.GetService(typeof(IInventoryMovementRepository)))
.Returns(movementRepository);
var vm = new InventoryDocumentViewModel()
{
Items = new List <InventoryDocumentItemViewModel>()
};
ValidationContext validationContext = new ValidationContext(vm, serviceProvider.Object, null);
var response = vm.Validate(validationContext);
Assert.True(response.Count() > 0);
}
private async Task CreateInventory(PackingReceiptModel model)
{
var client = ServiceProvider.GetService <IHttpClientService>();
var uri = string.Format("{0}{1}", APIEndpoint.Inventory, "inventory-documents");
InventoryDocumentViewModel inventoryDoc = new InventoryDocumentViewModel();
inventoryDoc.referenceNo = "RFNO" + " - " + model.Code;
string referenceType = string.IsNullOrWhiteSpace(model.StorageName) ? model.StorageName : "";
inventoryDoc.referenceType = $"Penerimaan Packing {referenceType}";
inventoryDoc.remark = " ";
inventoryDoc.type = "IN";
inventoryDoc.date = DateTime.UtcNow;
inventoryDoc.storageId = (model.StorageId);
inventoryDoc.storageCode = (model.StorageCode);
inventoryDoc.storageName = model.StorageName;
inventoryDoc.items = new List <InventoryDocumentItemViewModel>();
foreach (var item in model.Items)
{
var data = new InventoryDocumentItemViewModel
{
productCode = item.ProductCode,
productName = item.Product,
productId = item.ProductId,
remark = item.Remark,
quantity = item.Quantity,
uomId = item.UomId,
stockPlanning = 0,
uom = item.Uom
};
inventoryDoc.items.Add(data);
}
var myContentJson = JsonConvert.SerializeObject(inventoryDoc, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
var myContent = new StringContent(myContentJson, Encoding.UTF8, "application/json");
var response = await client.PostAsync(uri, myContent);
response.EnsureSuccessStatusCode();
}
private async Task CreateInventoryDocumentOut(ShipmentDocumentModel model)
{
string referenceType = string.IsNullOrWhiteSpace(model.StorageName) ? model.StorageName : "";
var inventoryDoc = new InventoryDocumentViewModel()
{
date = model.DeliveryDate,
referenceType = $"Pengiriman Barang {referenceType}",
referenceNo = model.Code,
remark = "Pengiriman Barang",
type = "OUT",
storageId = model.StorageId,
storageCode = model.StorageCode,
storageName = model.StorageName,
items = new List <InventoryDocumentItemViewModel>()
};
foreach (var detail in model.Details)
{
foreach (var item in detail.Items)
{
foreach (var packingReceiptItem in item.PackingReceiptItems)
{
var data = new InventoryDocumentItemViewModel
{
productCode = packingReceiptItem.ProductCode,
productName = packingReceiptItem.ProductName,
productId = packingReceiptItem.ProductId,
remark = packingReceiptItem.Remark,
quantity = packingReceiptItem.Quantity,
uomId = packingReceiptItem.UOMId,
stockPlanning = 0,
uom = packingReceiptItem.UOMUnit
};
inventoryDoc.items.Add(data);
}
}
}
string uri = "inventory-documents";
var httpClient = (IHttpClientService)_ServiceProvider.GetService(typeof(IHttpClientService));
var response = await httpClient.PostAsync($"{APIEndpoint.Inventory}{uri}", new StringContent(JsonConvert.SerializeObject(inventoryDoc).ToString(), Encoding.UTF8, "application/json"));
response.EnsureSuccessStatusCode();
}
public void CreateInventoryDocument(StockTransferNote Model, string Type, string Context)
{
StockTransferNoteViewModel ViewModel = MapToViewModel(Model);
string inventoryDocumentURI = "inventory/inventory-documents";
HttpClient httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Token);
/* Create Inventory Document */
List <InventoryDocumentItemViewModel> inventoryDocumentItems = new List <InventoryDocumentItemViewModel>();
foreach (StockTransferNote_ItemViewModel stni in ViewModel.StockTransferNoteItems)
{
InventoryDocumentItemViewModel inventoryDocumentItem = new InventoryDocumentItemViewModel
{
productId = stni.Summary.productId,
productCode = stni.Summary.productCode,
productName = stni.Summary.productName,
quantity = stni.TransferedQuantity != null ? (double)stni.TransferedQuantity : 0,
uomId = stni.Summary.uomId,
uom = stni.Summary.uom
};
inventoryDocumentItems.Add(inventoryDocumentItem);
}
InventoryDocumentViewModel inventoryDocument = new InventoryDocumentViewModel
{
date = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ"),
referenceNo = Model.ReferenceNo,
referenceType = Model.ReferenceType,
type = Type,
storageId = string.Equals(Context.ToUpper(), "CREATE") || string.Equals(Context.ToUpper(), "DELETE-SOURCE") ? Model.SourceStorageId : Model.TargetStorageId,
storageCode = string.Equals(Context.ToUpper(), "CREATE") || string.Equals(Context.ToUpper(), "DELETE-SOURCE") ? Model.SourceStorageCode : Model.TargetStorageCode,
storageName = string.Equals(Context.ToUpper(), "CREATE") || string.Equals(Context.ToUpper(), "DELETE-SOURCE") ? Model.SourceStorageName : Model.TargetStorageName,
items = inventoryDocumentItems
};
var response = httpClient.PostAsync($"{APIEndpoint.Inventory}{inventoryDocumentURI}", new StringContent(JsonConvert.SerializeObject(inventoryDocument).ToString(), Encoding.UTF8, General.JsonMediaType)).Result;
response.EnsureSuccessStatusCode();
}
public async Task CreateInventory(PackingReceiptModel model)
{
using (var client = new HttpClient())
{
var uri = new Uri(string.Format("{0}{1}", APIEndpoint.Inventory, "inventory-documents"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", IdentityService.Token);
InventoryDocumentViewModel inventoryDoc = new InventoryDocumentViewModel();
inventoryDoc.referenceNo = "RFNO" + " - " + model.Code;
string referenceType = string.IsNullOrWhiteSpace(model.StorageName) ? model.StorageName : "";
inventoryDoc.referenceType = $"Penerimaan Packing {referenceType}";
inventoryDoc.remark = " ";
inventoryDoc.type = "IN";
inventoryDoc.date = DateTime.UtcNow;
inventoryDoc.storageId = (model.StorageId);
inventoryDoc.storageCode = (model.StorageCode);
inventoryDoc.storageName = model.StorageName;
inventoryDoc.items = new List <InventoryDocumentItemViewModel>();
foreach (var item in model.Items)
{
var data = new InventoryDocumentItemViewModel();
data.productCode = item.ProductCode;
data.productName = item.Product;
data.productId = item.ProductId;
data.remark = item.Remark;
data.quantity = item.Quantity;
data.uomId = item.UomId;
data.stockPlanning = 0;
data.uom = item.Uom;
inventoryDoc.items.Add(data);
}
var myContentJson = JsonConvert.SerializeObject(inventoryDoc, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
var myContent = new StringContent(myContentJson, Encoding.UTF8, "application/json");
var response = await client.PostAsync(uri, myContent);
response.EnsureSuccessStatusCode();
}
}
public InventoryDocumentViewModel MapToViewModel(InventoryDocument model)
{
InventoryDocumentViewModel viewModel = new InventoryDocumentViewModel
{
No = model.No,
ReferenceNo = model.ReferenceNo,
ReferenceType = model.ReferenceType,
Remark = model.Remark,
StorageCode = model.StorageCode,
StorageId = model.StorageId,
StorageName = model.StorageName,
Date = model.Date,
Type = model.Type,
Items = model.Items.Select(item => new InventoryDocumentItemViewModel()
{
Id = item.Id,
Active = item.Active,
CreatedAgent = item.CreatedAgent,
CreatedBy = item.CreatedBy,
CreatedUtc = item.CreatedUtc,
IsDeleted = item.IsDeleted,
LastModifiedAgent = item.LastModifiedAgent,
LastModifiedBy = item.LastModifiedBy,
LastModifiedUtc = item.LastModifiedUtc,
ProductCode = item.ProductCode,
ProductId = item.ProductId,
ProductName = item.ProductName,
Remark = item.ProductRemark,
Quantity = item.Quantity,
StockPlanning = item.StockPlanning,
UomId = item.UomId,
Uom = item.UomUnit,
}).ToList()
};
PropertyCopier <InventoryDocument, InventoryDocumentViewModel> .Copy(model, viewModel);
return(viewModel);
}
public InventoryDocumentViewModel MapToViewModel(InventoryDocument model)
{
InventoryDocumentViewModel viewModel = new InventoryDocumentViewModel
{
no = model.No,
referenceNo = model.ReferenceNo,
referenceType = model.ReferenceType,
remark = model.Remark,
storageCode = model.StorageCode,
storageId = model.StorageId,
storageName = model.StorageName,
date = model.Date,
type = model.Type,
items = model.Items.Select(item => new InventoryDocumentItemViewModel()
{
Id = item.Id,
Active = item.Active,
_CreatedAgent = item._CreatedAgent,
_CreatedBy = item._CreatedBy,
_CreatedUtc = item._CreatedUtc,
_IsDeleted = item._IsDeleted,
_LastModifiedAgent = item._LastModifiedAgent,
_LastModifiedBy = item._LastModifiedBy,
_LastModifiedUtc = item._LastModifiedUtc,
productCode = item.ProductCode,
productId = item.ProductId,
productName = item.ProductName,
remark = item.ProductRemark,
quantity = item.Quantity,
stockPlanning = item.StockPlanning,
uomId = item.UomId,
uom = item.UomUnit,
}).ToList()
};
PropertyCopier <InventoryDocument, InventoryDocumentViewModel> .Copy(model, viewModel);
return(viewModel);
}
public InventoryDocument MapToModel(InventoryDocumentViewModel viewModel)
{
InventoryDocument model = new InventoryDocument
{
ReferenceNo = viewModel.referenceNo,
ReferenceType = viewModel.referenceType,
Remark = viewModel.remark,
StorageCode = viewModel.storageCode,
StorageId = Convert.ToInt32(viewModel.storageId),
StorageName = viewModel.storageName,
Date = viewModel.date,
Type = viewModel.type,
Items = viewModel.items.Select(item => new InventoryDocumentItem()
{
Id = item.Id,
Active = item.Active,
_CreatedAgent = item._CreatedAgent,
_CreatedBy = item._CreatedBy,
_CreatedUtc = item._CreatedUtc,
_IsDeleted = item._IsDeleted,
_LastModifiedAgent = item._LastModifiedAgent,
_LastModifiedBy = item._LastModifiedBy,
_LastModifiedUtc = item._LastModifiedUtc,
ProductCode = item.productCode,
ProductId = item.productId,
ProductName = item.productName,
ProductRemark = item.remark,
Quantity = item.quantity,
StockPlanning = item.stockPlanning,
UomId = item.uomId,
UomUnit = item.uom,
}).ToList()
};
PropertyCopier <InventoryDocumentViewModel, InventoryDocument> .Copy(viewModel, model);
return(model);
}
public void Should_Success_Validate_When_Type_ADJ()
{
var serviceProvider = GetServiceProvider();
InventoryDbContext dbContext = _dbContext(GetCurrentMethod());
InventorySummaryService inventorySummaryService = new InventorySummaryService(serviceProvider.Object, dbContext);
serviceProvider
.Setup(s => s.GetService(typeof(IInventorySummaryService)))
.Returns(inventorySummaryService);
InventoryMovementService inventoryMovementService = new InventoryMovementService(serviceProvider.Object, dbContext);
serviceProvider
.Setup(s => s.GetService(typeof(IInventoryMovementService)))
.Returns(inventoryMovementService);
InventoryDocumentService service = new InventoryDocumentService(serviceProvider.Object, dbContext);
var vm = new InventoryDocumentViewModel()
{
no = "1",
code = "code",
items = new List <InventoryDocumentItemViewModel>()
{
new InventoryDocumentItemViewModel()
{
quantity = 0
}
}
,
type = "ADJ"
};
ValidationContext validationContext = new ValidationContext(vm, serviceProvider.Object, null);
var response = vm.Validate(validationContext);
Assert.True(response.Count() > 0);
}
public void CreateInventoryDocument(FPReturnInvToPurchasing model, string Type)
{
string inventoryDocumentURI = "inventory/inventory-documents";
string storageURI = "master/storages";
string uomURI = "master/uoms";
HttpClientService httpClient = (HttpClientService)this.serviceProvider.GetService(typeof(HttpClientService));
#region 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];
#endregion UOM
#region 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];
#endregion Storage
#region Inventory Document
List <InventoryDocumentItemViewModel> inventoryDocumentItems = new List <InventoryDocumentItemViewModel>();
foreach (FPReturnInvToPurchasingDetail detail in model.FPReturnInvToPurchasingDetails)
{
InventoryDocumentItemViewModel inventoryDocumentItem = new InventoryDocumentItemViewModel();
inventoryDocumentItem.productId = detail.ProductId;
inventoryDocumentItem.productCode = detail.ProductCode;
inventoryDocumentItem.productName = detail.ProductName;
inventoryDocumentItem.quantity = detail.Length;
inventoryDocumentItem.uomId = uom["_id"].ToString();
inventoryDocumentItem.uom = uom["unit"].ToString();
inventoryDocumentItems.Add(inventoryDocumentItem);
}
InventoryDocumentViewModel inventoryDocument = new InventoryDocumentViewModel
{
date = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ"),
referenceNo = model.No,
referenceType = "Bon Retur Barang - Pembelian",
type = Type,
storageId = storage["_id"].ToString(),
storageCode = storage["code"].ToString(),
storageName = storage["name"].ToString(),
items = inventoryDocumentItems
};
var response = httpClient.PostAsync($"{APIEndpoint.Inventory}{inventoryDocumentURI}", new StringContent(JsonConvert.SerializeObject(inventoryDocument).ToString(), Encoding.UTF8, General.JsonMediaType)).Result;
response.EnsureSuccessStatusCode();
#endregion Inventory Document
}
public void CreateInventoryDocument(MaterialsRequestNote Model, string Type)
{
string inventoryDocumentURI = "inventory/inventory-documents";
string storageURI = "master/storages";
string uomURI = "master/uoms";
HttpClient httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Token);
/* 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 <InventoryDocumentItemViewModel> inventoryDocumentItems = new List <InventoryDocumentItemViewModel>();
List <MaterialsRequestNote_Item> list = Model.MaterialsRequestNote_Items
.GroupBy(m => new { m.ProductId, m.ProductCode, m.ProductName })
.Select(s => new MaterialsRequestNote_Item
{
ProductId = s.First().ProductId,
ProductCode = s.First().ProductCode,
ProductName = s.First().ProductName,
Length = s.Sum(d => d.Length)
}).ToList();
foreach (MaterialsRequestNote_Item item in list)
{
InventoryDocumentItemViewModel inventoryDocumentItem = new InventoryDocumentItemViewModel();
inventoryDocumentItem.productId = item.ProductId;
inventoryDocumentItem.productCode = item.ProductCode;
inventoryDocumentItem.productName = item.ProductName;
inventoryDocumentItem.quantity = item.Length;
inventoryDocumentItem.uomId = uom["_id"].ToString();
inventoryDocumentItem.uom = uom["unit"].ToString();
inventoryDocumentItems.Add(inventoryDocumentItem);
}
InventoryDocumentViewModel inventoryDocument = new InventoryDocumentViewModel
{
date = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ"),
referenceNo = Model.Code,
referenceType = "Surat Permintaan Barang",
type = Type,
storageId = storage["_id"].ToString(),
storageCode = storage["code"].ToString(),
storageName = storage["name"].ToString(),
items = inventoryDocumentItems
};
var response = httpClient.PostAsync($"{APIEndpoint.Inventory}{inventoryDocumentURI}", new StringContent(JsonConvert.SerializeObject(inventoryDocument).ToString(), Encoding.UTF8, General.JsonMediaType)).Result;
response.EnsureSuccessStatusCode();
}
public async Task CreateInventoryDocument(ReturToQCModel model)
{
using (var client = new HttpClient()
{
Timeout = Timeout.InfiniteTimeSpan
})
{
string relativePath = "inventory-documents/multi";
try
{
Uri serverUri = new Uri(APIEndpoint.Inventory);
Uri relativePathUri = new Uri(relativePath, UriKind.Relative);
var uri = new Uri(serverUri, relativePathUri);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", IdentityService.Token);
var listContainer = new List <StringContent>();
if (model.ReturToQCItems != null && model.ReturToQCItems.Count != 0)
{
List <InventoryDocumentViewModel> postedModels = new List <InventoryDocumentViewModel>();
foreach (var item in model.ReturToQCItems)
{
InventoryDocumentViewModel inventoryDoc = new InventoryDocumentViewModel
{
referenceNo = model.ReturNo + " - " + item.ProductionOrderNo,
referenceType = "retur-to-qc",
remark = "",
type = model.IsVoid ? "IN" : "OUT",
date = DateTimeOffset.UtcNow
};
var itemDetails = item.ReturToQCItemDetails.LastOrDefault();
if (itemDetails != null)
{
inventoryDoc.storageId = itemDetails.StorageId;
inventoryDoc.storageCode = itemDetails.StorageCode;
inventoryDoc.storageName = itemDetails.StorageName;
}
inventoryDoc.items = item.ReturToQCItemDetails.Select(x => new InventoryDocumentItemViewModel()
{
productCode = x.ProductCode,
productName = x.ProductName,
productId = x.ProductId,
remark = x.Remark,
quantity = x.ReturQuantity,
uomId = x.UOMId,
uom = x.UOMUnit,
}).ToList();
postedModels.Add(inventoryDoc);
}
var myContentJson = JsonConvert.SerializeObject(postedModels, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
var myContent = new StringContent(myContentJson, Encoding.UTF8, "application/json");
var response = await client.PostAsync(uri, myContent);
response.EnsureSuccessStatusCode();
}
}
catch (UriFormatException)
{
throw new UriFormatException(string.Format("Error : {0}, {1}", APIEndpoint.Inventory, relativePath));
}
catch (Exception)
{
throw new Exception(string.Format("Error : {0}, {1}", APIEndpoint.Inventory, relativePath));
}
}
}
public void CreateInventoryDocument(MaterialDistributionNote Model, string Type)
{
string inventoryDocumentURI = "inventory/inventory-documents";
string storageURI = "master/storages";
string uomURI = "master/uoms";
HttpClient httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Token);
/* 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 <InventoryDocumentItemViewModel> inventoryDocumentItems = new List <InventoryDocumentItemViewModel>();
List <MaterialDistributionNoteDetail> mdnds = new List <MaterialDistributionNoteDetail>();
foreach (MaterialDistributionNoteItem mdni in Model.MaterialDistributionNoteItems)
{
mdnds.AddRange(mdni.MaterialDistributionNoteDetails);
}
//List<MaterialDistributionNoteDetail> list = mdnds
// .GroupBy(m => new { m.ProductId, m.ProductCode, m.ProductName })
// .Select(s => new MaterialDistributionNoteDetail
// {
// ProductId = s.First().ProductId,
// ProductCode = s.First().ProductCode,
// ProductName = s.First().ProductName,
// ReceivedLength = s.Sum(d => d.ReceivedLength),
// MaterialRequestNoteItemLength = s.Sum(d => d.MaterialRequestNoteItemLength)
// }).ToList();
foreach (MaterialDistributionNoteDetail mdnd in mdnds)
{
InventoryDocumentItemViewModel inventoryDocumentItem = new InventoryDocumentItemViewModel
{
productId = mdnd.ProductId,
productCode = mdnd.ProductCode,
productName = mdnd.ProductName,
quantity = mdnd.ReceivedLength,
stockPlanning = Model.Type != "RE-GRADING" ? (mdnd.DistributedLength == 0 ? mdnd.MaterialRequestNoteItemLength - mdnd.ReceivedLength : mdnd.ReceivedLength * -1) : mdnd.ReceivedLength * -1,
uomId = uom["_id"].ToString(),
uom = uom["unit"].ToString()
};
inventoryDocumentItems.Add(inventoryDocumentItem);
}
List <InventoryDocumentItemViewModel> list = inventoryDocumentItems
.GroupBy(m => new { m.productId, m.productCode, m.productName })
.Select(s => new InventoryDocumentItemViewModel
{
productId = s.First().productId,
productCode = s.First().productCode,
productName = s.First().productName,
quantity = s.Sum(d => d.quantity),
stockPlanning = s.Sum(d => d.stockPlanning),
uom = s.First().uom,
uomId = s.First().uomId
}).ToList();
InventoryDocumentViewModel inventoryDocument = new InventoryDocumentViewModel
{
date = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ"),
referenceNo = Model.No,
referenceType = "Bon Pengantar Greige",
type = Type,
storageId = storage["_id"].ToString(),
storageCode = storage["code"].ToString(),
storageName = storage["name"].ToString(),
items = list
};
var response = httpClient.PostAsync($"{APIEndpoint.Inventory}{inventoryDocumentURI}", new StringContent(JsonConvert.SerializeObject(inventoryDocument).ToString(), Encoding.UTF8, General.JsonMediaType)).Result;
response.EnsureSuccessStatusCode();
}
public void CreateInventoryDocument(Models.FpRegradingResultDocs Model, string Type)
{
string inventoryDocumentURI = "inventory/inventory-documents";
string storageURI = "master/storages";
string uomURI = "master/uoms";
HttpClient httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Token);
/* 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 <InventoryDocumentItemViewModel> inventoryDocumentItems = new List <InventoryDocumentItemViewModel>();
InventoryDocumentItemViewModel inventoryDocumentItem = new InventoryDocumentItemViewModel();
double TotalLength = 0;
foreach (FpRegradingResultDocsDetails o in Model.Details)
{
TotalLength += o.Length;
//inventoryDocumentItem = new InventoryDocumentItemViewModel
//{
//productId = o.ProductId,
//productCode = o.ProductCode,
//productName = o.ProductName,
//quantity = o.Length,
//uomId = uom["_id"].ToString(),
//uom = uom["unit"].ToString()
//};
//inventoryDocumentItems.Add(inventoryDocumentItem);
}
inventoryDocumentItem.productId = Model.ProductId;
inventoryDocumentItem.productCode = Model.ProductCode;
inventoryDocumentItem.productName = Model.ProductName;
inventoryDocumentItem.quantity = TotalLength;
inventoryDocumentItem.uomId = uom["_id"].ToString();
inventoryDocumentItem.uom = uom["unit"].ToString();
inventoryDocumentItems.Add(inventoryDocumentItem);
InventoryDocumentViewModel inventoryDocument = new InventoryDocumentViewModel
{
date = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ"),
referenceNo = Model.Code,
referenceType = "Bon Hasil Re-grading",
type = Type,
storageId = storage["_id"].ToString(),
storageCode = storage["code"].ToString(),
storageName = storage["name"].ToString(),
items = inventoryDocumentItems
};
var response = httpClient.PostAsync($"{APIEndpoint.Inventory}{inventoryDocumentURI}", new StringContent(JsonConvert.SerializeObject(inventoryDocument).ToString(), Encoding.UTF8, General.JsonMediaType)).Result;
response.EnsureSuccessStatusCode();
}
public async Task <IActionResult> Post([FromBody] InventoryDocumentViewModel vm)
{
identityService.Token = Request.Headers["Authorization"].First().Replace("Bearer ", "");
identityService.Username = User.Claims.Single(p => p.Type.Equals("username")).Value;
//InventoryDocument m = _mapper.Map<InventoryDocument>(vm);
List <InventoryDocumentItem> items = new List <InventoryDocumentItem>();
foreach (var item in vm.items)
{
items.Add(new InventoryDocumentItem
{
ProductCode = item.productCode,
ProductId = item.productId,
ProductName = item.productName,
ProductRemark = item.remark,
Quantity = item.quantity,
StockPlanning = item.stockPlanning,
UomId = item.uomId,
UomUnit = item.uom,
});
}
InventoryDocument m = new InventoryDocument
{
ReferenceNo = vm.referenceNo,
ReferenceType = vm.referenceType,
Remark = vm.remark,
StorageCode = vm.storageCode,
StorageId = Convert.ToInt32(vm.storageId),
StorageName = vm.storageName,
Date = vm.date,
Type = vm.type,
Items = items
};
ValidateService validateService = (ValidateService)_facade.serviceProvider.GetService(typeof(ValidateService));
try
{
validateService.Validate(vm);
//int clientTimeZoneOffset = int.Parse(Request.Headers["x-timezone-offset"].First());
int result = await _facade.Create(m, identityService.Username);
Dictionary <string, object> Result =
new ResultFormatter(ApiVersion, General.CREATED_STATUS_CODE, General.OK_MESSAGE)
.Ok();
return(Created(String.Concat(Request.Path, "/", 0), Result));
}
catch (ServiceValidationExeption 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 IActionResult Get(int page = 1, int size = 25, string order = "{}", string keyword = null, string filter = "{}")
{
identityService.Username = User.Claims.Single(p => p.Type.Equals("username")).Value;
try
{
var Data = _facade.Read(page, size, order, keyword, filter);
List <InventoryDocumentViewModel> newData = new List <InventoryDocumentViewModel>();
foreach (var model in Data.Item1)
{
List <InventoryDocumentItemViewModel> items = new List <InventoryDocumentItemViewModel>();
foreach (var item in model.Items)
{
items.Add(new InventoryDocumentItemViewModel
{
productCode = item.ProductCode,
productId = item.ProductId,
productName = item.ProductName,
remark = item.ProductRemark,
quantity = item.Quantity,
stockPlanning = item.StockPlanning,
uomId = item.UomId,
uom = item.UomUnit,
});
}
InventoryDocumentViewModel viewModel = new InventoryDocumentViewModel
{
referenceNo = model.ReferenceNo,
referenceType = model.ReferenceType,
remark = model.Remark,
storageCode = model.StorageCode,
storageId = model.StorageId.ToString(),
storageName = model.StorageName,
date = model.Date,
type = model.Type,
items = items
};
newData.Add(viewModel);
}
List <object> listData = new List <object>();
listData.AddRange(
newData.AsQueryable().Select(s => new
{
s.code,
s.date,
s.items,
s.storageCode,
s.storageId,
s.storageName,
s.referenceNo,
s.referenceType
}).ToList()
);
return(Ok(new
{
apiVersion = ApiVersion,
statusCode = General.OK_STATUS_CODE,
message = General.OK_MESSAGE,
data = listData,
info = new Dictionary <string, object>
{
{ "count", listData.Count },
{ "total", Data.Item2 },
{ "order", Data.Item3 },
{ "page", page },
{ "size", size }
},
}));
}
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));
}
}
