public async Task <IActionResult> FileUpload(FileUploadViewModel fileUploadViewModel)
{
await AuthenticateUserLogin(true);
bool fileUploadedSuccessfully = false;
if (ModelState.IsValid)
{
if (!Path.GetExtension(fileUploadViewModel.DVLADataFile.FileName).Equals(".csv", StringComparison.InvariantCultureIgnoreCase))
{
TempData["errormessage"] = "Incorrect File Type. Please try again!";
return(View(fileUploadViewModel));
}
fileUploadedSuccessfully = UploadFile(fileUploadViewModel.DVLADataFile).Result;
if (fileUploadedSuccessfully)
{
TempData["successmessage"] = "File(s) Added Successfully!";
return(RedirectToAction("Index", "Home"));
}
else
{
TempData["errormessage"] = "Failed to upload file. Please try again!";
return(View(fileUploadViewModel));
}
return(View());
}
else
{
TempData["errormessage"] = "Failed to upload file. Please try again!";
return(View(fileUploadViewModel));
}
}
public async Task <ActionResult> UploadFile(FileUploadViewModel model)
{
List <FileViewModel> resultList = new List <FileViewModel>();
if (ModelState.IsValid)
{
// Use your file here
using (MemoryStream memoryStream = new MemoryStream())
{
//model.File.InputStream.CopyTo(memoryStream);
using (var dbx = new DropboxClient(accessToken))
{
var updated = await dbx.Files.UploadAsync(
model.Dir + "/" + model.File.FileName,
WriteMode.Overwrite.Instance,
body : model.File.InputStream);
// body: memoryStream);
ListFolderArg arg = new ListFolderArg(model.Dir);
var listFolderResult = await dbx.Files.ListFolderAsync(arg);
foreach (var item in listFolderResult.Entries.Where(i => i.IsFile))
{
resultList.Add(new FileViewModel()
{
Name = item.Name, Size = item.AsFile.Size, LastUpdate = item.AsFile.ServerModified.ToLongDateString()
});
}
}
}
}
return(View(resultList));
}
private List <LogRecord> GetRecords(FileUploadViewModel model)
{
List <LogRecord> employees = new List <LogRecord>();
StreamReader csvreader = new StreamReader(model.file.InputStream);
csvreader.ReadLine(); // Assuming first line is header
System.Diagnostics.Debug.WriteLine("begin");
while (!csvreader.EndOfStream)
{
var line = csvreader.ReadLine();
string[] values = Regex.Split(line, "(?<=^[^\"]*(?:\"[^\"]*\"[^\"]*)*),(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");
//var values = line.Split(',');//Values are comma separated
if (values.Count() == 0 || values[0].Equals(""))
{
break;
}
if (!values[0].Equals("DataInclude"))
{
LogRecord e = new LogRecord();
e.DateInclude = values[0];
e.Email = values[1];
e.Event1 = values[2];
e.Url = values[8];
employees.Add(e);
}
}
return(employees);
}
public async Task <ActionResult> Upload(FileUploadViewModel model)
{
int t1 = Thread.CurrentThread.ManagedThreadId;
List <Employee> employees = await Task.Factory.StartNew <List <Employee> > (() => GetEmployees(model));
int t2 = Thread.CurrentThread.ManagedThreadId;
EmployeeService service = new EmployeeService();
service.UploadEmployees(employees);
EmployeeListViewModel vm = new EmployeeListViewModel();
vm.Employees = new List <EmployeeViewModel>();
foreach (Employee item in employees)
{
EmployeeViewModel evm = new EmployeeViewModel();
evm.EmployeeName = item.FirstName + " " + item.LastName;
evm.Salary = item.Salary.ToString("C");
if (item.Salary > 15000)
{
evm.SalaryColor = "yellow";
}
else
{
evm.SalaryColor = "green";
}
vm.Employees.Add(evm);
}
return(Json(vm));
}
public async Task <IActionResult> Create(FileUploadViewModel model)
{
if (ModelState.IsValid)
{
string uniqueFileName = null;
// If the Photo property on the incoming model object is not null, then the user
// has selected an image to upload.
if (model.File != null)
{
// The image must be uploaded to the images folder in wwwroot
// To get the path of the wwwroot folder we are using the inject
// HostingEnvironment service provided by ASP.NET Core
string uploadsFolder = Path.Combine(_hostingEnvironment.WebRootPath, "images");
// To make sure the file name is unique we are appending a new
// GUID value and and an underscore to the file name
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.File.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
// Use CopyTo() method provided by IFormFile interface to
// copy the file to wwwroot/images folder
model.File.CopyTo(new FileStream(filePath, FileMode.Create));
}
FileUpload newFileUpload = new FileUpload
{
Name = model.Name,
File = uniqueFileName
};
_context.FileUploads.Add(newFileUpload);
await _context.SaveChangesAsync();
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> UploadShifts(FileUploadViewModel file)
{
bool headersProcessed = false;
using (StreamReader reader = new StreamReader(file.FormFile.OpenReadStream()))
{
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
if (!headersProcessed)
{
headersProcessed = true;
continue;
}
string[] parts = line.Split(",");
await this.shiftRepository.Add(new Shift
{
StoreName = file.StoreName,
Start = DateTime.Parse(parts[0]),
End = DateTime.Parse(parts[1]),
WorkType = parts[2],
Allocated = false
});
}
}
return(await this.Index());
}
public IActionResult SingleFile(FileUploadViewModel viewmodel)
{
// Validate is admin
if (!_credentialHoldingService.IsAdmin)
{
return(RedirectToRoute(new { controller = "Home", action = "Index" }));
}
var dir = _env.WebRootPath;
var file = viewmodel.File;
var filename = file != null?DateTime.Now.Ticks.ToString() + file.FileName.Replace(' ', '-') : "NoFileGiven";
if (file != null)
{
using (var fileStream = new FileStream($"{dir}/images/{filename}", FileMode.Create, FileAccess.ReadWrite))
{
file.CopyTo(fileStream);
}
}
_context.PostRepository.CreateAndAddNewPost(viewmodel.Title, viewmodel.Description, filename, viewmodel.SelectedTripId);
_context.SaveChanges();
// Send out subscriptions
var usersSubscribed = _context.SubscriptionRepository.GetSubscribedUsers(viewmodel.SelectedTripId);
var trip = _context.TripRepository.GetTripFromId(viewmodel.SelectedTripId);
_emailService.SendSubscriptionEmails(usersSubscribed, trip);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> UploadFile(FileUploadViewModel model)
{
if (model.File == null || model.File.Length == 0)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
;
var guId = GetFileName();
var targetFile = GetTargetFile(guId);
using (var stream = new FileStream(targetFile, FileMode.Create))
{
await model.File.CopyToAsync(stream);
model.File.OpenReadStream();
}
var file = new Entities.File
{
CourseId = model.CourseId,
Name = model.File.FileName,
DirName = "${uploadPath}",
UIdFileName = guId
};
_fileService.Create(file);
return(Ok(file));
}
public ActionResult Index()
{
FileUploadViewModel fileUpload = new FileUploadViewModel();
fileUpload.Employees = new List <EmployeeViewModel>();
return(View(fileUpload));
}
public async Task <ActionResult> UploadFile(FileUploadViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (!string.IsNullOrEmpty(model.File?.FileName))
{
var processedTransactions =
await _fileManager.ProcessCsvFilesAsync(model.File.InputStream, model.File.FileName);
if (processedTransactions.ErrorsList.Count == 0)
{
ViewBag.SuccessMessage =
$"Transactions processed successfully. The total transactions are {processedTransactions.TotalTransactionsProcessed}";
}
else
{
ViewBag.ErrorMessage =
$"Number of transactions processed successfully are {processedTransactions.TotalTransactionsProcessed} There were some failures, the specific errors are:";
foreach (var error in processedTransactions.ErrorsList)
{
ViewBag.ValidationError = ViewBag.ValidationError + " " + error;
}
model.ErrorList = processedTransactions.ErrorsList;
}
}
return(View(model));
}
public ActionResult UploadFile_facultystaffInfo(IFormFile file)
{
FileUploadViewModel fileUploadViewModel = new FileUploadViewModel();
var files = Request.Form.Files;
String filePath = "";//上传文件的路径
if (files.Count == 0)
{
throw new ArgumentException("找不到上传的文件");
}
// full path to file in temp location
foreach (var formFile in files)
{
string randomname = _fileService.fileRandName(formFile.FileName);
filePath = Directory.GetCurrentDirectory() + "\\files\\" + randomname;
if (formFile.Length > 0)
{
using (var stream = new FileStream(filePath, FileMode.Create))
{
formFile.CopyTo(stream);
}
}
fileUploadViewModel.FileName = formFile.FileName;
fileUploadViewModel.PhysisticName = randomname;
_fileService.SaveFileInfo(fileUploadViewModel);
_fileService.InputWhiteListIntoDataBase_facultystaffInfo(filePath, randomname);
}
return(Ok("导入成功"));
}
public ActionResult UploadFile_StudentInfoTimeInterval(IFormFile file)
{
FileUploadViewModel fileUploadViewModel = new FileUploadViewModel();
var files = Request.Form.Files;
String filePath = "";//上传文件的路径
if (files.Count == 0)
{
throw new ArgumentException("找不到上传的文件");
}
// full path to file in temp location
foreach (var formFile in files)
{
string randomname = _fileService.fileRandName(formFile.FileName);
filePath = Directory.GetCurrentDirectory() + "\\files\\" + randomname;
if (formFile.Length > 0)
{
using (var stream = new FileStream(filePath, FileMode.Create))
{
formFile.CopyTo(stream);
}
}
fileUploadViewModel.FileName = formFile.FileName;
//fileUploadViewModel.Url = "http://60.28.108.84:3000/toufiles/" + formFile.FileName;
//fileUploadViewModel.Url = "https://bhteda.com.cn/toufiles/" + formFile.FileName;
fileUploadViewModel.PhysisticName = randomname;
_fileService.SaveFileInfo(fileUploadViewModel);
_fileService.InputStudentInfoTimeIntervalIntoDataBase(filePath, randomname);
}
return(Ok("导入成功"));
}
public async Task <IActionResult> UploadShifts(FileUploadViewModel file)
{
bool headersProcessed = false;
Location location = await this.GetLocation(file.LocationName);
using (StreamReader reader = new StreamReader(file.FormFile.OpenReadStream()))
{
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
if (!headersProcessed)
{
headersProcessed = true;
continue;
}
string[] parts = line.Split(",");
await this.shiftRepository.Add(new Shift
{
LocationId = location.id,
StartDateTime = DateTime.Parse(parts[0]),
EndDateTime = DateTime.Parse(parts[1]),
WorkType = parts[2],
Allocated = false
});
}
}
return(Redirect("/Shifts"));
}
public async Task <ActionResult> CreateAsync(Guid folderId, string groupSlug, CancellationToken cancellationToken = default(CancellationToken))
{
if (!UserHasFileWriteAccess(folderId))
{
return(RedirectToAction("Index", "Home"));
}
if (folderId == Guid.Empty)
{
throw new ArgumentOutOfRangeException(nameof(folderId));
}
var folderModel = await _folderService.GetFolderAsync(groupSlug, folderId, CancellationToken.None);
if (folderModel is null)
{
throw new ApplicationException("No folder found for Id passed in");
}
var viewmodel = new FileUploadViewModel
{
FolderName = folderModel.Folder.FolderName,
Breadcrumbs = GetBreadcrumbs(folderId, groupSlug, "Upload file"),
FileToUpload = new FileWriteViewModel
{
FolderId = folderId,
Slug = groupSlug,
}
};
ViewBag.HideSideBar = true;
return(View(viewmodel));
}
ViewModelBase createModel()
{
var model = new FileUploadViewModel();
prepareViewModel(model);
return(model);
}
public async Task <IActionResult> UploadFileAsync(FileUploadViewModel model)
{
if (!ModelState.IsValid)
{
string errorMessages = String.Join("; ", ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage)) + ". ";
TempData["ActionMessage"] = $"[FAILED] The image { model.File.FileName } cannot be uploaded. { errorMessages }Please try again.";
}
else
{
var newFileUpload = await _fileProcessor.InsertFileRecordToDatabaseWithImageUploadingAsync(
model.File,
_configuration["ConnectionString:AzureStorage"],
"uploaded-photos",
await GetCurrentUserAsync());
await _db.FileUploads.AddAsync(newFileUpload);
await _db.SaveChangesAsync();
TempData["ActionMessage"] = $"The image { model.File.FileName } has been uploaded.";
}
return(RedirectToAction("Index"));
}
public void PrintFileUploadedSuccessful(FileUploadViewModel uploadViewModel)
{
Console.WriteLine($"\nThe file '{uploadViewModel.FilePath}' has been uploaded.");
Console.WriteLine($"- file name: '{uploadViewModel.FileName}'");
Console.WriteLine($"- file size: '{uploadViewModel.FileSize}'");
Console.WriteLine($"- extension: '{uploadViewModel.Extension}'\n");
}
public async Task UploadShifts_CsvFile_AddShifts()
{
// Arrange
IRepository <Shift> shiftRepository = Substitute.For <IRepository <Shift> >();
IRepository <Organization> organizationRepository = Substitute.For <IRepository <Organization> >();
Microsoft.Graph.IGraphServiceClient graphServiceClient = Substitute.For <Microsoft.Graph.IGraphServiceClient>();
IStringLocalizer <ShiftController> stringLocalizer = Substitute.For <IStringLocalizer <ShiftController> >();
ShiftController controller = new ShiftController(shiftRepository, organizationRepository, graphServiceClient, stringLocalizer);
FileUploadViewModel viewModel = new FileUploadViewModel {
StoreName = "Contoso"
};
string content = "Start, End, Type\n2020-04-10T09:00,2020-04-10T17:00,Shelf Stacker\n2020-04-10T10:00,2020-04-10T18:00,Tills";
byte[] contentBytes = Encoding.UTF8.GetBytes(content);
viewModel.FormFile = new FormFile(new MemoryStream(contentBytes), 0, contentBytes.Length, null, "shifts.csv")
{
Headers = new HeaderDictionary(),
ContentType = "csv"
};
// Act
await controller.UploadShifts(viewModel);
#pragma warning disable 4014
// Assert
shiftRepository.Received(1).Add(Arg.Is <Shift>(x => x.Start == DateTime.Parse("2020-04-10T09:00")));
shiftRepository.Received(1).Add(Arg.Is <Shift>(x => x.Start == DateTime.Parse("2020-04-10T10:00")));
#pragma warning restore 4014
}
public async Task<ActionResult> Upload(FileUploadViewModel model)
{
int t1 = Thread.CurrentThread.ManagedThreadId;
List<Employee> employees = await Task.Factory.StartNew<List<Employee>>(() => GetEmployees(model));
int t2 = Thread.CurrentThread.ManagedThreadId;
EmployeeBusinessLayer bal = new EmployeeBusinessLayer();
bal.UploadEmployees(employees);
EmployeeListViewModel vm = new EmployeeListViewModel();
vm.Employees = new List<EmployeeViewModel>();
foreach (Employee item in employees)
{
EmployeeViewModel evm = new EmployeeViewModel();
evm.EmployeeName = item.FirstName + " " + item.LastName;
evm.Salary = item.Salary.ToString("C");
if (item.Salary > 15000)
{
evm.SalaryColor = "yellow";
}
else
{
evm.SalaryColor = "green";
}
vm.Employees.Add(evm);
}
return Json(vm);
}
public ActionResult DeleteFile(string path)
{
System.IO.File.Delete(Server.MapPath(path));
var imageObj = _imgRepo.FindAll().Where(i => i.ImagePath == path).FirstOrDefault();
if (imageObj != null)
{
_imgRepo.Delete(imageObj);
}
var fuVM = new FileUploadViewModel();
var uploadedFiles = new List <UploadedFile>();
var files = Directory.GetFiles(Server.MapPath("~/Content/image-uploads"));
foreach (var file in files)
{
var fileInfo = new FileInfo(file);
var uploadedFile = new UploadedFile()
{
Title = Path.GetFileName(file)
};
uploadedFile.PathUrl = ("/Content/image-uploads/") + Path.GetFileName(file);
uploadedFiles.Add(uploadedFile);
}
fuVM.UploadedFiles = uploadedFiles;
return(View("FileUpload", fuVM));
}
public IActionResult Upload(FileUploadViewModel pvm)
{
FileModel file = new FileModel();
if (pvm.UploadedFile != null)
{
byte[] fileBytes = null;
// считываем переданный файл в массив байтов
using (var binaryReader = new BinaryReader(pvm.UploadedFile.OpenReadStream()))
{
fileBytes = binaryReader.ReadBytes((int)pvm.UploadedFile.Length);
}
// установка массива байтов
file.Content = fileBytes;
file.Path = pvm.UploadedFile.FileName;
}
_context.Files.Add(file);
try
{
_context.SaveChanges();
}
catch (Exception e)
{
Console.WriteLine(e.InnerException.Message);
}
return(RedirectToAction("Index"));
}
public async Task UploadShifts_ViewModel_ShiftRepoHit()
{
// Arrange
IFormFile formFile = Substitute.For <IFormFile>();
formFile.OpenReadStream()
.Returns(new MemoryStream(Encoding.UTF8.GetBytes("Start,End,WorkType\n2020-10-10,2020-10-10,Till\n2020-10-10,2020-10-10,Till")));
IRepository <Library.Models.Shift> shiftRepository = Substitute.For <IRepository <Library.Models.Shift> >();
ILocationService locationService = Substitute.For <ILocationService>();
locationService.GetByName("Contoso").Returns(new Library.Models.Location {
id = "1", Name = "Contoso"
});
ShiftsController controller = this.GetController(shiftRepository: shiftRepository, locationService: locationService);
FileUploadViewModel viewModel = new FileUploadViewModel
{
LocationName = "Contoso",
FormFile = formFile,
};
// Act
await controller.UploadShifts(viewModel);
// Assert
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
shiftRepository.Received(2).Add(
Arg.Is <Library.Models.Shift>(x => x.LocationId == "1" && x.WorkType == "Till" && x.Allocated == false));
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
}
public async Task <IActionResult> Upload([FromForm] FileUploadViewModel model)
{
try
{
using (var memoryStream = new MemoryStream())
{
await model.FormFile.CopyToAsync(memoryStream);
var file = new AppFile()
{
Content = memoryStream.ToArray(),
Name = model.FormFile.FileName
};
_context.File.Add(file);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
catch (Exception ex)
{
return(RedirectToAction(nameof(Error)));
}
}
public async Task <ActionResult> UploadImage(FileUploadViewModel fileUploadModel)
{
HttpPostedFileBase file;
try
{
file = Request.Files[0];
byte[] imageSize = new byte[file.ContentLength];
file.InputStream.Read(imageSize, 0, (int)file.ContentLength);
string filePath = System.IO.Path.Combine(Server.MapPath("~/Images/trips"), System.IO.Path.GetFileName(file.FileName));
//string fileName = file.FileName.Split('\\').Last(); // not used, it is included filepath
file.SaveAs(filePath);
HttpResponseMessage response = await UploadImageToExcursion(filePath);
if ((response.StatusCode == System.Net.HttpStatusCode.OK) && !string.IsNullOrEmpty(await response.Content.ReadAsStringAsync()))
{
return(RedirectToAction("Index", "Home"));
}
else
{
return(View("Index", "Home"));
}
}
catch (Exception e)
{
ModelState.AddModelError("uploadError", e);
return(View());
}
}
public async Task <IActionResult> Upload(IFormFile formFile)
{
var fileId = Guid.NewGuid();
var fileExt = Path.GetExtension(formFile.FileName);
var fileName = $"{fileId}{fileExt}";
var contentType = MimeTypeMap.List.MimeTypeMap.GetMimeType(fileExt).First(); // the library will always return "application/octet-stream" if type not found
var fileMetaModel = await _storageClient.UploadAsync(fileId, fileName, contentType, formFile.OpenReadStream());
// save uploaded file metadata in persisted store for future reference
await _fileMetaRepository.Add(new Aggregates.FileMeta
{
Id = fileId,
Link = fileMetaModel.Link,
Name = fileMetaModel.Name
});
var viewModel = new FileUploadViewModel
{
Id = fileId.ToString()
};
_logger.LogInformation("{messageName}|{@message}", CurrentActionName, viewModel);
return(new ObjectResult(viewModel));
}
private List <AreaModel> GetEmployeesInfo(FileUploadViewModel model)
{
List <AreaModel> employeesInfo = new List <AreaModel>();
StreamReader csvreader = new StreamReader(model.fileUpload.InputStream);
csvreader.ReadLine(); // Assuming first line is header
int i = 0;
while (!csvreader.EndOfStream)
{
i++;
var line = csvreader.ReadLine();
var values = line.Split(',');//Values are comma separated
if (values.Count() != 13)
{
System.Diagnostics.Debug.WriteLine(values.Count());
System.Diagnostics.Debug.WriteLine(i);
foreach (var v in values)
{
System.Diagnostics.Debug.Write(v + "--");
}
}
if (!values[0].Equals("Employee ID"))
{
AreaModel e = new AreaModel();
e.EmpId = values[0];
e.Email = values[1];
e.AreaCode = values[9];
e.Country = values[12];
employeesInfo.Add(e);
}
}
return(employeesInfo);
}
//[AdminFilter]
//public ActionResult Upload(FileUploadViewModel model, string upload)
//{
// List<Employee> employees = GetEmployees(model);
// EmployeeBusinessLayer bal = new EmployeeBusinessLayer();
// bal.UploadEmployees(employees, db);
// return RedirectToAction("Index", "Employee");
//}
private List <Employee> GetEmployees(FileUploadViewModel model)
{
var path = Path.Combine(
Directory.GetCurrentDirectory(), "wwwroot",
model.FileToUpload.GetFilename());
using (var stream = new FileStream(path, FileMode.Create))
{
model.FileToUpload.CopyToAsync(stream);
StreamReader reader = new StreamReader(stream);
List <Employee> employees = new List <Employee>();
reader.ReadLine();
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
var values = line.Split(',');
Employee e = new Employee();
e.FirstName = values[0];
e.LastName = values[1];
e.Salary = int.Parse(values[2]);
employees.Add(e);
}
return(employees);
}
}
public async Task <ActionResult> Create(FileUploadViewModel model)
{
if (ModelState.IsValid)
{
if (model.ImageUpload != null && model.ImageUpload.ContentLength > 0)
{
VtaDbContext db = new VtaDbContext();
var file = await db.Files.FindAsync(model.FileId);
string extension = Path.GetExtension(model.ImageUpload.FileName);
await AzureHelper.CreateAndConfigureAsync();
HttpPostedFileBase photoToUpload = model.ImageUpload;
string name = file.Id + extension;
string url = await AzureHelper.UploadPhotoAsync(photoToUpload, name);
file.SourceUrl = url;
file.IsUploaded = true;
file.ConvertedUrl = "";
file.IsConverted = false;
db.Entry(file).State = EntityState.Modified;
db.SaveChanges();
}
return(RedirectToAction("Index", "Files"));
}
return(View(model));
}
public ActionResult UploadEmployeeInfo(FileUploadViewModel model)
{
List <AreaModel> areaInfo = GetEmployeesInfo(model);
EmployeeBusinessLayer bal = new EmployeeBusinessLayer();
bal.UploadEmployeesInfo(areaInfo);
return(RedirectToAction("Index", "Employee"));
}
public ActionResult Upload(FileUploadViewModel model)
{
List <Employee> employees = GetEmployees(model);
EmployeeBusinessLayer bal = new EmployeeBusinessLayer();
bal.UploadEmployees(employees);
return(RedirectToAction("Index", "Employee"));
}
private async Task <FileUploadViewModel> LoadAllFiles()
{
var viewModel = new FileUploadViewModel();
viewModel.Files = await _fileRepository.AllFiles();
return(viewModel);
}
private List<Employee> GetEmployees(FileUploadViewModel model)
{
List<Employee> employees = new List<Employee>();
StreamReader csvreader = new StreamReader(model.fileUpload.InputStream);
csvreader.ReadLine();// Assuming first line is header
while (!csvreader.EndOfStream)
{
var line = csvreader.ReadLine();
var values = line.Split(',');//Values are comma separated
Employee e = new Employee();
e.FirstName = values[0];
e.LastName = values[1];
e.Salary = int.Parse(values[2]);
employees.Add(e);
}
return employees;
}
private FileUploadViewModel GenerateViewModel(string publicKey, string secretKey, string bucketName, string uploaderPath)
{
var vm = new FileUploadViewModel
{
FormAction = "http://" + bucketName + ".s3.amazonaws.com/",
FormMethod = "post",
FormEnclosureType = "multipart/form-data",
Bucket = bucketName,
FileId = "uploads/:uuid" + "/${filename}",
AwsAccessKey = publicKey,
// one of private, public-read, public-read-write, or authenticated-read
Acl = "public-read"
};
const string AWS_ISO_FORMAT = "yyyy-MM-ddTHH:mm:ss.fffZ";
var policy =
new
{
expiration = DateTime.Now.AddHours(10).ToUniversalTime().ToString(AWS_ISO_FORMAT, System.Globalization.CultureInfo.InvariantCulture),
conditions = new object[]
{
new { bucket = bucketName },
new [] { "starts-with", "$key", "" },
new { acl = "public-read" },
new { success_action_status = "201" },
new object[] { "content-length-range", 0, 20971520 },
new [] { "starts-with", "$Content-Type", "" }
}
};
String serialzedPolicy = new System.Web.Script.Serialization.JavaScriptSerializer().Serialize(policy);
var encoding = new ASCIIEncoding();
vm.Base64Policy = Convert.ToBase64String(encoding.GetBytes(serialzedPolicy));
vm.Signature = CreateSignature(secretKey, serialzedPolicy);
vm.CreatResourceUrl = "Uploads/Create";
vm.UploaderPath = uploaderPath + "uploader.html";
vm.ToQuery = vm.FormAction + vm.UploaderPath + "?AWSAccessKeyId=" + vm.AwsAccessKey +
"&_policy=" + vm.Base64Policy + "&_signature=" + vm.Signature +
"&bucket=" + HttpUtility.UrlEncode(vm.FormAction) + "&key=" + HttpUtility.UrlEncode(vm.FileId);
return vm;
}
