public async Task <IActionResult> Index()
{
ViewBag.Title = "Upload Files";
UploadViewModel model = new UploadViewModel();
model.CurrentSub = Subdomain;
model.Encrypt = false;
model.ExpirationLength = 1;
model.ExpirationUnit = ExpirationUnit.Days;
model.MaxUploadSize = _config.UploadConfig.MaxUploadSize;
if (User.Identity.IsAuthenticated)
{
User user = UserHelper.GetUser(_dbContext, User.Identity.Name);
if (user != null)
{
model.Encrypt = user.UploadSettings.Encrypt;
model.ExpirationLength = user.UploadSettings.ExpirationLength;
model.ExpirationUnit = user.UploadSettings.ExpirationUnit;
model.Vaults = user.Vaults.ToList();
model.MaxUploadSize = _config.UploadConfig.MaxUploadSizeBasic;
IdentityUserInfo userInfo = await IdentityHelper.GetIdentityUserInfo(_config, User.Identity.Name);
if (userInfo.AccountType == AccountType.Premium)
{
model.MaxUploadSize = _config.UploadConfig.MaxUploadSizePremium;
}
}
}
return(View(model));
}
public async Task <ActionResult> Send(UploadViewModel uploadViewModel)
{
//retrieving the data submitted
var file = Request.Form.Files["File"];
string group = uploadViewModel.Group;
string firstName = uploadViewModel.FirstName;
string lastName = uploadViewModel.LastName;
ApplicationUser applicationUser = applicationUserRepository.GetUserByNames(firstName, lastName).FirstOrDefault();
var filePath = Path.Combine(webHostEnvironment.WebRootPath, "uploads");
if (!Directory.Exists(filePath))
{
Directory.CreateDirectory(filePath);
}
using (var fileStream = System.IO.File.Create(Path.Combine(filePath, file.FileName)))
{
file.CopyTo(fileStream);
}
FileHandler fileHandler = new FileHandler(configuration);
await fileHandler.UploadFile(Path.Combine(filePath, file.FileName).ToString(), applicationUser);
System.IO.File.Delete(Path.Combine(filePath, file.FileName));
//the lists will be empty on post and we need to repopulate them
uploadViewModel.ApplicationUsers = this.applicationUserRepository.AllApplicationUsers;
uploadViewModel.StudyPrograms = this.studyProgramRepository.AllStudyPrograms;
uploadViewModel.Groups = this.groupRepository.AllGroups;
return(View(uploadViewModel));
}
public async Task <IActionResult> UploadImage(UploadViewModel model)
{
var file = model.File;
if (file.Length > 0)
{
string path = Path.Combine(_env.WebRootPath, "images");
using (var fs = new FileStream(Path.Combine(path, file.FileName), FileMode.Create))
{
await file.CopyToAsync(fs);
}
model.Source = $"/images{file.FileName}";
model.Extension = Path.GetExtension(file.FileName).Substring(1);
return(Ok(model));
}
return(BadRequest());
//if (file == null) throw new Exception("File is null");
//if (file.Length == 0) throw new Exception("File is empty");
//using (Stream stream = file.OpenReadStream())
//{
// using (var binaryReader = new BinaryReader(stream))
// {
// var fileContent = binaryReader.ReadBytes((int)file.Length);
// await _uploadService.AddFile(fileContent, file.FileName, file.ContentType);
// }
//}
}
public async Task <bool> UploadImageAsync(UploadViewModel upload, string userId)
{
try
{
string filename = upload.Image.FileName + Guid.NewGuid().ToString() + Path.GetExtension(upload.Image.FileName);
// Create a URI to the blob
Uri blobUri = new Uri("https://" +
_configuration.GetValue <string>("Azure:StorageAccount:Name") +
".blob.core.windows.net/" +
_configuration.GetValue <string>("Azure:StorageAccount:BlobContainer") +
"/" + filename);
// Create StorageSharedKeyCredentials object by reading
// the values from the configuration (appsettings.json)
StorageSharedKeyCredential storageCredentials = new StorageSharedKeyCredential(
_configuration.GetValue <string>("Azure:StorageAccount:Name"), _configuration.GetValue <string>("Azure:StorageAccount:Key"));
// Create the blob client.
BlobClient blobClient = new BlobClient(blobUri, storageCredentials);
// Upload the file
using (Stream file = upload.Image.OpenReadStream())
{
var res = await blobClient.UploadAsync(file);
await RecordImageUploadAsync(upload.Image.FileName, filename, userId);
}
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public void Insert(UploadViewModel vmod)
{
DokumenOrmawa dokumen = new DokumenOrmawa();
dokumen.Nama = vmod.Nama;
dokumen.Urldokumen = vmod.Urldokumen;
dokumen.JenisDokumenId = vmod.JenisDokumenId;
_context.DokumenOrmawa.Add(dokumen);
PengajuanProposalKegiatan pengajuan = new PengajuanProposalKegiatan();
pengajuan.DanaAnggaran = vmod.DanaAnggaran;
pengajuan.Kegiatan = vmod.Kegiatan;
pengajuan.AnggotaOrmawaId = 2;
pengajuan.TipeKegiatanOrmawaId = vmod.TipeKegiatanOrmawaId;
pengajuan.JenisKegiatanOrmawaId = vmod.JenisKegiatanOrmawaId;
pengajuan.PenanggungJawabId = 7;
_context.PengajuanProposalKegiatan.Add(pengajuan);
DaftarDokumenOrmawa daftar = new DaftarDokumenOrmawa();
daftar.PengajuanProposalKegiatanId = pengajuan.Id;
daftar.DokumenOrmawaId = dokumen.Id;
_context.DaftarDokumenOrmawa.Add(daftar);
_context.SaveChanges();
}
public IActionResult Upload(IFormFile imageFile, string password)
{
Guid guid = Guid.NewGuid();
string actualFileName = $"{guid}-{imageFile.FileName}";
string finalFileName = Path.Combine(_environment.WebRootPath, "uploads", actualFileName);
using var fs = new FileStream(finalFileName, FileMode.CreateNew);
imageFile.CopyTo(fs);
var db = new Imagesdb(_connectionString);
var image = new Image
{
Name = actualFileName,
Password = password,
View = +1
};
db.Add(image);
var vm = new UploadViewModel
{
Image = image
};
return(View(vm));
}
public ActionResult PostAPet(UploadViewModel model, HttpPostedFileBase[] images = null)
{
if (model != null && images != null)
{
int i = 1; string imageFileString = "";
var imgList = new Dictionary <int, string>();
foreach (var image in images)
{
var imgBin = new byte[image.ContentLength];
image.InputStream.Read(imgBin, 0, image.ContentLength);
var base64Img = Convert.ToBase64String(imgBin);
imageFileString = string.Format("data:image/jpg;base64,{0}", base64Img);
imgList.Add(i++, imageFileString);
}
var lastId = TroyHack.MvcApplication.AllPostings.Max(p => p.PostingId);
var posting = new PostViewModel
{
Age = model.Age,
Breed = model.Breed,
Characteristic = model.Characteristic,
Health = model.Health,
Images = imgList,
PostingId = lastId + 1,
SpecialNeeds = model.SpecialNeeds,
Status = model.Status,
Story = model.Story
};
TroyHack.MvcApplication.AllPostings.Add(posting);
return(RedirectToAction("Index"));
}
return(RedirectToAction("PostAPet"));
}
/// <summary>
/// Initiate a new upload operation by creating a new UploadViewModel, setting its properties,
/// saving its local upload file and finall publishing an UploadActionMessage with a UploadAction.Create
/// property for the new UploadViewModel to handle.
/// </summary>
/// <param name="newLocalUpload"></param>
/// <param name="newArchive"></param>
/// <returns></returns>
private void InitiateNewUpload(Archive newArchive, IList <ArchiveFileInfo> archiveFilesInfo)
{
_log.Info("Initiating a new upload in the upload manager.");
// create a new UploadViewModel.
UploadViewModel newUploadVM = this.CreateNewUploadVM() as UploadViewModel;
// create a new local upload
var newLocalUpload = new LocalUpload()
{
ArchiveFilesInfo = archiveFilesInfo.ToList(),
IsArchiveManifestUploaded = false
};
newUploadVM.Archive = newArchive;
newUploadVM.LocalUpload = newLocalUpload;
this._localUploads.Add(newUploadVM.LocalUpload);
// add the new UploadViewModel at the beginning of the Uploads list.
PendingUploads.Insert(0, newUploadVM);
NotifyOfPropertyChange(() => TotalPendingUploadsText);
NotifyOfPropertyChange(() => this.HasUploads);
// activate the new uploadviewmodel before sending the create message.
this.ActivateItem(newUploadVM);
IUploadActionMessage uploadActionMessage = IoC.Get <IUploadActionMessage>();
uploadActionMessage.UploadAction = Enumerations.UploadAction.Create;
uploadActionMessage.UploadVM = newUploadVM;
this._eventAggregator.PublishOnBackgroundThread(uploadActionMessage);
}
/// <summary>
/// Uploads CSV file containg Vehicle sale data in the format provided by Data Track
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool UploadVehicleData(UploadViewModel model)
{
bool ret = true;
if (model.FileToUpload != null)
{
try
{
//File name and folder name has been hard coded for Demo
Guid gid = Guid.NewGuid();
string folderPath = Path.Combine(appPath, "VehicleData");
string filePath = Path.Combine(folderPath, "DefaultData.csv");
string oldFileName = Path.Combine(folderPath, $"DefaultData{gid}.csv");
if (File.Exists(filePath))
{
File.Move(filePath, oldFileName);
}
using (var fileStream = File.Create(filePath))
{
fileStream.Position = 0;
model.FileToUpload.CopyTo(fileStream);
}
}
catch
{
ret = false;
}
}
return(ret);
}
public IActionResult Edit(Guid id, UploadViewModel model)
{
var fileInfo = _fileData.Get(id);
var companyId = GetNonAdminUserCompanyId();
if (!companyId.IsNullOrWhiteSpace() && !fileInfo.ContainerName.Equals(companyId, StringComparison.OrdinalIgnoreCase) ||
fileInfo.ReadOnly)
{
return(RedirectToAction(nameof(AccountController.AccessDenied), nameof(AccountController).GetControllerName(),
new { returnUrl = Request.Path }));
}
if (ModelState.IsValid)
{
fileInfo.Description = model.Description;
fileInfo.ContentType = model.ContentType;
fileInfo.ReadOnly = model.ReadOnly;
_fileData.Commit();
SendFileNotification(FileOperations.ModifiedMetadata, fileInfo.FileName,
User.Claims.FirstOrDefault(_ => _.Type.Equals(AuthConstants.CompanyClaim)).Value);
return(RedirectToAction(nameof(Details), new { id = fileInfo.Id }));
}
return(View(fileInfo));
}
public async Task <BaseResult <string> > UploadPhoto(UploadViewModel request)
{
try
{
var baseDir = Path.Combine(Constants.DocumentBaseDirectory);
smbFileOperationHelper.CreateFolder(baseDir);
var hotelDir = Path.Combine(baseDir, request.HotelCode);
smbFileOperationHelper.CreateFolder(hotelDir);
var photosDir = Path.Combine(hotelDir, Constants.DocumentPhotosDirectory);
smbFileOperationHelper.CreateFolder(photosDir);
var rand = new Random();
var fileToUpload = Path.Combine(photosDir, rand.Next().ToString(CultureInfo.InvariantCulture));
smbFileOperationHelper.CreateFile(fileToUpload, request.Extension.Value, request.Bytes.ToArray(), true);
return(new BaseResult <string>()
{
Result = fileToUpload + Constants.FileExtensions.GetFileExtentions(request.Extension.Value)
});
}
catch (Exception e)
{
return(new BaseResult <string>()
{
IsError = true, ExceptionMessage = e
});
}
}
public async Task <IActionResult> MultipleFiles(UploadViewModel vmod)
{
try
{
if (ModelState.IsValid)
{
if (vmod.FileDokumen == null || vmod.FileDokumen.Length == 0)
{
return(Content("file not selected"));
}
var namaFile = Path.GetFileName(vmod.FileDokumen.FileName);
var dok = namaFile.Substring(0, namaFile.IndexOf('.'));
vmod.Urldokumen = $"https://{await _fileService.UploadDokumen($"test_{dok}", vmod.FileDokumen)}";
_repo.Insert(vmod);
//return RedirectToAction(nameof(Daftaranggota));
SetSuccessNotification("Dokumen Berhasil di Upload");
return(RedirectToAction("Index", "Upload"));
}
return(RedirectToAction("Index"));
}
catch (Exception e)
{
SetErrorNotification(e.Message);
return(RedirectToAction("Index", "Upload"));
}
}
public ActionResult Index(UploadViewModel model, HttpPostedFileBase file)
{
var scanner = VirusScannerFactory.GetVirusScanner();
var result = scanner.ScanStream(file.InputStream);
ViewBag.Message = result.Message;
return View(model);
}
public IActionResult Upload()
{
var viewModel = new UploadViewModel();
viewModel.Categories = DbContext.Categories.ToList();
return(View(viewModel));
}
public async Task <UploadViewModel> ShowChooser()
{
UploadViewModel uploadViewModel = null;
var openPicker = new FileOpenPicker {
ViewMode = PickerViewMode.Thumbnail, SuggestedStartLocation = PickerLocationId.PicturesLibrary
};
openPicker.FileTypeFilter.Add(".jpg");
openPicker.FileTypeFilter.Add(".jpeg");
openPicker.FileTypeFilter.Add(".png");
openPicker.FileTypeFilter.Add(".bmp");
var file = await openPicker.PickSingleFileAsync();
if (file != null)
{
uploadViewModel = new UploadViewModel();
uploadViewModel.PictureFile = file;
uploadViewModel.PictureStream = await file.OpenReadAsync();
uploadViewModel.ImageIdentifier = Guid.NewGuid() + file.FileType;
}
return(uploadViewModel);
}
public async Task AdminController_POST_Upload_When_FileName_Length_Is_Zero_Returns_No_Content_Found()
{
// Arrange
var someFileName = "SomeFilename.csv";
var uploadObject = new UploadViewModel.Upload {
Filepath = someFileName
};
var uploadViewModel = new UploadViewModel();
uploadViewModel.Uploads.Add(uploadObject);
_TestAdminController.StashModel(uploadViewModel);
var fileToUpload = Mock.Of <IFormFile>(
f => f.FileName == someFileName &&
f.Length == 0 // Setting needed to make sure the method fails the way this test expects it to
);
var listOfFiles = new List <IFormFile>();
listOfFiles.Add(fileToUpload);
// Act
IActionResult result = await _TestAdminController.Uploads(listOfFiles, UPLOAD_COMMAND);
// Assert
Assert.NotNull(result, "Expected an object returning from the POST call to 'Uploads'");
Assert.GreaterOrEqual(
1,
_TestAdminController.ModelState[""].Errors.Count,
"Expected at least one error object to have been returned from 'Uploads', since this test is sending an invalid file to upload.");
Assert.AreEqual($"No content found in '{fileToUpload.FileName}'", _TestAdminController.ModelState[""].Errors[0].ErrorMessage);
}
public ActionResult Upload(UploadViewModel formData)
{
//Save File and Create Path
var uploadedFile = Request.Files[0];
string filename = $"{DateTime.Now.Ticks}{uploadedFile.FileName}";
var serverPath = Server.MapPath(@"~\Upload");
var fullPath = Path.Combine(serverPath, filename);
uploadedFile.SaveAs(fullPath);
Upload existing = db.Uploads
.Where(u => u.RefId == formData.refId && u.TypeRef == formData.type)
.FirstOrDefault();
if (existing == null)
{
var uploadModel = new Upload
{
File = filename,
RefId = formData.refId,
TypeRef = formData.type
};
db.Uploads.Add(uploadModel);
}
else
{
existing.File = filename;
db.Entry(existing).State = EntityState.Modified;
}
db.SaveChanges();
return(Redirect(formData.ReturnUrl));
}
public UploadPage()
{
InitializeComponent();
BindingContext = new UploadViewModel();
imagePreview.Source = URL;
test += URL;
}
public async Task AdminController_POST_Upload_When_FileName_Does_Not_Match_Returns_Invalid_Filename()
{
// Arrange
var someFileName = "SomeFilename";
var uploadObject = new UploadViewModel.Upload {
Filepath = someFileName + "InvalidFilename" + ".csv"
};
var uploadViewModel = new UploadViewModel();
uploadViewModel.Uploads.Add(uploadObject);
_TestAdminController.StashModel(uploadViewModel);
var fileToUpload = Mock.Of <IFormFile>(f => f.FileName == someFileName);
var listOfFiles = new List <IFormFile>();
listOfFiles.Add(fileToUpload);
// Act
IActionResult result = await _TestAdminController.Uploads(listOfFiles, UPLOAD_COMMAND);
// Assert
Assert.NotNull(result, "Expected an object returning from the POST call to 'Uploads'");
Assert.GreaterOrEqual(
1,
_TestAdminController.ModelState[""].Errors.Count,
"Expected at least one error object to have been returned from 'Uploads', since this test is sending an invalid file to upload.");
Assert.AreEqual($"Invalid filename '{fileToUpload.FileName}'", _TestAdminController.ModelState[""].Errors[0].ErrorMessage);
}
public ActionResult AddRoom()
{
if (Session["account"] == null)
{
return(RedirectToAction("Index", "Home"));
}
else
{
Account account = Session["account"] as Account;
if (account.Role == 0)
{
return(RedirectToAction("AllPost", "Admin"));
}
else if (account.Role == 2)
{
return(RedirectToAction("ChangeInfo", "Account"));
}
}
var cityList = db.Provinces.OrderBy(c => c.ProvinceName).ToList();
var uploadViewModel = new UploadViewModel()
{
ListProvince = cityList,
ListCriterion = db.Criteria.ToList()
};
return(View(uploadViewModel));
}
/// <summary>
/// Create UploadViewModels based on the LocalUpload List,
/// which should already be populated with all local uploads
/// started from this client. This method runs at each application start
/// and only then. Its purpose is to populate the client's uploads list.
/// </summary>
/// <param name="localUploads"></param>
/// <returns>Task</returns>
private void CreateUploadViewModels(IList <LocalUpload> localUploads)
{
IList <Task <UploadViewModel> > tasks = new List <Task <UploadViewModel> >();
foreach (LocalUpload localUpload in localUploads)
{
//tasks.Add(InstatiateUploadViewModel(localUpload));
UploadViewModel u = CreateNewUploadVM() as UploadViewModel;
u.LocalUpload = localUpload;
if (String.IsNullOrEmpty(localUpload.Status))
{
localUpload.Status = Enumerations.Status.Pending.GetStringValue();
}
this.ActivateItem(u);
Enumerations.Status status = Enumerations.GetStatusFromString(localUpload.Status);
if (status == Enumerations.Status.Completed)
{
this.CompletedUploads.Add(u);
}
else
{
this.PendingUploads.Add(u);
}
}
_log.Info("Created " + this.PendingUploads.Count + " UploadViewModels for the upload manager.");
}
public async Task <IActionResult> ProductsDataPost(long?id = 0)
{
if (id == null || id == 0)
{
return(Redirect("/Admin/Products/Index"));
}
var up = new UploadViewModel();
up.idpost = id.ToString();
var pro = await _context.Products.Include(a => a.IdmenuNavigation)
.Where(p => p.Id == id).FirstOrDefaultAsync();
if (pro == null)
{
return(Redirect("/Admin/Products/Index"));
}
ViewData["product"] = pro;
ViewData["Datatype"] = new SelectList(_context.Productdatatypes, "Id", "Name");
return(View(up));
}
public async Task <IActionResult> UpdateCustomer(UploadViewModel listofcustomers)
{
int?CustomerUploaded = listofcustomers.CustomersList.ToList().Count();
foreach (var customer in listofcustomers.CustomersList)
{
_db.Customers.Add(customer);
}
string message;
await _db.SaveChangesAsync();
if (CustomerUploaded == null)
{
// Loads page "Nothing" in data folder.
return(View("Nothing"));
}
if (CustomerUploaded == 1)
{
message = "1 customer uploaded";
}
else
{
message = CustomerUploaded.ToString() + " customers uploaded";
}
// Displays page saving it has been successful and reporting how many customers have been uploaded
return(View("UploadSuccess", message));
}
public async Task <IActionResult> Upload(UploadViewModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
var product = await this.productsRepository.Get(model.ProductId).ConfigureAwait(false);
if (model.Photos != null)
{
var photoUris = await this.SaveFiles(model.Photos.ToArray()).ConfigureAwait(false);
foreach (var photo in photoUris.Select(x => new Photo {
Uri = x
}))
{
product.Photos.Add(photo);
}
}
if (model.Thumbnail != null)
{
var thumbnailUri = await this.SaveFiles(model.Thumbnail).ConfigureAwait(false);
product.Thumbnail = thumbnailUri.Single();
}
await this.productsRepository.Update(product);
return(this.RedirectToAction("CreateOrEdit", new { id = model.ProductId }));
}
public UploadViewModel Upload(IFormFile file, string virtualPath)
{
UploadViewModel result;
var fileExtension = string.Empty;
if (file.ContentType != null)
{
fileExtension = Helpers.GetExtension(file.ContentType).Replace(".", "");
}
else
{
string[] split = file.FileName.Split(".");
fileExtension = split[split.Length - 1];
}
var filename = Guid.NewGuid().ToString() + "." + fileExtension;
var fullPath = Path.Combine(pathToSave, filename);
using (var stream = new FileStream(fullPath, FileMode.Create))
{
file.CopyTo(stream);
}
result = new UploadViewModel(virtualPath, filename, fileExtension);
return(result);
}
public ActionResult Main(UploadViewModel upload)
{
portfolioContext context = new portfolioContext();
if (!ModelState.IsValid)
{
return(View("Index", upload));
}
int id = Convert.ToInt32(upload.Works.Filter);
var filtervalue = context.filters.SingleOrDefault(x => x.Id == id);
HttpPostedFileBase image = Request.Files["Image"];
byte[] bytes = null;
using (BinaryReader br = new BinaryReader(image.InputStream))
{
bytes = br.ReadBytes(image.ContentLength);
}
Works work = new Works
{
Image = bytes,
Description = upload.Works.Description,
Title = upload.Works.Title,
Filter = filtervalue.Filter,
DT = DateTime.Now
};
context.Works.Add(work);
context.SaveChanges();
return(RedirectToAction("Main", "Admin"));
}
public HttpResponseMessage CvPhoto([FromBody] UploadViewModel model)
{
String uploadFolder = ConfigurationManager.AppSettings["PhotoUploadPath"];
String path = HttpContext.Current.Server.MapPath("~/" + uploadFolder); //Path
if (!System.IO.Directory.Exists(path))
{
System.IO.Directory.CreateDirectory(path); //Create directory if it doesn't exist
}
string imageName = Guid.NewGuid() + ".jpg";
string imgPath = Path.Combine(path, imageName);
var stringContent = model.Content
.Replace("data:image/jpeg;base64,", "")
.Replace("data:image/png;base64,", "");
byte[] imageBytes = Convert.FromBase64String(stringContent);
File.WriteAllBytes(imgPath, imageBytes);
var dataReturn = new
{
Photo = string.Format("/{0}/{1}", uploadFolder, imageName),
};
return(Request.CreateResponse(HttpStatusCode.OK, dataReturn));
}
public IActionResult Upload(UploadViewModel model)
{
List <UploadResult> result = new List <UploadResult>();
#region Form.Files 文件
IFormFileCollection files = HttpContext.Request.Form.Files;
if (null != files && files.Count > 0)
{
FormFileUploadViewModel fileModel = new FormFileUploadViewModel();
foreach (IFormFile file in files)
{
model.CopyTo(fileModel);
fileModel.File = file;
var itemResult = UploadItemByFormFile(fileModel);
result.Add(itemResult);
}
}
#endregion
#region Form.Base64 文件
Dictionary <string, string> base64Dictionary = new Dictionary <string, string>();
var formCollection = Request.Form;
foreach (var fc in formCollection)
{
if (_regexBase64.IsMatch(fc.Value))
{
base64Dictionary.Add(fc.Key, fc.Value);
}
}
if (null != base64Dictionary && base64Dictionary.Count > 0)
{
Base64UploadViewModel base64Model = null;
foreach (var file in base64Dictionary)
{
model.CopyTo(base64Model);
base64Model.Data = file.Value;
base64Model.FieldName = file.Key;
var itemResult = UploadItemByBase64(base64Model);
result.Add(itemResult);
}
}
#endregion
return(Json(result));
}
public UploadPage()
{
InitializeComponent();
_viewModel = ServiceLocator.Current.GetInstance <UploadViewModel>();
DataContext = _viewModel;
Loaded += UploadPage_Loaded;
// We need to prevent the virtual keyboard covering the textbox control
InputPane.GetForCurrentView().Showing += (s, args) =>
{
RenderTransform = new TranslateTransform {
Y = -args.OccludedRect.Height
};
args.EnsuredFocusedElementInView = true;
};
InputPane.GetForCurrentView().Hiding += (s, args) =>
{
RenderTransform = new TranslateTransform {
Y = 0
};
args.EnsuredFocusedElementInView = false;
};
}
private async Task <bool> IsValid(UploadViewModel uploadForm)
{
if (uploadForm.PictureFile == default(StorageFile))
{
var messageBox = new Windows.UI.Popups.MessageDialog("You must select a picture before uploading.", "Warning!");
await messageBox.ShowAsync();
return(false);
}
if ((uploadForm.SelectedAlbum.UniqueId == string.Empty) && string.IsNullOrWhiteSpace(uploadForm.NewAlbumName))
{
var messageBox = new Windows.UI.Popups.MessageDialog("You must provide an album name.", "Warning!");
await messageBox.ShowAsync();
return(false);
}
if (string.IsNullOrWhiteSpace(uploadForm.PictureName))
{
var messageBox = new Windows.UI.Popups.MessageDialog("You must provide a picture title.", "Warning!");
await messageBox.ShowAsync();
return(false);
}
return(true);
}
public IActionResult Create(UploadViewModel model)
{
string statusMessage = string.Empty;
ViewBag.Error = string.Empty;
if (ModelState.IsValid)
{
//TODO: Accept attribute not working. Need to verify and remove code below
if (!model.FileToUpload.FileName.ToLower().EndsWith("csv"))
{
// ViewBag.Error = "Only .CSV files allowed";
ViewBag.Error = "Only .CSV files allowed !";
return(View());
}
if (model.FileToUpload.Length == 0)
{
ViewBag.Error = "Empty file Not allowed";
return(View());
}
var data = _repository.GetDataService(VehicleDataStore.File_CSV);
bool writeStatus = data.UploadVehicleData(model);
statusMessage = writeStatus == true ? "File Successfully uploaded" : "There is error uploading file";
return(View("UploadData", statusMessage));
}
else
{
ViewBag.Error = string.Empty;
return(View());
}
}
public RootViewModel(Window window)
{
if (window == null)
throw new ArgumentNullException("window");
this.window = window;
Upload = new UploadViewModel();
ConnectCommand = new AnonymousCommand(OnConnect);
CloseCommand = new AnonymousCommand(App.Current.Shutdown);
AboutCommand = new AnonymousCommand(OnAbout);
}
public ActionResult Upload()
{
_logger.Debug("Upload init");
if (!_permissionService.Authorize(StandardPermissionProvider.ManageProducts))
return AccessDeniedView();
//a vendor cannot import products
if (_workContext.CurrentVendor != null)
return AccessDeniedView();
var viewModel = new UploadViewModel { };
return View("~/Plugins/Anko.Plugin.Admin.Uploader/Views/Upload/Upload.cshtml");
}
public ActionResult Upload(int showId)
{
var show = DatabaseSession.Get<Show>(showId);
var viewModel = new UploadViewModel();
viewModel.ParentName = show.DisplayTitleWithYear;
viewModel.ParentLinkURL = this.GetURL<ShowController>(c => c.ShowDetails(showId));
viewModel.PhotoCount = DatabaseSession.Query<ShowPhoto>().Where(x => x.Show == show).Count();
viewModel.PhotoListLinkURL = Url.GetUrl(ListShowPhotos, showId, (int?)null);
viewModel.UploadFormURL = Url.GetUrl(Upload, showId, (PhotosController.UploadPOSTParameters)null);
return new ViewModelResult(viewModel);
}
