public async Task <IActionResult> Process([FromBody] SODocsViewModel ViewModel)
{
try
{
identityService.Username = User.Claims.Single(p => p.Type.Equals("username")).Value;
IValidateService validateService = (IValidateService)serviceProvider.GetService(typeof(IValidateService));
validateService.Validate(ViewModel);
var Model = mapper.Map <SODocs>(ViewModel);
await facade.Process(Model, 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 async Task <SODocsViewModel> MapToViewModel(List <SODocsCsvViewModel> csv, string source)
{
List <SODocsItemViewModel> soDocsItems = new List <SODocsItemViewModel>();
var storages = GetStorage(source);
foreach (var i in csv)
{
var item = dbContext.Inventories.Where(x => x.ItemCode == i.code && x.StorageId == storages.Id).FirstOrDefault();
if (item != null)
{
soDocsItems.Add(new SODocsItemViewModel
{
item = new ItemViewModel
{
articleRealizationOrder = item.ItemArticleRealizationOrder,
_id = item.ItemId,
code = i.code,
domesticCOGS = Convert.ToDouble(item.ItemDomesticCOGS),
domesticSale = Convert.ToDouble(item.ItemDomesticSale),
domesticWholesale = Convert.ToDouble(item.ItemDomesticWholeSale),
domesticRetail = Convert.ToDouble(item.ItemDomesticRetail),
name = i.name,
size = item.ItemSize,
uom = item.ItemUom
},
qtySO = Convert.ToDouble(i.quantity),
qtyBeforeSO = Convert.ToDouble(item.Quantity),
remark = ""
});
}
}
SODocsViewModel soDocs = new SODocsViewModel
{
code = GenerateCode("EFR-SO/INT"),
storage = new StorageViewModel
{
_id = storages.Id,
code = storages.Code,
name = storages.Name,
isCentral = storages.IsCentral
},
items = soDocsItems,
isProcessed = false
};
return(soDocs);
}
public IActionResult Get(int id)
{
try
{
var indexAcceptPdf = Request.Headers["Accept"].ToList().IndexOf("application/pdf");
SODocs model = facade.ReadById(id);
SODocsViewModel viewModel = mapper.Map <SODocsViewModel>(model);
if (viewModel == null)
{
throw new Exception("Invalid Id");
}
//////// //if (indexAcceptPdf < 0)
//////// //{
return(Ok(new
{
apiVersion = ApiVersion,
statusCode = General.OK_STATUS_CODE,
message = General.OK_MESSAGE,
data = viewModel,
}));
//////// // }
//////// //else
//////// //{
//////// // int clientTimeZoneOffset = int.Parse(Request.Headers["x-timezone-offset"].First());
//////// // PurchaseRequestPDFTemplate PdfTemplate = new PurchaseRequestPDFTemplate();
//////// // MemoryStream stream = PdfTemplate.GeneratePdfTemplate(viewModel, clientTimeZoneOffset);
//////// // return new FileStreamResult(stream, "application/pdf")
//////// // {
//////// // FileDownloadName = $"{viewModel.Code}.pdf"
//////// // };
//////// //}
}
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> PostCSVFileAsync(string source)
// public async Task<IActionResult> PostCSVFileAsync(double source, double destination, DateTime date)
{
try
{
identityService.Username = User.Claims.Single(p => p.Type.Equals("username")).Value;
identityService.Token = Request.Headers["Authorization"].FirstOrDefault().Replace("Bearer ", "");
identityService.TimezoneOffset = Convert.ToInt32(Request.Headers["x-timezone-offset"]);
if (Request.Form.Files.Count > 0)
{
//VerifyUser();
var UploadedFile = Request.Form.Files[0];
StreamReader Reader = new StreamReader(UploadedFile.OpenReadStream());
List <string> FileHeader = new List <string>(Reader.ReadLine().Split(","));
var ValidHeader = facade.CsvHeader.SequenceEqual(FileHeader, StringComparer.OrdinalIgnoreCase);
if (ValidHeader)
{
Reader.DiscardBufferedData();
Reader.BaseStream.Seek(0, SeekOrigin.Begin);
Reader.BaseStream.Position = 0;
CsvReader Csv = new CsvReader(Reader);
Csv.Configuration.IgnoreQuotes = false;
Csv.Configuration.Delimiter = ",";
Csv.Configuration.RegisterClassMap <Bateeq.Service.Warehouse.Lib.Facades.SOFacade.SOMap>();
Csv.Configuration.HeaderValidated = null;
List <SODocsCsvViewModel> Data = Csv.GetRecords <SODocsCsvViewModel>().ToList();
SODocsViewModel Data1 = await facade.MapToViewModel(Data, source);
Tuple <bool, List <object> > Validated = facade.UploadValidate(ref Data, Request.Form.ToList());
Reader.Close();
if (Validated.Item1) /* If Data Valid */
{
SODocs data = mapper.Map <SODocs>(Data1);
//foreach (var item in data)
//{
// Transfrom(item);
//}
await facade.UploadData(data, identityService.Username);
Dictionary <string, object> Result =
new ResultFormatter(ApiVersion, General.CREATED_STATUS_CODE, General.OK_MESSAGE)
.Ok();
return(Created(HttpContext.Request.Path, Result));
}
else
{
using (MemoryStream memoryStream = new MemoryStream())
{
using (StreamWriter streamWriter = new StreamWriter(memoryStream))
using (CsvWriter csvWriter = new CsvWriter(streamWriter))
{
csvWriter.WriteRecords(Validated.Item2);
}
return(File(memoryStream.ToArray(), ContentType, FileName));
}
}
}
else
{
Dictionary <string, object> Result =
new ResultFormatter(ApiVersion, General.INTERNAL_ERROR_STATUS_CODE, General.CSV_ERROR_MESSAGE)
.Fail();
return(NotFound(Result));
}
}
else
{
Dictionary <string, object> Result =
new ResultFormatter(ApiVersion, General.BAD_REQUEST_STATUS_CODE, General.NO_FILE_ERROR_MESSAGE)
.Fail();
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));
}
}
