public async Task ChangeUserPhoto_Fail_WorngFile()
{
//Arrange------------------------------------------------------------------------------------------------------------------------------
string userHimselfId = UnitTestsDataInput.userLogedInId;
IFormFile file = new FormFile(new MemoryStream(Encoding.UTF8.GetBytes("dummy image")),
0, 0, "Data", "0d47394e-672f-4db7-898c-bfd8f32e2af7.png");
byte[] data;
using (var br = new BinaryReader(file.OpenReadStream()))
data = br.ReadBytes((int)file.OpenReadStream().Length);
ByteArrayContent bytes = new ByteArrayContent(data);
MultipartFormDataContent multiContent = new MultipartFormDataContent();
multiContent.Add(bytes, "File", file.FileName);
var request = new
{
Url = UnitTestsDataInput.baseRouteV1 + "site/panel/users/" + userHimselfId + "/photos",
Body = UnitTestsDataInput.photoForProfileDto
};
multiContent.Add(ContentHelper.GetStringContent(request.Body));
_client.DefaultRequestHeaders.Authorization
= new AuthenticationHeaderValue("Bearer", UnitTestsDataInput.aToken);
//Act----------------------------------------------------------------------------------------------------------------------------------
var response = await _client.PostAsync(request.Url, multiContent);
//Assert-------------------------------------------------------------------------------------------------------------------------------
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
public static bool UploadFileToServer(string filePath)
{
IFormFile formFile;
using (var fs = new FileStream(filePath, FileMode.Open))
{
formFile = new FormFile(fs, fs.Position, new FileInfo(filePath).Length, "ProcessingDocument", filePath);
using (var client = new HttpClient())
{
var fileName = formFile.FileName;
using (var content = new MultipartFormDataContent())
{
content.Add(new StreamContent(formFile.OpenReadStream())
{
Headers =
{
ContentLength = formFile.Length,
ContentType = new MediaTypeHeaderValue("multipart/form-data")
}
}, "File", fileName);
var response = client.PostAsync("https://localhost:44345/api/uploadfile", content).Result;
return(response.IsSuccessStatusCode);
}
}
}
}
/// <summary>
/// Upload an image to blob storage
/// OR
/// Replace it if a file with the provided guid already exists
/// </summary>
/// <param name="container">The container to upload the blob to.
/// Container is an enum.</param>
/// <param name="formFile">The FormFile object which contains the byte data and meta-data
/// for the file being uploaded.</param>
/// <param name="blobName">The guid which will become the blob filename in azure storage.
/// </param>
/// <returns>A Image object which contains the guid filename given to the blob in blob storage.
/// This object also contains the URL that you can use to access the blob file from online.</returns>
public async Task <Image> UploadOrReplaceImage(ContainerName container, FormFile formFile, Guid blobName)
{
CloudBlockBlob blockBlob;
if (container == ContainerName.Gallery)
{ // check which container to upload the blob to
blockBlob = _GalleryContainer.GetBlockBlobReference(blobName.ToString());
}
else if (container == ContainerName.Log)
{
blockBlob = _LogContainer.GetBlockBlobReference(blobName.ToString());
}
else
{
throw new ArgumentException("Invalid enum ContainerName value", container.ToString());
}
blockBlob.Properties.ContentType = formFile.ContentType; // set the new blob's mime type
// Create or overwrite the blob with the contents of formFile stream
await blockBlob.UploadFromStreamAsync(formFile.OpenReadStream());
Image image = new Image
{
Url = blockBlob.StorageUri.PrimaryUri.ToString(),
Guid = blobName,
Filename = formFile.FileName,
ContainerName = container
};
return(image);
}
/// <summary>
/// UploadFile
/// </summary>
/// <param name="File">HttpPostedFileBase</param>
/// <param name="extension"> ".jpeg" or ".pdf" </param>
/// <returns></returns>
public async Task <string> UploadFile(FormFile File, string extension, string endpoint, string token = "")
{
try {
byte[] data;
var notification = new Notification();
using (Stream inputStream = File.OpenReadStream()) {
if (!(inputStream is MemoryStream memoryStream))
{
memoryStream = new MemoryStream();
inputStream.CopyTo(memoryStream);
}
data = memoryStream.ToArray();
}
var fileUploadCommand = new FileUpload {
Bytes = data,
Extension = extension
};
var content = new MultipartFormDataContent();
var fileContent = new ByteArrayContent(fileUploadCommand.Bytes);
fileContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = Guid.NewGuid().ToString() + fileUploadCommand.Extension
};
content.Add(fileContent);
using (var client = new HttpClient()) {
client.BaseAddress = new Uri(baseUri);
client.Timeout = TimeSpan.FromMinutes(30);
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token);
var response = await client.PostAsync(endpoint, content);
if (response.IsSuccessStatusCode)
{
notification.Value = await response.Content.ReadAsStringAsync();
var message = JsonConvert.DeserializeObject <Notification>(notification.Value);
return(message.Value);
}
else
{
var result = await response.Content.ReadAsStringAsync();
throw new Exception(result);
}
}
} catch (Exception ex) {
throw ex;
}
}
public async Task <IActionResult> Create(List <IFormFile> file, [Bind("image_id,image_name,room_image")] Image image)
{
long size = file.Sum(f => f.Length);
var filepath = Path.GetTempFileName();
System.Diagnostics.Debug.WriteLine("im here");
foreach (var FormFile in file)
{
System.Diagnostics.Debug.WriteLine("im in");
// Check file format
if (FormFile.ContentType.ToLower() != "image/jpeg" && FormFile.ContentType.ToLower() != "image/png")
{
return(BadRequest("The " + Path.GetFullPath(filepath) + " is not an image file. Please ensure a correct file format is being uploaded."));
}
//Check file size whether it is empty or not
else if (FormFile.Length <= 0)
{
return(BadRequest("The " + Path.GetFileName(filepath) + " is empty. Please ensure a correct file is being uploaded."));
}
// Limit the file size to 1MB
else if (FormFile.Length > 1048576)
{
return(BadRequest("The " + Path.GetFileName(filepath) + " is more than 1 MB. Please ensure the file is less than 1 MB."));
}
else
{
CloudBlobContainer container = GetCloudBlobContainer();
CloudBlockBlob blob = container.GetBlockBlobReference(image.image_name + "-image.jpg");
try
{
using (var fileStream = FormFile.OpenReadStream())
{
blob.UploadFromStreamAsync(fileStream).Wait();
}
//Get URL from blob storage
image.room_image = blob.Uri.OriginalString;
if (ModelState.IsValid)
{
_context.Add(image);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(image));
}
catch (Exception e)
{
return(BadRequest("Failed to create" + e));
}
}
}
return(View(image));
}
public async Task <IActionResult> Create([Bind("ID,Category,Name,Brand,PurchaseDate,Price,WornTimes,ImageUrl,FileName,UserId")] Wardrobe wardrobe, List <IFormFile> files)
{
ViewBag.userid = _userManager.GetUserId(HttpContext.User);
if (ModelState.IsValid)
{
//get temporary filepath
var filepath = Path.GetTempFileName();
foreach (var FormFile in files)
{
//chack the file
if (FormFile.Length <= 0)
{
TempData["message"] = "Please upload an image file";
}
//If file is valid proceed to transfer data
{
//Get the information of the container
CloudBlobContainer container = GetCloudBlobContainer();
//create the container if not exist in the storage
ViewBag.Success = container.CreateIfNotExistsAsync().Result;
ViewBag.BlobContainerName = container.Name; //get the container name
//Give a name for the blob
CloudBlockBlob blob = container.GetBlockBlobReference(Path.GetFileName(FormFile.FileName));
try
{
using (var stream = FormFile.OpenReadStream())
{
await blob.UploadFromStreamAsync(stream);
}
}
catch (Exception ex)
{
TempData["message"] = ex.ToString();
}
//get uri of the uploaded blob and save in database
var blobUrl = blob.Uri.AbsoluteUri;
wardrobe.ImageUrl = blobUrl.ToString();
wardrobe.FileName = FormFile.FileName.ToString();
_context.Add(wardrobe);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
TempData["createmessage"] = "Please upload an image for your clothes";
return(RedirectToAction(nameof(Create)));
}
return(View(wardrobe));
}
public async Task <IActionResult> Post(List <IFormFile> files)
{
long sizes = files.Sum(f => f.Length);
var filepath = Path.GetTempFileName();
int i = 1; string contents = "";
foreach (var FormFile in files)
{
//step 1: before pass the file, check the file content type
if (FormFile.ContentType.ToLower() != "text/plain")
{
return(BadRequest("The " + Path.GetFileName(filepath) +
"is not a text file! Please upload a correct text file"));
}
//step 2: chech whether the file is empty anot
else if (FormFile.Length <= 0)
{
return(BadRequest("The " + Path.GetFileName(filepath) +
"is empty!"));
}
//step 3: check file size got over limit anot
else if (FormFile.Length > 1048576) //more than 1MB
{
return(BadRequest("The " + Path.GetFileName(filepath) +
"is too big!"));
}
//step 4: start to transfer the file to the correct destination
else
{
//e.g file path
var filedest = "file path" + i + ".txt";
using (var stream = new FileStream(filedest, FileMode.Create))
{
await FormFile.CopyToAsync(stream);
}
//read file
using (var reader = new StreamReader(FormFile.OpenReadStream()))
{
contents = contents + "\\n" + await reader.ReadToEndAsync();
}
}
}
TempData["message"] = "Success Transfer" + contents;
return(RedirectToAction("Index"));
}
public async Task <IActionResult> ImportEntities([FromBody] ODataActionParameters request)
{
if (!this.ModelState.IsValid || request == null)
{
return((IActionResult) new BadRequestObjectResult(this.ModelState));
}
if (!request.ContainsKey("importFile") || request["importFile"] == null)
{
return((IActionResult) new BadRequestObjectResult((object)request));
}
IFormFile formFile = (IFormFile)request["importFile"];
MemoryStream memoryStream = new MemoryStream();
formFile.CopyTo((Stream)memoryStream);
FormFile file = new FormFile((Stream)memoryStream, 0L, formFile.Length, formFile.Name, formFile.FileName);
try
{
InitializeEnvironment();
var sb = new StringBuilder();
using (var reader = new StreamReader(file.OpenReadStream()))
{
while (reader.Peek() >= 0)
{
sb.AppendLine(reader.ReadLine());
}
}
var jsonString = sb.ToString();
var entities = JsonConvert.DeserializeObject <EntityCollectionModel>(jsonString, new JsonSerializerSettings {
TypeNameHandling = TypeNameHandling.All
});
var importEntitiesArgument = new ImportEntitiesArgument(entities);
var command = this.Command <ImportCommerceEntitiesCommand>();
var result = await command.Process(this.CurrentContext, importEntitiesArgument);
return((IActionResult) new ObjectResult((object)this.ExecuteLongRunningCommand(() => command.Process(this.CurrentContext, importEntitiesArgument))));
}
catch (Exception ex)
{
return(new ObjectResult(ex));
}
}
public async Task <string> saveImageToBlobStorage(FormFile file)
{
var blobName = $"{Guid.NewGuid()}{Path.GetExtension(file.FileName)}";
blobName = blobName.Replace("\"", "");
var cloudBlockBlob = blobContainer.GetBlockBlobReference(blobName);
cloudBlockBlob.Properties.ContentType = file.ContentType;
cloudBlockBlob.Metadata.Add("origName", file.FileName);
using (var fileStream = file.OpenReadStream())
{
await cloudBlockBlob.UploadFromStreamAsync(fileStream);
}
return(blobName);
}
// Método para subir los blobs a azure (emulador)
// Contenedor, imagen, ruta
public async Task <String> SubirImagen(String archivo, String nombre)
{
byte[] data = Convert.FromBase64String(archivo);
var stream = new MemoryStream(data);
IFormFile imagen = new FormFile(stream, 0, data.Length, "name", nombre);
// Recuperamos nuestro contenedor
CloudBlobContainer container = this.client.GetContainerReference("fotoperfiles");
// A partir de este contenedor recuperamos el blob, que es una clase de tipo CloudBlockBlob
CloudBlockBlob blob = container.GetBlockBlobReference(imagen.FileName);
// Para subir un blob, necesitamos un stream
using (var str = imagen.OpenReadStream())
{
await blob.UploadFromStreamAsync(stream);
}
String uri = blob.SnapshotQualifiedUri.AbsoluteUri.Replace("\"", "");
return(uri);
}
public async Task <IActionResult> OnPostUploadAsync()
{
if (!ModelState.IsValid)
{
await FetchHappinessPerDayViewModel();
return(Page());
}
try
{
await using var stream = FormFile.OpenReadStream();
await _pictureStorageClient.SaveAsync(stream);
}
catch (Exception ex)
{
_logger.LogError(null, ex);
}
return(RedirectToPage());
}
public async Task OnPostAsync()
{
if (FormFile == null)
{
return;
}
var request = new PostMeterReadingsRequest();
try
{
using var reader = FormFile.OpenReadStream();
using var csv = new CsvReader(new ExcelParser(reader, "in"));
var meterReadings = csv.GetRecordsAsync <MeterReading>();
request.MeterReadings = new List <PostMeterReadingsRequest.MeterReading>();
await foreach (var meterReading in meterReadings)
{
request.MeterReadings.Add(new PostMeterReadingsRequest.MeterReading
{
AccountId = meterReading.AccountId,
MeterReadValue = meterReading.MeterReadValue,
MeterReadingDateTime = DateTime.Parse(meterReading.MeterReadingDateTime)
});
}
}
catch (Exception)
{
UploadError = true;
return;
}
var response = await _meterReadingsClient.Upload(request, CancellationToken.None);
TotalSuccessCount = response.TotalSuccessCount;
TotalFailCount = response.TotalFailCount;
}
public ObjectId saveSRTBucket(string srtPath)
{
using (var stream = File.OpenRead(srtPath))
{
FormFile formFile = new FormFile(stream, 0, stream.Length, "SrtFile", Path.GetFileName(stream.Name))
{
Headers = new HeaderDictionary(),
ContentType = "text/srt"
};
//get the bytes from the content stream of the file
byte[] theFileAsBytes = new byte[formFile.Length];
using (BinaryReader theReader = new BinaryReader(formFile.OpenReadStream()))
{
theFileAsBytes = theReader.ReadBytes((int)formFile.Length);
}
//כיון ששמירת קבצים במונגו נשמר באחסון GridFSBucket בתוך המונגו
ObjectId srtFile = bucket.UploadFromBytes(formFile.FileName, theFileAsBytes);
return(srtFile);
}
}
public async Task <ActionResult> AddLocatedImage([FromBody] LocatedImageDto locatedImageDto)
{
var locationDto = locatedImageDto.LocationDto;
var byteArray = Convert.FromBase64String(locatedImageDto.Base64);
var memoryStream = new MemoryStream(byteArray);
IFormFile file = new FormFile(memoryStream, 0, byteArray.Length, "name", "fileName.jpg");
if (file.Length > 0 && locationDto != null)
{
var randomName = GetRandomBlobName(file.FileName);
var blob = _blobContainer.GetBlockBlobReference(randomName);
using (var stream = file.OpenReadStream())
{
await blob.UploadFromStreamAsync(stream);
}
var user = _context.Users.SingleOrDefault(u => u.Id == Convert.ToInt64(locatedImageDto.UserId));
var imageLocation = new ImageLocation()
{
Uri = blob.Uri.ToString(),
Latitude = locationDto.Latitude,
Longitude = locationDto.Longitude,
User = user,
UserId = Convert.ToInt64(locatedImageDto.UserId)
};
_context.ImageLocations.Add(imageLocation);
_context.SaveChanges();
return(Ok());
}
else
{
return(NoContent());
}
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Category,Name,Brand,PurchaseDate,Price,WornTimes,ImageUrl,FileName,UserId")] Wardrobe wardrobe, List <IFormFile> files, string filename)
{
if (id != wardrobe.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var filepath = Path.GetTempFileName();
foreach (var FormFile in files)
{
if (FormFile.Length <= 0)
{
TempData["editmessage"] = "Please upload a proper image file";
}
else
{
if (filename != null)
{
//delete file from blob
CloudBlobContainer container1 = GetCloudBlobContainer();
CloudBlockBlob blobfile = container1.GetBlockBlobReference(filename);
string name = blobfile.Name;
var result = blobfile.DeleteIfExistsAsync().Result;
if (result == false)
{
TempData["message"] = "Unable to delete file";
}
else
{
TempData["message"] = "File is deleted";
}
}
//first all, get the container information
CloudBlobContainer container = GetCloudBlobContainer();
//give a name for the blob
CloudBlockBlob blob = container.GetBlockBlobReference(Path.GetFileName(FormFile.FileName));
try
{
using (var stream = FormFile.OpenReadStream())
{
await blob.UploadFromStreamAsync(stream);
}
}
catch (Exception ex)
{
TempData["message"] = ex.ToString();
}
// get the uri of the specific uploaded blob and save it
var blobUrl = blob.Uri.AbsoluteUri;
wardrobe.ImageUrl = blobUrl.ToString();
wardrobe.FileName = FormFile.FileName.ToString();
_context.Update(wardrobe);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
try
{
_context.Update(wardrobe);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WardrobeExists(wardrobe.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(wardrobe));
}
public ActionResult <string> Create
(Caterer model)
{
string json = null;
var stream2 = new MemoryStream(model.Document);
IFormFile file = new FormFile(stream2, 0, model.Document.Length, "name", "filename.xlsx");
string folderName = "UploadExcel";
//string webRootPath = _hostingEnvironment.WebRootPath;
//string newPath = Path.Combine(webRootPath, folderName);
StringBuilder sb = new StringBuilder();
//if (!Directory.Exists(newPath))
//{
// Directory.CreateDirectory(newPath);
//}
string sFileExtension = Path.GetExtension(file.FileName).ToLower();
List <string> ItemLista = new List <string>();
List <string> IngredientsLista = new List <string>();
if (file.Length > 0)
{
ISheet sheet;
using (var stream = file.OpenReadStream())
{
//json = ReadExcelasJSON(stream);
stream.Position = 0;
if (sFileExtension == ".xls")
{
HSSFWorkbook hssfwb = new HSSFWorkbook(stream); //This will read the Excel 97-2000 formats
sheet = hssfwb.GetSheetAt(0); //get first sheet from workbook
}
else
{
XSSFWorkbook hssfwb = new XSSFWorkbook(stream); //This will read 2007 Excel format
sheet = hssfwb.GetSheetAt(0); //get first sheet from workbook
}
IRow headerRow = sheet.GetRow(0); //Get Header Row
int cellCount = headerRow.LastCellNum;
sb.Append("<table class='table table-bordered'><tr>");
for (int j = 0; j < cellCount; j++)
{
NPOI.SS.UserModel.ICell cell = headerRow.GetCell(j);
if (cell == null || string.IsNullOrWhiteSpace(cell.ToString()))
{
continue;
}
sb.Append("<th>" + cell.ToString() + "</th>");
}
sb.Append("</tr>");
sb.AppendLine("<tr>");
for (int i = (sheet.FirstRowNum + 1); i <= sheet.LastRowNum; i++) //Read Excel File
{
IRow row = sheet.GetRow(i);
if (row == null)
{
continue;
}
if (row.Cells.All(d => d.CellType == NPOI.SS.UserModel.CellType.Blank))
{
continue;
}
for (int j = row.FirstCellNum; j < cellCount; j++)
{
if (row.GetCell(j) != null)
{
sb.Append("<td>" + row.GetCell(j).ToString() + "</td>");
}
}
sb.AppendLine("</tr>");
}
sb.Append("</table>");
}
}
//return this.Content(sb.ToString());
List <string> testLista2 = ItemLista;
return(sb.ToString());
}
private Task <Result <Image> > ConvertAndUpload(Image dbImage, FormFile uploadedFile)
{
return(GetBytes()
.Ensure(AreDimensionsValid,
$"Uploading image size must be at least {MinimumImageWidth}×{MinimumImageHeight} pixels and the width mustn't exceed two heights and vice versa")
.Bind(Convert)
.Bind(Upload));
Result <byte[]> GetBytes()
{
using var binaryReader = new BinaryReader(uploadedFile.OpenReadStream());
return(Result.Success(binaryReader.ReadBytes((int)uploadedFile.Length)));
}
async Task <bool> AreDimensionsValid(byte[] imageBytes)
{
var info = await ImageJob.GetImageInfo(new BytesSource(imageBytes));
return(MinimumImageWidth <= info.ImageWidth &&
MinimumImageHeight <= info.ImageHeight &&
info.ImageWidth / info.ImageHeight < 2 &&
info.ImageHeight / info.ImageWidth < 2);
}
async Task <Result <ImageSet> > Convert(byte[] imageBytes)
{
var imagesSet = new ImageSet();
using var imageJob = new ImageJob();
var jobResult = await imageJob.Decode(imageBytes)
.Constrain(new Constraint(ConstraintMode.Within, ResizedLargeImageMaximumSideSize, ResizedLargeImageMaximumSideSize))
.Branch(f => f.ConstrainWithin(ResizedSmallImageMaximumSideSize, ResizedSmallImageMaximumSideSize).EncodeToBytes(new MozJpegEncoder(TargetJpegQuality, true)))
.EncodeToBytes(new MozJpegEncoder(TargetJpegQuality, true))
.Finish().InProcessAsync();
imagesSet.SmallImage = GetImage(1);
imagesSet.MainImage = GetImage(2);
return(imagesSet.MainImage.Any() && imagesSet.SmallImage.Any()
? Result.Success(imagesSet)
: Result.Failure <ImageSet>("Processing of the images failed"));
byte[] GetImage(int index)
{
var encodeResult = jobResult?.TryGet(index);
var bytes = encodeResult?.TryGetBytes();
return(bytes != null?bytes.Value.ToArray() : new byte[]
{
});
}
}
async Task <Result <Image> > Upload(ImageSet imageSet)
{
dbImage.Position = _dbContext.Images.Count(i => i.ReferenceId == dbImage.ReferenceId && i.ImageType == dbImage.ImageType);
var entry = _dbContext.Images.Add(dbImage);
await _dbContext.SaveChangesAsync();
var imageId = entry.Entity.Id;
SetImageKeys();
var addToBucketResult = await AddImagesToBucket();
if (!addToBucketResult)
{
_dbContext.Images.Remove(entry.Entity);
await _dbContext.SaveChangesAsync();
return(Result.Failure <Image>("Uploading of the image failed"));
}
_dbContext.Images.Update(entry.Entity);
await _dbContext.SaveChangesAsync();
_dbContext.DetachEntry(entry.Entity);
return(Result.Success(dbImage));
void SetImageKeys()
{
var basePartOfKey = $"{S3FolderName}/{dbImage.ServiceSupplierId}/{imageId}";
dbImage.Keys.MainImage = $"{basePartOfKey}-main.jpg";
dbImage.Keys.SmallImage = $"{basePartOfKey}-small.jpg";
}
async Task <bool> AddImagesToBucket()
{
await using var largeStream = new MemoryStream(imageSet.MainImage);
await using var smallStream = new MemoryStream(imageSet.SmallImage);
var imageList = new List <(string key, Stream stream)>
{
(dbImage.Keys.MainImage, largeStream),
(dbImage.Keys.SmallImage, smallStream)
};
var resultList = await _amazonS3ClientService.Add(_bucketName, imageList);
foreach (var result in resultList)
{
if (result.IsFailure)
{
var keyList = new List <string>
{
dbImage.Keys.MainImage,
dbImage.Keys.SmallImage
};
await _amazonS3ClientService.Delete(_bucketName, keyList);
return(false);
}
}
return(true);
}
}
}
//public static Tuple<List<string>, List<string>> ReturnMultipleList(int[] array, int number)
//{
// return Tuple.Create(list1, list2);
//}
public static List <Item> CreateItem(Caterer model)
{
_tempList = new List <Item>();
_temp = new Item();
string json = null;
var stream2 = new MemoryStream(model.Document);
IFormFile file = new FormFile(stream2, 0, model.Document.Length, "name", "filename.xlsx");
string folderName = "UploadExcel";
string sFileExtension = Path.GetExtension(file.FileName).ToLower();
List <string> ItemLista = new List <string>();
List <string> IngredientsLista = new List <string>();
if (file.Length > 0)
{
ISheet sheet;
using (var stream = file.OpenReadStream())
{
//json = ReadExcelasJSON(stream);
stream.Position = 0;
if (sFileExtension == ".xls")
{
HSSFWorkbook hssfwb = new HSSFWorkbook(stream); //This will read the Excel 97-2000 formats
sheet = hssfwb.GetSheetAt(0); //get first sheet from workbook
}
else
{
XSSFWorkbook hssfwb = new XSSFWorkbook(stream); //This will read 2007 Excel format
sheet = hssfwb.GetSheetAt(0); //get first sheet from workbook
}
IRow headerRow = sheet.GetRow(0); //Get Header Row
int cellCount = headerRow.LastCellNum;
for (int j = 0; j < cellCount; j++)
{
NPOI.SS.UserModel.ICell cell = headerRow.GetCell(j);
if (cell == null || string.IsNullOrWhiteSpace(cell.ToString()))
{
continue;
}
}
for (int i = (sheet.FirstRowNum + 1); i <= sheet.LastRowNum; i++) //Read Excel File
{
IRow row = sheet.GetRow(i);
if (row == null)
{
continue;
}
if (row.Cells.All(d => d.CellType == NPOI.SS.UserModel.CellType.Blank))
{
continue;
}
for (int celNumber = row.FirstCellNum; celNumber < cellCount; celNumber++)
{
if (row.GetCell(celNumber) != null)
{
var data = row.GetCell(celNumber).ToString();
switch (celNumber)
{
case 0:
_temp.Name = data;
break;
case 1:
_temp.Price = int.Parse(data);
break;
case 2:
_temp.Ingredents = parseToList(data, _DELIMITER);
break;
default:
return(null);
}
}
}
_tempList.Add(_temp);
}
}
}
return(_tempList);
}
public async Task Invoke(HttpContext context)
{
HttpRequest request = context.Request;
FormFile file = null;
try
{
file = (FormFile)request.Form.Files["data"];
}
catch (InvalidOperationException)
{
// Do nothing because the file isn't available
// and that doesn't necessary indicate an error.
// TODO: Find a better solution for this...
}
if (file != null)
{
Boolean compression = request.Form["c"] == "1";
Stream newBody = file.OpenReadStream();
if (compression)
{
// GZipStream cannot be reused, so I need to copy the data out of it
using (GZipStream gzipStream = new GZipStream(newBody, CompressionMode.Decompress))
{
newBody = new MemoryStream();
await gzipStream.CopyToAsync(newBody);
newBody.Seek(0, SeekOrigin.Begin);
}
}
// The client doesn't inform us of the datatype of the data sent.
// So I need to attempt to decode the data as JSON, and if it fails, then
// assume the data is binary.
try
{
using (var reader = new StreamReader(newBody,
Encoding.UTF8,
false,
1024,
true
))
{
JToken.ReadFrom(new JsonTextReader(reader));
}
request.ContentType = "application/json";
}
catch (JsonReaderException jex)
{
Console.WriteLine(jex.Message);
}
finally
{
newBody.Seek(0, SeekOrigin.Begin);
}
context.Request.Body = newBody;
}
await _next(context);
}
