public IActionResult ChangeFileInfo(long fileId)
        {
            HostingFile file = _hostingCore.GetFileById(fileId);

            if (file == null)
            {
                return(NotFound());
            }

            User user = _hostingCore.GetUserById(file.AuthorId);

            if (User.Identity.Name == user.Email ||
                User.HasClaim(ClaimsIdentity.DefaultRoleClaimType, Roles.Admin.ToString()) ||
                User.HasClaim(ClaimsIdentity.DefaultRoleClaimType, Roles.Editor.ToString()))
            {
                var fileInfo = new FileInfoModel
                {
                    Id          = file.Id,
                    Name        = file.Name,
                    Category    = file.Category,
                    Description = file.Description
                };

                return(View(fileInfo));
            }

            return(RedirectToAction("FilePage", new { fileId = file.Id }));
        }
        public IActionResult Download(long fileId)
        {
            HostingFile file = _hostingCore.GetFileById(fileId);

            if (file == null)
            {
                return(NotFound());
            }

            return(File(Path.Combine("~", file.Link), "application/octet-stream", file.Name));
        }
        private static HostingFile GetHostingFile(SqlDataReader reader)
        {
            var file = new HostingFile
            {
                Id          = reader.GetInt64("Id"),
                Name        = reader.GetString("Name"),
                Size        = reader.GetInt64("Size"),
                AuthorId    = reader.GetInt64("AuthorId"),
                Description = reader.GetString("Description"),
                Category    = reader.GetString("Category"),
                Link        = reader.GetString("Link")
            };

            return(file);
        }
        public IActionResult DeleteFile(long fileId)
        {
            HostingFile file = _hostingCore.GetFileById(fileId);

            User user = _hostingCore.GetUserById(file.AuthorId);

            if (User.Identity.Name == user.Email ||
                User.HasClaim(ClaimsIdentity.DefaultRoleClaimType, Roles.Admin.ToString()))
            {
                System.IO.File.Delete(Path.Combine(_appEnvironment.WebRootPath, file.Link));
                _hostingCore.DeleteFile(fileId);
            }

            return(RedirectToAction("UserPage", new { userId = file.AuthorId }));
        }
        public IActionResult FilePage(long fileId)
        {
            HostingFile file = _hostingCore.GetFileById(fileId);

            if (file == null)
            {
                return(NotFound());
            }

            var userFileInfo = new UserFileModel
            {
                File = file,
                User = _hostingCore.GetUserById(file.AuthorId)
            };

            return(View(userFileInfo));
        }
        public IActionResult ChangeFileInfo(FileInfoModel fileInfo)
        {
            if (ModelState.IsValid)
            {
                HostingFile file = _hostingCore.GetFileById(fileInfo.Id);
                User        user = _hostingCore.GetUserById(file.AuthorId);

                if (User.Identity.Name == user.Email ||
                    User.HasClaim(ClaimsIdentity.DefaultRoleClaimType, Roles.Admin.ToString()) ||
                    User.HasClaim(ClaimsIdentity.DefaultRoleClaimType, Roles.Editor.ToString()))
                {
                    IEnumerable <HostingFile> userFiles = _hostingCore.GetUserFiles(file.AuthorId);

                    var selectedFiles = from userFile in userFiles
                                        where userFile.Name == fileInfo.Name &&
                                        userFile.Id != fileInfo.Id
                                        select userFile;

                    if (selectedFiles?.Count() > 0)
                    {
                        ModelState.AddModelError("", "You already have a file with this name");

                        return(View(fileInfo));
                    }

                    file.Name        = fileInfo.Name;
                    file.Category    = fileInfo.Category;
                    file.Description = fileInfo.Description;

                    _hostingCore.UpdateFile(file.Id, file);
                }

                return(RedirectToAction("FilePage", new { fileId = file.Id }));
            }

            return(View(fileInfo));
        }
        public async Task <IActionResult> Upload(FileLoadModel loadModel)
        {
            if (ModelState.IsValid)
            {
                IFormFile uploadedFile = loadModel.UploadedFile;

                User user = _hostingCore.GetUserByEmail(User.Identity.Name);

                if (user != null && uploadedFile != null)
                {
                    if (uploadedFile.FileName.Length > 100)
                    {
                        ModelState.AddModelError("", "Max file name length is 100 symbols");

                        return(View(loadModel));
                    }

                    IEnumerable <HostingFile> userFiles = _hostingCore.GetUserFiles(user.Id);

                    var selectedFiles = from userFile in userFiles
                                        where userFile.Name == uploadedFile.FileName
                                        select userFile;

                    if (selectedFiles?.Count() > 0)
                    {
                        ModelState.AddModelError("", "You already uploaded a file with this name");

                        return(View(loadModel));
                    }

                    var link = $"Files/{user.Id}/";

                    var file = new HostingFile
                    {
                        AuthorId    = user.Id,
                        Name        = uploadedFile.FileName,
                        Size        = uploadedFile.Length,
                        Category    = loadModel.Category,
                        Description = loadModel.Description,
                        Link        = link
                    };

                    _hostingCore.InsertFile(file);

                    userFiles = _hostingCore.GetUserFiles(user.Id);

                    selectedFiles = from userFile in userFiles
                                    where userFile.Name == uploadedFile.FileName
                                    select userFile;

                    file = selectedFiles.FirstOrDefault();

                    file.Link += file.Id;

                    _hostingCore.UpdateFile(file.Id, file);

                    var path = _appEnvironment.WebRootPath + $"/Files/{user.Id}/";

                    if (!Directory.Exists(path))
                    {
                        Directory.CreateDirectory(path);
                    }

                    path += file.Id;

                    using (var fileStream = new FileStream(path, FileMode.Create))
                    {
                        await uploadedFile.CopyToAsync(fileStream);
                    }

                    return(RedirectToAction("UserPage", "Hosting", new { userId = file.AuthorId }));
                }

                return(View(loadModel));
            }

            ModelState.AddModelError("", "An error occurred during uploading");
            return(View(loadModel));
        }
Example #8
0
 public void UpdateFile(long id, HostingFile file)
 {
     _dbDataProvider.ExecuteNonQuery(_dbDataProvider.Expressions.UpdateFile(id), Tables.Files, file);
 }
Example #9
0
 public void InsertFile(HostingFile file)
 {
     _dbDataProvider.ExecuteNonQuery(_dbDataProvider.Expressions.InsertFile, Tables.Files, file);
 }