983 lines
38 KiB
C#
983 lines
38 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.IO.Compression;
|
|
using System.Linq;
|
|
using gehGassi.Core.Interfaces;
|
|
using gehGassi.Permissions;
|
|
using gehGassi.Web.Auth;
|
|
using gehGassi.Web.Auth.Attributes;
|
|
using gehGassi.Web.Models;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Http;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.AspNetCore.StaticFiles;
|
|
using Newtonsoft.Json;
|
|
|
|
namespace gehGassi.Web.Controllers
|
|
{
|
|
/// <summary>
|
|
/// Controller für die Verwaltung von Stufen
|
|
/// </summary>
|
|
[Authorize]
|
|
public class FileManagerController : BaseController
|
|
{
|
|
private readonly IFileShareService _fileShareService;
|
|
|
|
/// <summary>
|
|
/// Erstellt eine Instanz
|
|
/// </summary>
|
|
/// <param name="fileShareService">Instanz eines IFileShareService</param>
|
|
public FileManagerController(IFileShareService fileShareService)
|
|
{
|
|
_fileShareService = fileShareService;
|
|
}
|
|
|
|
#region Admin
|
|
|
|
/// <summary>
|
|
/// Gibt einen View für den Dateimanager zurück
|
|
/// </summary>
|
|
/// <returns>View</returns>
|
|
[Authorize(Policy = Policies.PowerUserOnly)]
|
|
[HasPermission(Permission.SettingsManage, Permission.SettingsFileManager)]
|
|
[ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
|
|
public IActionResult Index()
|
|
{
|
|
return View();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handler für file-Browser Anfragen.
|
|
/// </summary>
|
|
/// <param name="args">FileExplorerParams mit Commands und Parameter</param>
|
|
/// <returns></returns>
|
|
[Authorize(Policy = Policies.PowerUserOnly)]
|
|
[HttpPost]
|
|
[ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
|
|
public object Handler([FromBody] FileManagerDirectoryContent args)
|
|
{
|
|
if (args.Action is "delete" or "rename")
|
|
{
|
|
if (args.TargetPath == null && args.Path == "")
|
|
{
|
|
var response = new FileManagerResponse { Error = new ErrorDetails { Code = "401", Message = "Restricted to modify the root folder." } };
|
|
return Json(response);
|
|
}
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(args.Path))
|
|
{
|
|
if (args.Path.StartsWith("/"))
|
|
args.Path = $"gehGassi{args.Path}";
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(args.TargetPath))
|
|
{
|
|
if (args.TargetPath.StartsWith("/"))
|
|
args.TargetPath = $"gehGassi{args.TargetPath}";
|
|
}
|
|
|
|
var rootName = "gehGassi";
|
|
|
|
switch (args.Action)
|
|
{
|
|
case "read":
|
|
// reads the file(s) or folder(s) from the given path.
|
|
return Json(GetFilesAndFolders(args.Path, rootName));
|
|
case "delete":
|
|
// deletes the selected file(s) or folder(s) from the given path.
|
|
return Json(Delete(args.Path, args.Names.ToList()));
|
|
case "copy":
|
|
// copies the selected file(s) or folder(s) from a path and then pastes them into a given target path.
|
|
return Json(Copy(args.Path, args.TargetPath, args.Names.ToList()));
|
|
case "move":
|
|
// cuts the selected file(s) or folder(s) from a path and then pastes them into a given target path.
|
|
return Json(Move(args.Path, args.TargetPath, args.Names.ToList()));
|
|
case "details":
|
|
// gets the details of the selected file(s) or folder(s).
|
|
return Json(Details(args.Path, args.Names.ToList()));
|
|
case "create":
|
|
//creates a new folder in a given path.
|
|
return Json(CreateFolder(args.Path, args.Name));
|
|
case "search":
|
|
// gets the list of file(s) or folder(s) from a given path based on the searched key string.
|
|
return Json(GetFilesAndFolders(args.Path, rootName, args.SearchString));
|
|
case "rename":
|
|
// renames a file or folder.
|
|
return Json(Rename(args.Path, args.Name, args.NewName, rootName));
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gibt ein Bild zurück
|
|
/// </summary>
|
|
/// <param name="args">Parameter</param>
|
|
/// <returns>Bild oder NotFound</returns>
|
|
[Authorize(Policy = Policies.PowerUserOnly)]
|
|
[ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
|
|
public IActionResult GetImage(FileManagerDirectoryContent args)
|
|
{
|
|
if (args.Path.StartsWith("/"))
|
|
args.Path = $"gehGassi{args.Path}";
|
|
var (share, filename) = GetShareAndFolder(args.Path);
|
|
|
|
var file = _fileShareService.Get(share, filename);
|
|
if (file != null)
|
|
{
|
|
return File(file, GetMimeMapping(Path.GetFileName(filename)));
|
|
}
|
|
|
|
return NotFound();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hochladen einer oder mehrerer Dateien
|
|
/// </summary>
|
|
/// <param name="path">Pfad</param>
|
|
/// <param name="uploadFiles">Dateien</param>
|
|
/// <param name="action">Action</param>
|
|
/// <returns></returns>
|
|
[Authorize(Policy = Policies.PowerUserOnly)]
|
|
[ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
|
|
public IActionResult Upload(string path, IList<IFormFile> uploadFiles, string action)
|
|
{
|
|
if (path.StartsWith("/"))
|
|
path = $"gehGassi{path}";
|
|
var (share, folder) = GetShareAndFolder(path);
|
|
|
|
try
|
|
{
|
|
for (var i = 0; i < uploadFiles.Count; i++)
|
|
{
|
|
var fileName = Path.GetFileName(uploadFiles[i].FileName);
|
|
|
|
if (!string.IsNullOrWhiteSpace(folder))
|
|
fileName = $"{folder}/{fileName}";
|
|
|
|
using (var ms = new MemoryStream())
|
|
{
|
|
uploadFiles[i].CopyTo(ms);
|
|
var fileBytes = ms.ToArray();
|
|
_fileShareService.Store(share, fileName, fileBytes);
|
|
}
|
|
}
|
|
}
|
|
catch { }
|
|
|
|
return Content("");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Herunterladen einer Datei
|
|
/// </summary>
|
|
/// <param name="downloadInput">PArameter</param>
|
|
/// <returns>Datei</returns>
|
|
[Authorize(Policy = Policies.PowerUserOnly)]
|
|
[ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
|
|
public IActionResult Download(string downloadInput)
|
|
{
|
|
var args = JsonConvert.DeserializeObject<FileManagerDirectoryContent>(downloadInput);
|
|
if (args.Path.StartsWith("/"))
|
|
args.Path = $"gehGassi{args.Path}";
|
|
|
|
var names = args.Names;
|
|
var data = args.Data;
|
|
|
|
var fileCount = 0;
|
|
for (int i = 0; i < args.Data.Length; i++)
|
|
{
|
|
if (args.Data[i].IsFile)
|
|
fileCount++;
|
|
}
|
|
var filesOnly = fileCount == names.Length;
|
|
|
|
if (filesOnly && names.Length == 1)
|
|
{
|
|
//Nur eine Datei.... direkter Download
|
|
var (share, folder) = GetShareAndFolder(args.Path);
|
|
if (!string.IsNullOrWhiteSpace(folder))
|
|
folder += "/";
|
|
var file = _fileShareService.Get(share, folder + names[0]);
|
|
if (file != null)
|
|
{
|
|
return File(file, "APPLICATION/octet-stream", names[0]);
|
|
}
|
|
}
|
|
else if (filesOnly && names.Length > 1)
|
|
{
|
|
//Mehrere Dateien. Diese nun in ein Zip verpacken und als Zip senden
|
|
byte[] archiveFile;
|
|
using (var archiveStream = new MemoryStream())
|
|
{
|
|
using (var archive = new ZipArchive(archiveStream, ZipArchiveMode.Create, true))
|
|
{
|
|
for (int i = 0; i < args.Data.Length; i++)
|
|
{
|
|
var (share, folder) = GetShareAndFolder(args.Path);
|
|
if (!string.IsNullOrWhiteSpace(folder))
|
|
folder += "/";
|
|
var file = _fileShareService.Get(share, folder + names[i]);
|
|
if (file != null)
|
|
{
|
|
var zipArchiveEntry = archive.CreateEntry(names[i], CompressionLevel.Optimal);
|
|
using var zipStream = zipArchiveEntry.Open();
|
|
zipStream.Write(file, 0, file.Length);
|
|
}
|
|
}
|
|
}
|
|
|
|
archiveFile = archiveStream.ToArray();
|
|
}
|
|
|
|
var fileName = $"gehGassi_{DateTime.Now.Year}-{DateTime.Now.Month}-{DateTime.Now.Day}-{DateTime.Now.Hour}-{DateTime.Now.Minute}-{DateTime.Now.Second}.zip";
|
|
return File(archiveFile, "APPLICATION/octet-stream", fileName);
|
|
}
|
|
|
|
return NotFound();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region private
|
|
|
|
/// <summary>
|
|
/// Lesen von Daten
|
|
/// </summary>
|
|
/// <param name="path">Pfad - beinhaltet bereits Anpassungen an Rollen</param>
|
|
/// <param name="rootName">Root-Name der angezeigt werden soll</param>
|
|
/// <param name="filter">Filter wenn gesucht werden soll</param>
|
|
/// <returns>FileManagerResponse</returns>
|
|
private FileManagerResponse GetFilesAndFolders(string path, string rootName, string filter = "")
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(filter))
|
|
filter = filter.Replace("*", "");
|
|
|
|
var (share, folder) = GetShareAndFolder(path);
|
|
|
|
var response = new FileManagerResponse { Files = new List<FileManagerDirectoryContent>() };
|
|
try
|
|
{
|
|
var directoriesFound = _fileShareService.ListFolders(share, folder);
|
|
var filesFound = _fileShareService.ListFiles(share, folder);
|
|
|
|
var (dirName, relativePath) = GetFolderNameAndRelativePath(folder, rootName);
|
|
var folderInfo = _fileShareService.GetFolderInfo(share, folder);
|
|
var directoryContent = new FileManagerDirectoryContent
|
|
{
|
|
Name = dirName,
|
|
FilterPath = relativePath,
|
|
Size = 0,
|
|
Type = "File Folder",
|
|
IsFile = false,
|
|
DateModified = folderInfo?.LastModified ?? DateTimeOffset.UtcNow,
|
|
DateCreated = folderInfo?.Created ?? DateTimeOffset.UtcNow,
|
|
HasChild = directoriesFound.Count > 0 ? true : false
|
|
};
|
|
response.CWD = directoryContent;
|
|
|
|
foreach (var directory in directoriesFound)
|
|
{
|
|
|
|
if (directory.Name.ToLowerInvariant().Contains(filter.ToLowerInvariant()))
|
|
{
|
|
response.Files.Add(new FileManagerDirectoryContent()
|
|
{
|
|
Name = directory.Name,
|
|
FilterPath = relativePath,
|
|
Size = 0,
|
|
Type = "Directory",
|
|
IsFile = false,
|
|
DateModified = directory.LastModified ?? DateTimeOffset.UtcNow,
|
|
DateCreated = directory.Created ?? DateTimeOffset.UtcNow,
|
|
HasChild = directory.HasSubfolders
|
|
});
|
|
}
|
|
}
|
|
|
|
foreach (var file in filesFound)
|
|
{
|
|
var fileName = file.Name.ToLowerInvariant();
|
|
var extension = Path.GetExtension(fileName)?.ToLowerInvariant();
|
|
if (fileName.ToLowerInvariant().Contains(filter.ToLowerInvariant()))
|
|
{
|
|
response.Files.Add(new FileManagerDirectoryContent()
|
|
{
|
|
Name = file.Name,
|
|
FilterPath = FolderToRelativePath(folder),
|
|
Size = file.Size,
|
|
Type = extension,
|
|
IsFile = true,
|
|
DateModified = file.LastModified ?? DateTimeOffset.UtcNow,
|
|
DateCreated = file.Created ?? DateTimeOffset.UtcNow,
|
|
HasChild = false,
|
|
});
|
|
}
|
|
}
|
|
|
|
return response;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var errorDetails = new ErrorDetails { Message = ex.GetType().FullName + ", " + ex.Message, Code = "500" };
|
|
response.Error = errorDetails;
|
|
return response;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Anlegen eines Ordners
|
|
/// </summary>
|
|
/// <param name="path">Pfad - beinhaltet bereits Anpassungen an Rollen</param>
|
|
/// <param name="foldertoCreate">Ordner in dem ein neuer Ordner angelegt werden soll</param>
|
|
/// <returns>FileManagerResponse</returns>
|
|
private FileManagerResponse CreateFolder(string path, string foldertoCreate)
|
|
{
|
|
var response = new FileManagerResponse();
|
|
|
|
var newFolder = foldertoCreate;
|
|
var (share, folder) = GetShareAndFolder(path);
|
|
if (!string.IsNullOrWhiteSpace(folder))
|
|
newFolder = $"{folder}/{foldertoCreate}";
|
|
|
|
try
|
|
{
|
|
var success = _fileShareService.CreateFolder(share, newFolder);
|
|
|
|
if (success)
|
|
{
|
|
var folderInfo = _fileShareService.GetFolderInfo(share, newFolder);
|
|
var folderCreatedInfo = new FileManagerDirectoryContent
|
|
{
|
|
Name = foldertoCreate,
|
|
FilterPath = null,
|
|
IsFile = false,
|
|
Size = 0,
|
|
DateModified = folderInfo.LastModified ?? DateTimeOffset.UtcNow,
|
|
DateCreated = folderInfo.LastModified ?? DateTimeOffset.UtcNow,
|
|
HasChild = folderInfo.HasSubfolders,
|
|
Type = "Directory"
|
|
};
|
|
var newData = new List<FileManagerDirectoryContent> { folderCreatedInfo };
|
|
response.Files = newData;
|
|
}
|
|
else
|
|
{
|
|
var error = new ErrorDetails { Code = "400", Message = $"A file or folder with the name {foldertoCreate} already exists." };
|
|
response.Error = error;
|
|
}
|
|
|
|
return response;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
var error = new ErrorDetails { Code = "400", Message = e.GetType().FullName + ", " + e.Message };
|
|
response.Error = error;
|
|
}
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Umbenennen einer Datei oder eines Ordners
|
|
/// </summary>
|
|
/// <param name="path">Pfad - beinhaltet bereits Anpassungen an Rollen</param>
|
|
/// <param name="name">Name</param>
|
|
/// <param name="newName">Neuer Name</param>
|
|
/// <param name="rootName">Root-Name der angezeigt werden soll</param>
|
|
/// <returns>FileManagerResponse</returns>
|
|
private FileManagerResponse Rename(string path, string name, string newName, string rootName)
|
|
{
|
|
var response = new FileManagerResponse();
|
|
|
|
var (share, folder) = GetShareAndFolder(path);
|
|
var (dirName, relativePath) = GetFolderNameAndRelativePath(folder, rootName);
|
|
|
|
var isFile = Path.HasExtension(name);
|
|
if (isFile)
|
|
{
|
|
var fileName = name;
|
|
if (!string.IsNullOrWhiteSpace(folder))
|
|
fileName = $"{folder}/{name}";
|
|
var newfileName = newName;
|
|
if (!string.IsNullOrWhiteSpace(folder))
|
|
newfileName = $"{folder}/{newName}";
|
|
|
|
var success = _fileShareService.RenameFile(share, fileName, newfileName, false);
|
|
if (success)
|
|
{
|
|
var fileInfo = _fileShareService.GetFileInfo(share, newfileName);
|
|
if (fileInfo != null)
|
|
{
|
|
var extension = Path.GetExtension(newfileName)?.ToLowerInvariant();
|
|
response.Files = new List<FileManagerDirectoryContent>
|
|
{
|
|
new()
|
|
{
|
|
Name = fileInfo.Name,
|
|
FilterPath = FolderToRelativePath(folder),
|
|
Size = fileInfo.Size,
|
|
Type = extension,
|
|
IsFile = true,
|
|
DateModified = fileInfo.LastModified ?? DateTimeOffset.UtcNow,
|
|
HasChild = false,
|
|
}
|
|
};
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var error = new ErrorDetails { Code = "400", Message = $"Can not rename file" };
|
|
response.Error = error;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var folderName = name;
|
|
if (!string.IsNullOrWhiteSpace(folder))
|
|
folderName = $"{folder}/{name}";
|
|
|
|
var newfolderName = newName;
|
|
if (!string.IsNullOrWhiteSpace(folder))
|
|
newfolderName = $"{folder}/{newName}";
|
|
|
|
var success = _fileShareService.RenameFolderEx(share, folderName, newfolderName, false);
|
|
if (success)
|
|
{
|
|
var folderInfo = _fileShareService.GetFolderInfo(share, newfolderName);
|
|
if (folderInfo != null)
|
|
{
|
|
response.Files = new List<FileManagerDirectoryContent>
|
|
{
|
|
new()
|
|
{
|
|
Name = folderInfo.Name,
|
|
FilterPath = relativePath,
|
|
Size = 0,
|
|
Type = "Directory",
|
|
IsFile = false,
|
|
DateModified = folderInfo.LastModified ?? DateTimeOffset.UtcNow,
|
|
HasChild = folderInfo.HasSubfolders,
|
|
}
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Kopieren von Daten
|
|
/// </summary>
|
|
/// <param name="path">Pfad - beinhaltet bereits Anpassungen an Rollen</param>
|
|
/// <param name="targetPath">Zielpfad</param>
|
|
/// <param name="names">Namen der Daten</param>
|
|
/// <returns>FileManagerResponse</returns>
|
|
private FileManagerResponse Copy(string path, string targetPath, List<string> names)
|
|
{
|
|
var response = new FileManagerResponse();
|
|
response.Files = new List<FileManagerDirectoryContent>();
|
|
|
|
var (share, folder) = GetShareAndFolder(path);
|
|
var (targetShare, targetFolder) = GetShareAndFolder(targetPath);
|
|
|
|
foreach (var name in names)
|
|
{
|
|
var isFile = Path.HasExtension(name);
|
|
if (isFile)
|
|
{
|
|
var fileName = name;
|
|
if (!string.IsNullOrWhiteSpace(folder))
|
|
fileName = $"{folder}/{name}";
|
|
|
|
var targetFileName = name;
|
|
if (!string.IsNullOrWhiteSpace(targetFolder))
|
|
targetFileName = $"{targetFolder}/{name}";
|
|
|
|
var success = _fileShareService.RenameFile(share, fileName, targetFileName, true);
|
|
if (success)
|
|
{
|
|
var fileInfo = _fileShareService.GetFileInfo(share, targetFileName);
|
|
if (fileInfo != null)
|
|
{
|
|
var extension = Path.GetExtension(targetFileName)?.ToLowerInvariant();
|
|
response.Files.Add(new FileManagerDirectoryContent()
|
|
{
|
|
Name = fileInfo.Name,
|
|
FilterPath = FolderToRelativePath(targetFolder),
|
|
Size = fileInfo.Size,
|
|
Type = extension,
|
|
IsFile = true,
|
|
DateModified = fileInfo.LastModified ?? DateTimeOffset.UtcNow,
|
|
HasChild = false,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var folderName = name;
|
|
if (!string.IsNullOrWhiteSpace(folder))
|
|
folderName = $"{folder}/{name}";
|
|
|
|
var targetFolderName = name;
|
|
if (!string.IsNullOrWhiteSpace(targetFolder))
|
|
targetFolderName = $"{targetFolder}/{name}";
|
|
|
|
var success = _fileShareService.RenameFolderEx(share, folderName, targetFolderName, true);
|
|
if (success)
|
|
{
|
|
var (dirName, relativePath) = GetFolderNameAndRelativePath(targetFolderName, "");
|
|
var folderInfo = _fileShareService.GetFolderInfo(share, targetFolderName);
|
|
if (folderInfo != null)
|
|
{
|
|
response.Files.Add(new FileManagerDirectoryContent()
|
|
{
|
|
Name = dirName,
|
|
FilterPath = relativePath,
|
|
Size = 0,
|
|
Type = "Directory",
|
|
IsFile = false,
|
|
DateModified = folderInfo.LastModified ?? DateTimeOffset.UtcNow,
|
|
DateCreated= DateTimeOffset.UtcNow,
|
|
HasChild = folderInfo.HasSubfolders
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verschieben von Daten
|
|
/// </summary>
|
|
/// <param name="path">Pfad - beinhaltet bereits Anpassungen an Rollen</param>
|
|
/// <param name="targetPath">Zielpfad</param>
|
|
/// <param name="names">Namen der Daten</param>
|
|
/// <returns>FileManagerResponse</returns>
|
|
private FileManagerResponse Move(string path, string targetPath, List<string> names)
|
|
{
|
|
var response = new FileManagerResponse();
|
|
response.Files = new List<FileManagerDirectoryContent>();
|
|
|
|
var (share, folder) = GetShareAndFolder(path);
|
|
var (targetShare, targetFolder) = GetShareAndFolder(targetPath);
|
|
|
|
foreach (var name in names)
|
|
{
|
|
var isFile = Path.HasExtension(name);
|
|
if (isFile)
|
|
{
|
|
var fileName = name;
|
|
if (!string.IsNullOrWhiteSpace(folder))
|
|
fileName = $"{folder}/{name}";
|
|
|
|
var targetFileName = name;
|
|
if (!string.IsNullOrWhiteSpace(targetFolder))
|
|
targetFileName = $"{targetFolder}/{name}";
|
|
|
|
var success = _fileShareService.RenameFile(share, fileName, targetFileName, false);
|
|
if (success)
|
|
{
|
|
var fileInfo = _fileShareService.GetFileInfo(share, targetFileName);
|
|
if (fileInfo != null)
|
|
{
|
|
var extension = Path.GetExtension(targetFileName)?.ToLowerInvariant();
|
|
response.Files.Add(new FileManagerDirectoryContent()
|
|
{
|
|
Name = fileInfo.Name,
|
|
FilterPath = FolderToRelativePath(targetFolder),
|
|
Size = fileInfo.Size,
|
|
Type = extension,
|
|
IsFile = true,
|
|
DateModified = fileInfo.LastModified ?? DateTimeOffset.UtcNow,
|
|
HasChild = false,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var folderName = name;
|
|
if (!string.IsNullOrWhiteSpace(folder))
|
|
folderName = $"{folder}/{name}";
|
|
|
|
var targetFolderName = name;
|
|
if (!string.IsNullOrWhiteSpace(targetFolder))
|
|
targetFolderName = $"{targetFolder}/{name}";
|
|
|
|
var success = _fileShareService.RenameFolderEx(share, folderName, targetFolderName, false);
|
|
if (success)
|
|
{
|
|
var (dirName, relativePath) = GetFolderNameAndRelativePath(targetFolderName, "");
|
|
var folderInfo = _fileShareService.GetFolderInfo(share, targetFolderName);
|
|
if (folderInfo != null)
|
|
{
|
|
response.Files.Add(new FileManagerDirectoryContent()
|
|
{
|
|
Name = dirName,
|
|
FilterPath = relativePath,
|
|
Size = 0,
|
|
Type = "Directory",
|
|
IsFile = false,
|
|
DateModified = folderInfo.LastModified ?? DateTimeOffset.UtcNow,
|
|
DateCreated = DateTimeOffset.UtcNow,
|
|
HasChild = folderInfo.HasSubfolders
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Löschen von Daten
|
|
/// </summary>
|
|
/// <param name="path">Pfad - beinhaltet bereits Anpassungen an Rollen</param>
|
|
/// <param name="names">Namen der Daten</param>
|
|
/// <returns>FileManagerResponse</returns>
|
|
private FileManagerResponse Delete(string path, List<string> names)
|
|
{
|
|
var response = new FileManagerResponse();
|
|
response.Files = new List<FileManagerDirectoryContent>();
|
|
|
|
var (share, folder) = GetShareAndFolder(path);
|
|
|
|
foreach (var name in names)
|
|
{
|
|
var isFile = Path.HasExtension(name);
|
|
if (isFile)
|
|
{
|
|
var fileName = name;
|
|
if (!string.IsNullOrWhiteSpace(folder))
|
|
fileName = $"{folder}/{name}";
|
|
|
|
var fileInfo = _fileShareService.GetFileInfo(share, fileName);
|
|
if (fileInfo != null)
|
|
{
|
|
var success = _fileShareService.DeleteFile(share, fileName);
|
|
if (success)
|
|
{
|
|
var extension = Path.GetExtension(fileName)?.ToLowerInvariant();
|
|
response.Files.Add(new FileManagerDirectoryContent()
|
|
{
|
|
Name = fileInfo.Name,
|
|
Size = fileInfo.Size,
|
|
Type = extension,
|
|
IsFile = true,
|
|
DateModified = fileInfo.LastModified ?? DateTimeOffset.UtcNow,
|
|
HasChild = false,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var folderName = name;
|
|
if (!string.IsNullOrWhiteSpace(folder))
|
|
folderName = $"{folder}/{name}";
|
|
|
|
var folderInfo = _fileShareService.GetFolderInfo(share, folderName);
|
|
if (folderInfo != null)
|
|
{
|
|
var success = _fileShareService.DeleteFolder(share, folderName);
|
|
if (success)
|
|
{
|
|
response.Files.Add(new FileManagerDirectoryContent()
|
|
{
|
|
Name = folderInfo.Name,
|
|
Size = 0,
|
|
Type = "Directory",
|
|
IsFile = false,
|
|
DateModified = folderInfo.LastModified ?? DateTimeOffset.UtcNow,
|
|
HasChild = folderInfo.HasSubfolders,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Details von Daten anzeigen
|
|
/// </summary>
|
|
/// <param name="path">Pfad - beinhaltet bereits Anpassungen an Rollen</param>
|
|
/// <param name="names">Namen der Daten</param>
|
|
/// <returns>FileManagerResponse</returns>
|
|
private FileManagerResponse Details(string path, List<string> names)
|
|
{
|
|
var response = new FileManagerResponse();
|
|
|
|
var details = new FileDetails();
|
|
|
|
var (share, folder) = GetShareAndFolder(path);
|
|
|
|
var size = 0L;
|
|
var fileCount = 0;
|
|
var dirCount = 0;
|
|
var detailsName = string.Empty;
|
|
|
|
foreach (var name in names)
|
|
{
|
|
var isFile = Path.HasExtension(name);
|
|
if (isFile)
|
|
{
|
|
fileCount += 1;
|
|
var fileName = name;
|
|
if (!string.IsNullOrWhiteSpace(folder))
|
|
fileName = $"{folder}/{name}";
|
|
|
|
var fileInfo = _fileShareService.GetFileInfo(share, fileName);
|
|
if (fileInfo != null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(detailsName))
|
|
detailsName = fileInfo.Name;
|
|
else
|
|
detailsName += $", {fileInfo.Name}";
|
|
size += fileInfo.Size;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dirCount += 1;
|
|
var folderName = name;
|
|
if (!string.IsNullOrWhiteSpace(folder))
|
|
folderName = $"{folder}/{name}";
|
|
|
|
var folderInfo = _fileShareService.GetFolderInfo(share, folderName);
|
|
if (folderInfo != null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(detailsName))
|
|
detailsName = folderInfo.Name;
|
|
else
|
|
detailsName += $", {folderInfo.Name}";
|
|
size += _fileShareService.GetFolderSize(share, folderName);
|
|
}
|
|
}
|
|
}
|
|
|
|
details.Name = detailsName;
|
|
details.Size = GetByteSizeString(size);
|
|
details.IsFile = fileCount > 0 && dirCount == 0;
|
|
details.MultipleFiles = fileCount > 0 || dirCount == 0;
|
|
details.Location = folder != "" ? folder : share;
|
|
response.Details = details;
|
|
return response;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Helper
|
|
|
|
/// <summary>
|
|
/// Holt den Share-Namen und den Ordner aus dem Pfad
|
|
/// </summary>
|
|
/// <param name="path">Pfad</param>
|
|
/// <returns>share,folder</returns>
|
|
private (string, string) GetShareAndFolder(string path)
|
|
{
|
|
path = path.ToLowerInvariant();
|
|
var pathParts = path.Split('/');
|
|
var share = pathParts[0];
|
|
var folder = path.Replace(share, "");
|
|
folder = folder.Trim('/');
|
|
return (share, folder);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gibt zu einem Ordner den Namen und den relativen Pfad zurück
|
|
/// </summary>
|
|
/// <param name="folder">Ordner</param>
|
|
/// <param name="rootName">rootname</param>
|
|
/// <returns>name,relativePath</returns>
|
|
private (string, string) GetFolderNameAndRelativePath(string folder, string rootName)
|
|
{
|
|
folder = folder.ToLowerInvariant();
|
|
var dirName = rootName;
|
|
var relativePath = "";
|
|
if (!string.IsNullOrWhiteSpace(folder))
|
|
{
|
|
var folders = folder.Split("/");
|
|
dirName = folders.Last();
|
|
relativePath = "/";
|
|
if (folders.Length > 1)
|
|
{
|
|
relativePath += folder.Replace(dirName, "");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
relativePath = "/";
|
|
}
|
|
|
|
return (dirName, relativePath);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Konvertiert einen Ordner-Pfad in einen Relativen-Pfad
|
|
/// </summary>
|
|
/// <param name="folder">Order</param>
|
|
/// <returns>Relativer Pfad</returns>
|
|
private string FolderToRelativePath(string folder)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(folder))
|
|
return "/";
|
|
else
|
|
return $"/{folder}/";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gibt den Mimetype einer Datei zurück
|
|
/// </summary>
|
|
/// <param name="fileName">Dateiname</param>
|
|
/// <returns>Mimetype</returns>
|
|
private string GetMimeMapping(string fileName)
|
|
{
|
|
new FileExtensionContentTypeProvider().TryGetContentType(fileName, out var contentType);
|
|
return contentType ?? "application/octet-stream";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gibt eine Dateigröße in Bytes, KB oder MB usw. zurück
|
|
/// </summary>
|
|
/// <param name="fileSize">Größe in bytes</param>
|
|
/// <returns>Umgerechnete Größe als String</returns>
|
|
private string GetByteSizeString(long fileSize)
|
|
{
|
|
try
|
|
{
|
|
string[] index = { "B", "KB", "MB", "GB", "TB", "PB", "EB" }; //Longs run out around EB
|
|
if (fileSize == 0)
|
|
{
|
|
return "0 " + index[0];
|
|
}
|
|
|
|
var bytes = Math.Abs(fileSize);
|
|
var loc = Convert.ToInt32(Math.Floor(Math.Log(bytes, 1024)));
|
|
var num = Math.Round(bytes / Math.Pow(1024, loc), 1);
|
|
return (Math.Sign(fileSize) * num).ToString(CultureInfo.InvariantCulture) + " " + index[loc];
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
|
|
#region Helper-Classes
|
|
|
|
public class FileManagerDirectoryContent
|
|
{
|
|
public string Path { get; set; }
|
|
|
|
public string Action { get; set; }
|
|
|
|
public string NewName { get; set; }
|
|
|
|
public string[] Names { get; set; }
|
|
|
|
public string Name { get; set; }
|
|
|
|
public long Size { get; set; }
|
|
|
|
public string PreviousName { get; set; }
|
|
|
|
public DateTimeOffset DateModified { get; set; }
|
|
|
|
public DateTimeOffset DateCreated { get; set; }
|
|
|
|
public bool HasChild { get; set; }
|
|
|
|
public bool IsFile { get; set; }
|
|
|
|
public string Type { get; set; }
|
|
|
|
public string Id { get; set; }
|
|
|
|
public string FilterPath { get; set; }
|
|
|
|
public string FilterId { get; set; }
|
|
|
|
public string ParentId { get; set; }
|
|
|
|
public string TargetPath { get; set; }
|
|
|
|
public string[] RenameFiles { get; set; }
|
|
|
|
public IList<IFormFile> UploadFiles { get; set; }
|
|
|
|
public bool CaseSensitive { get; set; }
|
|
|
|
public string SearchString { get; set; }
|
|
|
|
public bool ShowHiddenItems { get; set; }
|
|
|
|
public FileManagerDirectoryContent[] Data { get; set; }
|
|
|
|
public FileManagerDirectoryContent TargetData { get; set; }
|
|
|
|
public AccessPermission Permission { get; set; }
|
|
|
|
/// <summary>
|
|
/// Optional - Rootpath der nach den internen Regeln angewendet werden soll
|
|
/// </summary>
|
|
public string Rp { get; set; }
|
|
}
|
|
|
|
public class AccessPermission
|
|
{
|
|
public bool Copy = true;
|
|
public bool Download = true;
|
|
public bool Write = true;
|
|
public bool WriteContents = true;
|
|
public bool Read = true;
|
|
public bool Upload = true;
|
|
public string Message = String.Empty;
|
|
}
|
|
|
|
public class FileManagerResponse
|
|
{
|
|
public FileManagerDirectoryContent CWD { get; set; }
|
|
public List<FileManagerDirectoryContent> Files { get; set; }
|
|
|
|
public ErrorDetails Error { get; set; }
|
|
|
|
public FileDetails Details { get; set; }
|
|
|
|
}
|
|
|
|
public class ErrorDetails
|
|
{
|
|
|
|
public string Code { get; set; }
|
|
|
|
public string Message { get; set; }
|
|
|
|
public IEnumerable<string> FileExists { get; set; }
|
|
}
|
|
|
|
public class FileDetails
|
|
{
|
|
public string Name { get; set; }
|
|
public string Location { get; set; }
|
|
public bool IsFile { get; set; }
|
|
public string Size { get; set; }
|
|
public DateTime Created { get; set; }
|
|
public DateTime Modified { get; set; }
|
|
public bool MultipleFiles { get; set; }
|
|
public AccessPermission Permission { get; set; }
|
|
}
|
|
|
|
#endregion
|
|
}
|