Esempio n. 1
0
 public CreateModel(WebPortalAPI.Data.ApplicationDbContext context, IMapper mapper, IHostingEnvironment env)
 {
     _context   = context;
     _env       = env;
     _mapper    = mapper;
     FileUpload = new FileUploadVM(_context, _env);
 }
Esempio n. 2
0
 public EditModel(WebPortalAPI.Data.ApplicationDbContext context, IHostingEnvironment env, IMapper mapper)
 {
     _context     = context;
     _mapper      = mapper;
     _env         = env;
     fileuploadVM = new FileUploadVM(_context, _env);
 }
Esempio n. 3
0
        public async Task <IActionResult> Upload(FileUploadVM model)
        {
            if (ModelState.IsValid)
            {
                string filePath = null;
                string fileName = null;
                if (model.CsvFile != null)
                {
                    string uploadsFolder = Path.Combine(_hostingEnvironment.WebRootPath, "data");
                    fileName = model.CsvFile.FileName;
                    filePath = Path.Combine(uploadsFolder, model.CsvFile.FileName);
                    using (Stream fileStream = new FileStream(filePath, FileMode.Create))
                    {
                        await model.CsvFile.CopyToAsync(fileStream);
                    }
                }

                CSVFile csvFile = new CSVFile
                {
                    FilePath = filePath,
                    FileName = fileName
                };
                _fileService.Add(csvFile);
                return(RedirectToAction("details", new { Id = csvFile.Id }));
            }
            return(View());
        }
Esempio n. 4
0
        public async Task <IViewComponentResult> InvokeAsync(long courseId)
        {
            var model = new FileUploadVM
            {
                CourseId = courseId
            };

            return(View(model));
        }
Esempio n. 5
0
        private async Task <FileUploadVM> LoadAllFiles()
        {
            var viewModel = new FileUploadVM();

            viewModel.FilesOnDatabase = await context.FilesOnDatabase.ToListAsync();

            viewModel.FilesOnFileSystem = await context.FilesOnFileSystem.ToListAsync();

            return(viewModel);
        }
        public async Task <IViewComponentResult> InvokeAsync(long id, long courseId, long?parentId)
        {
            var model = new FileUploadVM {
                Id              = id,
                CourseId        = courseId,
                ParentSectionId = parentId > 0 ? parentId : null
            };

            return(View(model));
        }
        public async Task <IActionResult> UploadAvatarImage(FileUploadVM model)
        {
            IFormFile formFile = Request.Form.Files.FirstOrDefault();

            if (ModelState.IsValid)
            {
                if (formFile.Length > 0)
                {
                    if (!FileExtensions.IsImageType(formFile.ContentType))
                    {
                        return(BadRequest("The file provided is not of an acceptable format."));
                    }
                    var    userId       = long.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier));
                    var    fileName     = DateTime.Now.ToString("yyyyMMddHHmmss");
                    var    filePath     = $"{userId}";
                    var    fileNamePath = $"{filePath}/{fileName}.{Path.GetExtension(formFile.FileName)}";
                    string mimeType     = formFile.ContentType;
                    byte[] fileData     = new byte[formFile.Length];

                    using (var ms = new MemoryStream())
                    {
                        await formFile.CopyToAsync(ms);

                        fileData = ms.ToArray();
                    }
                    try
                    {
                        _blobService.UploadFileToBlob(fileNamePath, fileData, mimeType);
                        var entity = _context.Users.FirstOrDefault(x => x.Id == userId);

                        if (entity != default)
                        {
                            if (entity.ProfileImage != null)
                            {
                                //Delete the old image from blob
                                _blobService.DeleteBlobData(entity.ProfileImage);
                            }

                            //Set new image URL
                            entity.ProfileImage = fileNamePath;

                            //Update Entity and Save
                            _context.Update(entity);
                            await _context.SaveChangesAsync();
                        }
                    }
                    catch (Exception e)
                    {
                        _logger.LogError(e, $"Failed To Upload File For Course:{model.CourseId} Section:{model.Id}!");
                    }
                }
            }
            return(RedirectToAction("Index", "Account"));
        }
Esempio n. 8
0
        public async Task <IViewComponentResult> InvokeAsync()
        {
            var user = await _userManager.GetUserAsync(HttpContext.User);

            var model = new FileUploadVM
            {
                UserId = user.Id
            };

            return(View(model));
        }
Esempio n. 9
0
        public IActionResult Fileupload(List <IFormFile> files)
        {
            FileUploadVM f = new FileUploadVM(db, _env);

            f.file     = files.FirstOrDefault();
            f.FileName = files.FirstOrDefault().FileName;
            f.fileSize = files.FirstOrDefault().Length;
            f.Type     = (int)Utils.FileType.Logo;
            f.save();

            return(RedirectToAction("Index"));
        }
Esempio n. 10
0
        public async Task <IActionResult> UploadFile(FileUploadVM model)
        {
            IFormFile formFile = Request.Form.Files.FirstOrDefault();

            if (ModelState.IsValid)
            {
                if (formFile.Length > 0)
                {
                    if (!_fileOptions.AllowedExtensions.Contains(Path.GetExtension(formFile.FileName)))
                    {
                        return(BadRequest("The file provided is not of an acceptable format."));
                    }
                    var    fileName     = DateTime.Now.ToString("yyyyMMddHHmmss");
                    var    filePath     = $"{model.CourseId}/{model.Id}";
                    var    fileNamePath = $"{filePath}/{fileName}.{Path.GetExtension(formFile.FileName)}";
                    string mimeType     = formFile.ContentType;
                    byte[] fileData     = new byte[formFile.Length];

                    using (var ms = new MemoryStream())
                    {
                        await formFile.CopyToAsync(ms);

                        fileData = ms.ToArray();
                    }

                    try
                    {
                        _blobService.UploadFileToBlob(fileNamePath, fileData, mimeType);

                        var entity = new FileModel
                        {
                            SectionId = model.Id,
                            Name      = model.Title,
                            Uri       = fileNamePath,
                            MimeType  = mimeType
                        };

                        _context.Add(entity);
                        await _context.SaveChangesAsync();
                    }
                    catch (Exception e)
                    {
                        _logger.LogError(e, $"Failed To Upload File For Course:{model.CourseId} Section:{model.Id}!");
                    }
                }
            }
            return(RedirectToAction("Edit", "Author", new { id = model.CourseId, selectedSection = model.ParentSectionId }));
        }
Esempio n. 11
0
        public IActionResult InitDb(FileUploadVM fileToUploadVM)
        {
            if (fileToUploadVM.FileToUpload.FileName.ToLower() != "mondial.xml")
            {
                return(this.BadRequest("Bitte nur Datei mondial.xml laden"));
            }

            var    stream = fileToUploadVM.FileToUpload.OpenReadStream();
            string xml;

            using (var sr = new StreamReader(stream))
            {
                xml = sr.ReadToEnd();
            }

            world.InitDb(xml);

            return(RedirectToAction("Index"));
        }
Esempio n. 12
0
        public ActionResult UploadJson(FileUploadVM model)
        {
            //if (!ModelState.IsValid)
            //    return View(model);

            byte[] data;

            using (MemoryStream ms = new MemoryStream())
            {
                model.File.InputStream.CopyTo(ms);
                data = ms.ToArray();
            }

            var json = Encoding.Default.GetString(data);

            var entity = JsonConvert.DeserializeObject <Product[]>(json);

            return(RedirectToAction("Index", "Home"));
        }
Esempio n. 13
0
        public async Task <IActionResult> OnPostAsync()
        {
            if (!ModelState.IsValid)
            {
                return(Page());
            }


            FileUploadVM f = new FileUploadVM(_context, _env);

            f.file     = files.FirstOrDefault();
            f.FileName = files.FirstOrDefault().FileName;
            f.fileSize = files.FirstOrDefault().Length;
            f.Type     = FileUpload.Type;
            f.save();

            // _context.FileUploads.Add(FileUpload);
            //await _context.SaveChangesAsync();

            return(RedirectToPage("./FileUploadIndex"));
        }
Esempio n. 14
0
        public ActionResult <ResultVM <bool> > UploadResume([FromForm] FileUploadVM fileUploadVM)
        {
            ResultVM <bool> resultVM = new ResultVM <bool>();

            try
            {
                var formFile = fileUploadVM.Files.FirstOrDefault();
                //Check if file size exceeds 2MB
                if (formFile.Length > (2 * 1024 * 1024))
                {
                    return(StatusCode(StatusCodes.Status400BadRequest, new { Codes = new string[] { "FileSizeExceeded" } }));
                }
                var result = resumeBusiness.UploadResume(formFile);
                mapper.Map(result, resultVM);
                return(resultVM);
            }
            catch (Exception ex)
            {
                resultVM.Message    = ex.Message;
                resultVM.StatusCode = Convert.ToInt32(Enums.StatusCode.BadRequest);
                return(StatusCode(StatusCodes.Status400BadRequest, new { Result = resultVM }));
            }
        }
Esempio n. 15
0
        //Check Valid Image and Upload to Server
        public async Task <IActionResult> CheckImg(FileUploadVM vm)
        {
            var file = vm.File;

            if (file.Length > 0)
            {
                string errorMsg = null;

                String[] orgfileName = file.FileName.Split('.');
                if (orgfileName[1].ToLower() != "jpg" && orgfileName[1].ToLower() != "jpeg" && orgfileName[1].ToLower() != "png")
                {
                    errorMsg = "Only .jpg, .jpeg & .png are allowed";
                    return(Json(new { success = false, response = errorMsg }));
                }

                string path     = Path.Combine(_environment.WebRootPath, "images/article");
                var    filename = orgfileName[0] + DateTime.Now.ToString("ddMMyyhhmmsstt") + "." + orgfileName[1];
                using (var fs = new FileStream(Path.Combine(path, filename), FileMode.Create))
                {
                    await file.CopyToAsync(fs);
                }
                using (var img = Image.Load(Path.Combine(path, filename)))
                {
                    vm.Source    = $"/images/article/{filename}";
                    vm.Extension = Path.GetExtension(filename).Substring(1);
                    vm.Width     = img.Width;
                    vm.Height    = img.Height;
                    vm.Size      = file.Length / 1000;
                    if (img.Height > 400)
                    {
                        if (img.Width > 700)
                        {
                            if (vm.Size < 10000)
                            {
                                return(Json(new { success = true, response = vm }));
                            }
                            else
                            {
                                errorMsg = "Image should be less than 10 MB";
                            }
                        }
                        else
                        {
                            errorMsg = "Image Width should be greater than 700px";
                        }
                    }
                    else
                    {
                        errorMsg = "Image height should be greater than 400px";
                    }

                    if (errorMsg != null)
                    {
                        string fullPath = path + "/" + filename;
                        if (System.IO.File.Exists(fullPath))
                        {
                            System.IO.File.Delete(fullPath);
                        }
                        return(Json(new { success = false, response = errorMsg }));
                    }
                }
            }
            return(BadRequest());
        }