// this method removes desired files and folders
public bool RemoveFilesAndFolders(string userId, string[] foldersId, string[] filesId)
{
bool success = true;
foreach (var id in foldersId)
{
Folder folder = _database.GetRepository <Folder>().Get(id);
if (folder == null)
{
throw new StatusCodeException($"The folder with ID = {id} doesn't exists.", StatusCodes.Status404NotFound);
}
FolderVM vm = new FolderVM {
IsShared = folder.IsShared, OwnerId = folder.OwnerId
};
if (CheckEditAccess(vm, userId))
{
try
{
Directory.Delete(folder.Path, true);
Folder deletedFolder = _database.GetRepository <Folder>().Get(id);
RemoveChildrenFolders(deletedFolder);
_database.GetRepository <Folder>().Delete(id);
_database.Save();
}
catch
{
success = false;
}
}
}
foreach (var id in filesId)
{
DAL.Entities.File file = _database.GetRepository <DAL.Entities.File>().Get(id);
if (file == null)
{
throw new StatusCodeException($"The file with ID = {id} doesn't exists.", StatusCodes.Status404NotFound);
}
FileVM vm = new FileVM {
IsShared = file.IsShared, OwnerId = _database.GetRepository <Folder>().Get(file.FolderId).OwnerId
};
if (CheckEditAccess(vm, userId))
{
try
{
System.IO.File.Delete(file.Path);
_database.GetRepository <DAL.Entities.File>().Delete(id);
_database.Save();
}
catch
{
success = false;
}
}
}
return(success);
}
public async Task<IActionResult> AddFile(IFormFile uploadedFile)
{
try
{
if (uploadedFile != null)
{
string path = "/Files/" + uploadedFile.FileName;
using (var fileStream = new FileStream(_appEnvironment.WebRootPath + path, FileMode.Create))
{
await uploadedFile.CopyToAsync(fileStream).ConfigureAwait(false);
}
var users = await _unitOfWork.Users.Find(u => u.Email == User.Identity.Name).ConfigureAwait(false);
if (users.Any())
{
var usersGuid = users.First().UserGuid;
DAL.Entities.File file = new DAL.Entities.File { Name = uploadedFile.FileName, Path = path, UserGuid = usersGuid };
_unitOfWork.Files.Create(file);
_unitOfWork.Save();
}
}
return RedirectToAction("Files");
}
catch (Exception ex)
{
_logger.LogError(ex, "Can't add file");
return BadRequest();
}
}
// this method renames the desired file
public bool RenameFile(string newName, string fileId)
{
DAL.Entities.File file = _database.GetRepository <DAL.Entities.File>().Get(fileId);
if (file == null)
{
throw new StatusCodeException($"The file with ID = {fileId} doesn't exists.", StatusCodes.Status404NotFound);
}
string oldPath = file.Path;
string extension = ElementHelperClass.DefineFileExtension(oldPath);
string newPath = oldPath.Substring(0, oldPath.LastIndexOf('\\') + 1) + newName + extension;
file.Path = newPath;
if (!System.IO.File.Exists(newPath))
{
System.IO.File.Move(oldPath, newPath);
_database.GetRepository <DAL.Entities.File>().Update(file);
_database.Save();
return(true);
}
else
{
return(false);
}
}
// this method creates an archive and returns it for download
public MemoryStream CreateArchive(string currFolderId, string userId, string[] foldersId, string[] filesId)
{
Folder parentFolder = _database.GetRepository <Folder>().Get(currFolderId);
if (parentFolder == null)
{
throw new StatusCodeException($"Invalid current folder ID ({currFolderId}). Unable to create archive.",
StatusCodes.Status500InternalServerError);
}
ZipStrings.UseUnicode = true;
MemoryStream outputMemStream = new MemoryStream();
using (var zipStream = new ZipOutputStream(outputMemStream))
{
zipStream.SetLevel(0);
int folderOffset = parentFolder.Path.Length + (parentFolder.Path.EndsWith("\\") ? 0 : 1);
foreach (var id in filesId)
{
DAL.Entities.File file = _database.GetRepository <DAL.Entities.File>().Get(id);
FileVM vm = new FileVM {
IsShared = file.IsShared, OwnerId = _database.GetRepository <Folder>().Get(file.FolderId).OwnerId
};
if (CheckAccessToView(vm, userId))
{
CompressFile(file, zipStream, folderOffset);
}
}
foreach (var id in foldersId)
{
Folder folder = _database.GetRepository <Folder>().Get(id);
FolderVM vm = new FolderVM {
IsShared = folder.IsShared, OwnerId = folder.OwnerId
};
if (CheckAccessToView(vm, userId))
{
CompressFolder(folder, userId, zipStream, folderOffset);
}
}
zipStream.IsStreamOwner = false;
}
outputMemStream.Position = 0;
return(outputMemStream);
}
public ActionResult UploadFiles()
{
// Checking no of files injected in Request object
if (Request.Files.Count > 0)
{
try
{
var fileIds = new List <int>();
// Get all files from Request object
var files = Request.Files;
for (var i = 0; i < files.Count; i++)
{
var file = Request.Files[0];
if (file == null || file.ContentLength <= 0)
{
continue;
}
// Code to process image, resize, etc goes here
var image = new DAL.Entities.File
{
FileName = file.FileName,
FileContentType = file.ContentType,
FileBytes = new byte[file.ContentLength],
FileSize = file.ContentLength
};
file.InputStream.Read(image.FileBytes, 0, image.FileSize);
//add the id to the userProfileDto
fileIds.Add(FileFunctions.Create(image));
}
// Returns message that successfully uploaded
return(Json(fileIds.ToArray()));
}
catch (Exception ex)
{
return(Json("Error occurred. Error details: " + ex.Message));
}
}
else
{
return(Json("No files selected."));
}
}
// this method compresses a file
private void CompressFile(DAL.Entities.File file, ZipOutputStream zipStream, int folderOffset)
{
FileInfo fi = new FileInfo(file.Path);
string entryName = file.Path.Substring(folderOffset);
entryName = ZipEntry.CleanName(entryName);
ZipEntry newEntry = new ZipEntry(entryName);
newEntry.DateTime = fi.LastWriteTime;
newEntry.Size = fi.Length;
zipStream.PutNextEntry(newEntry);
var buffer = new byte[4096];
using (FileStream fsInput = System.IO.File.OpenRead(file.Path))
{
StreamUtils.Copy(fsInput, zipStream, buffer);
}
zipStream.CloseEntry();
}
// this method upload files on the hard drive and saves them in the database
public async Task <ICollection <ElementVM> > UploadFiles(IFormFileCollection files, FolderVM parentFolder)
{
List <ElementVM> elements = new List <ElementVM>();
foreach (var uploadedFile in files)
{
string path = parentFolder.Path + '\\' + uploadedFile.FileName;
if (!System.IO.File.Exists(path))
{
DAL.Entities.File file = new DAL.Entities.File
{
Id = Guid.NewGuid().ToString(),
Path = path,
IsShared = parentFolder.IsShared,
FolderId = parentFolder.Id
};
_database.GetRepository <DAL.Entities.File>().Create(file);
ElementVM elem = new ElementVM
{
Id = file.Id,
IsFolder = false,
ElemName = uploadedFile.FileName,
LastModified = DateTime.Now.ToShortDateString(),
Type = ElementHelperClass.DefineFileType(ElementHelperClass.DefineFileExtension(uploadedFile.FileName)),
Size = ElementHelperClass.Recount(new Tuple <double, ElementVM.Unit>(uploadedFile.Length, ElementVM.Unit.B)),
IsShared = file.IsShared
};
elements.Add(elem);
}
using (var fileStream = new FileStream(path, FileMode.Create))
{
await uploadedFile.CopyToAsync(fileStream);
}
}
_database.Save();
return(elements);
}
// this method changes access to view for the selected folders and files and returns folder id
public string ChangeAccess(string currFolderId, string userId, string[] foldersId, string[] filesId, bool openAccess)
{
Folder parent = _database.GetRepository <Folder>().Get(currFolderId);
if (parent == null)
{
throw new StatusCodeException($"The folder with ID = {currFolderId} doesn't exists.", StatusCodes.Status404NotFound);
}
FolderVM parentVM = new FolderVM {
IsShared = parent.IsShared, OwnerId = parent.OwnerId
};
if (CheckEditAccess(parentVM, userId))
{
string idForLink;
if (foldersId.Length == 1 && filesId.Length == 0)
{
idForLink = foldersId[0];
}
else
{
idForLink = currFolderId;
}
foreach (string id in filesId)
{
DAL.Entities.File file = _database.GetRepository <DAL.Entities.File>().Get(id);
if (file == null)
{
throw new StatusCodeException($"The file with ID = {id} doesn't exists.", StatusCodes.Status404NotFound);
}
FileVM vm = new FileVM {
IsShared = file.IsShared, OwnerId = _database.GetRepository <Folder>().Get(file.FolderId).OwnerId
};
if (CheckEditAccess(vm, userId))
{
file.IsShared = openAccess;
_database.GetRepository <DAL.Entities.File>().Update(file);
}
}
foreach (string id in foldersId)
{
Folder folder = _database.GetRepository <Folder>().Get(id);
if (folder == null)
{
throw new StatusCodeException($"The folder with ID = {id} doesn't exists.", StatusCodes.Status404NotFound);
}
FolderVM vm = new FolderVM {
IsShared = folder.IsShared, OwnerId = folder.OwnerId
};
if (CheckEditAccess(vm, userId))
{
folder.IsShared = openAccess;
_database.GetRepository <Folder>().Update(folder);
ChangeChildrenAccess(folder, openAccess);
}
}
_database.Save();
return(idForLink);
}
else
{
throw new StatusCodeException($"You don't have access to folder with ID = {currFolderId}.", StatusCodes.Status403Forbidden);
}
}
// this method returns all folders and files that are contained in the needed folder
public ICollection <ElementVM> GetElementsFromFolder(FolderVM folderVM, string userId)
{
if (folderVM == null)
{
throw new StatusCodeException("The needed folder doesn't exists.", StatusCodes.Status404NotFound);
}
DirectoryInfo dir = new DirectoryInfo(folderVM.Path);
FileInfo[] files;
DirectoryInfo[] dirs;
files = dir.GetFiles();
dirs = dir.GetDirectories();
List <ElementVM> models = new List <ElementVM>();
List <Folder> childFolders = _database.GetRepository <Folder>().Find(f => f.ParentFolderId == folderVM.Id).ToList();
List <DAL.Entities.File> childFiles = _database.GetRepository <DAL.Entities.File>().Find(f => f.FolderId == folderVM.Id).ToList();
foreach (var elem in dirs)
{
Folder folder = childFolders.Find(f => f.Path == elem.FullName);
if (folder != null)
{
if (CheckAccessToView(new FolderVM {
OwnerId = folder.OwnerId, IsShared = folder.IsShared
}, userId))
{
ElementVM model = new ElementVM
{
Id = folder.Id,
IsFolder = true,
Type = ElementVM.FileType.Folder,
ElemName = elem.Name,
LastModified = elem.LastWriteTime.ToShortDateString(),
Size = null,
IsShared = folder.IsShared
};
models.Add(model);
}
}
}
foreach (var elem in files)
{
DAL.Entities.File file = childFiles.Find(f => f.Path == elem.FullName);
if (file != null)
{
FileVM vm = new FileVM {
IsShared = file.IsShared, OwnerId = _database.GetRepository <Folder>().Get(file.FolderId).OwnerId
};
if (CheckAccessToView(vm, userId))
{
// for a more convenient display of file size, call the conversion function
Tuple <double, ElementVM.Unit> size = new Tuple <double, ElementVM.Unit>(elem.Length, ElementVM.Unit.B);
size = ElementHelperClass.Recount(size);
ElementVM.FileType type = ElementHelperClass.DefineFileType(elem.Extension);
ElementVM model = new ElementVM
{
Id = childFiles.Find(f => f.Path == elem.FullName).Id,
IsFolder = false,
Type = type,
ElemName = elem.Name,
LastModified = elem.LastWriteTime.ToShortDateString(),
Size = size,
IsShared = file.IsShared
};
models.Add(model);
}
}
}
return(models);
}
