BadOpenKmFileSystem.cs

Go to the documentation of this file.

using BadScript2.IO.Virtual;
 
using ewu.adam.openkm.rest;
using ewu.adam.openkm.rest.Bean;
 
namespace BadScript2.IO.OpenKM;
 
public class BadOpenKmFileSystem : IFileSystem
{
    private readonly IOkmWebservice m_Webservice;
 
    private Folder m_Current;
 
    private string? m_StartupDirectory;
 
    public BadOpenKmFileSystem(IOkmWebservice webService)
    {
        m_Webservice = webService;
 
        m_Current = m_Webservice.GetFolderProperties(GetStartupDirectory())
                                .Result;
    }
 
    public BadOpenKmFileSystem(string url, string user, string password) :
        this(OkmWebserviceFactory.NewInstance(url, user, password)) { }
 
#region IFileSystem Members
 
    public string GetStartupDirectory()
    {
        return m_StartupDirectory ??= m_Webservice.GetPersonalFolder()
                                                  .Result.path;
    }
 
    public bool Exists(string path)
    {
        return m_Webservice.HasNode(MakeFullPath(path))
                           .Result;
    }
 
    public bool IsFile(string path)
    {
        return m_Webservice.IsValidDocument(MakeFullPath(path))
                           .Result;
    }
 
    public bool IsDirectory(string path)
    {
        return m_Webservice.IsValidFolder(MakeFullPath(path))
                           .Result;
    }
 
    public IEnumerable<string> GetFiles(string path, string extension, bool recursive)
    {
        path = MakeFullPath(path);
 
        return recursive ? InnerGetFilesRecursive(path, extension) : InnerGetFiles(path, extension);
    }
 
    public IEnumerable<string> GetDirectories(string path, bool recursive)
    {
        path = MakeFullPath(path);
 
        return recursive ? InnerGetDirectoriesRecursive(path) : InnerGetDirectories(path);
    }
 
    public void CreateDirectory(string path, bool recursive = false)
    {
        path = MakeFullPath(path);
 
        if (recursive)
        {
            InnerCreateDirectoryRecursive(path);
        }
        else
        {
            InnerCreateDirectory(path);
        }
    }
 
    public void DeleteDirectory(string path, bool recursive)
    {
        path = MakeFullPath(path);
 
        if (!Exists(path))
        {
            throw new Exception("Directory does not exist.");
        }
 
        if (!recursive && HasChildren(path))
        {
            throw new Exception("Directory is not empty.");
        }
 
        m_Webservice.DeleteFolder(path)
                    .Wait();
    }
 
    public void DeleteFile(string path)
    {
        path = MakeFullPath(path);
 
        if (!IsFile(path))
        {
            throw new Exception("File does not exist.");
        }
 
        m_Webservice.DeleteDocument(path)
                    .Wait();
    }
 
    public string GetFullPath(string path)
    {
        return MakeFullPath(path);
    }
 
    public Stream OpenRead(string path)
    {
        Stream result = m_Webservice.GetContent(MakeFullPath(path))
                                    .Result;
 
        return result;
    }
 
    public Stream OpenWrite(string path, BadWriteMode mode)
    {
        return new BadOpenKmWritableStream(m_Webservice, MakeFullPath(path), mode);
    }
 
    public string GetCurrentDirectory()
    {
        return m_Current.path;
    }
 
    public void SetCurrentDirectory(string path)
    {
        m_Current = m_Webservice.GetFolderProperties(MakeFullPath(path))
                                .Result;
    }
 
    public void Copy(string src, string dst, bool overwrite = true)
    {
        src = MakeFullPath(src);
        dst = MakeFullPath(dst);
 
        if (!Exists(src))
        {
            throw new Exception("Source does not exist");
        }
 
        if (IsDirectory(src))
        {
            throw new
                NotSupportedException("At the moment, copying directories is not supported. (need to implement recursive move files)"
                                     );
        }
 
        if (!Exists(dst))
        {
            throw new Exception("Target directory does not exist");
        }
 
        string dstFile = MakeFullPath(Path.Combine(dst, Path.GetFileName(src)));
 
        if (Exists(dstFile))
        {
            if (!IsFile(dstFile))
            {
                throw new Exception("Target file is a directory");
            }
 
            if (!overwrite)
            {
                throw new Exception("Target already exists");
            }
 
            m_Webservice.DeleteDocument(dstFile)
                        .Wait();
        }
 
        m_Webservice.CopyDocument(src, dst)
                    .Wait();
    }
 
    public void Move(string src, string dst, bool overwrite = true)
    {
        src = MakeFullPath(src);
        dst = MakeFullPath(dst);
 
        if (!Exists(src))
        {
            throw new Exception("Source does not exist");
        }
 
        if (IsDirectory(src))
        {
            throw new
                NotSupportedException("At the moment, moving directories is not supported. (need to implement recursive move files)"
                                     );
        }
 
        if (!Exists(dst))
        {
            throw new Exception("Target directory does not exist");
        }
 
        string dstFile = MakeFullPath(Path.Combine(dst, Path.GetFileName(src)));
 
        if (Exists(dstFile))
        {
            if (!IsFile(dstFile))
            {
                throw new Exception("Target file is a directory");
            }
 
            if (!overwrite)
            {
                throw new Exception("Target already exists");
            }
 
            m_Webservice.DeleteDocument(dstFile)
                        .Wait();
        }
 
        m_Webservice.MoveDocument(src, dst)
                    .Wait();
    }
 
#endregion
 
    private string MakeFullPath(string path)
    {
        string full = BadVirtualPathReader.ResolvePath(path, GetCurrentDirectory());
 
        return full;
    }
 
    private bool HasChildren(string path)
    {
        return m_Webservice.GetFolderChildren(path)
                           .Result.folder.Count >
               0 ||
               m_Webservice.GetDocumentChildren(path)
                           .Result.document.Count >
               0;
    }
 
    private IEnumerable<string> InnerGetDirectories(string path)
    {
        FolderList? current = m_Webservice.GetFolderChildren(path)
                                          .Result;
 
        return current == null ? Enumerable.Empty<string>() : current.folder.Select(x => x.path);
    }
 
    private IEnumerable<string> InnerGetFiles(string path, string extension)
    {
        DocumentList? current = m_Webservice.GetDocumentChildren(path)
                                            .Result;
 
        if (current == null)
        {
            yield break;
        }
 
        foreach (Document document in current.document)
        {
            string ext = Path.GetExtension(document.path);
 
            if (string.IsNullOrEmpty(extension) || ext == extension)
            {
                yield return document.path;
            }
        }
    }
 
    private IEnumerable<string> InnerGetDirectoriesRecursive(string path)
    {
        foreach (string dir in InnerGetDirectories(path))
        {
            yield return dir;
 
            foreach (string innerDir in InnerGetDirectoriesRecursive(dir))
            {
                yield return innerDir;
            }
        }
    }
 
    private IEnumerable<string> InnerGetFilesRecursive(string path, string extension)
    {
        foreach (string file in InnerGetFiles(path, extension))
        {
            yield return file;
        }
 
        foreach (string directory in InnerGetDirectories(path))
        {
            foreach (string file in InnerGetFilesRecursive(directory, extension))
            {
                yield return file;
            }
        }
    }
 
 
    private void InnerCreateDirectoryRecursive(string path)
    {
        if (IsDirectory(path))
        {
            return;
        }
 
        string? parent = Path.GetDirectoryName(path);
 
        if (parent != null)
        {
            InnerCreateDirectoryRecursive(parent);
        }
 
        InnerCreateDirectory(path);
    }
 
    private void InnerCreateDirectory(string path)
    {
        m_Webservice.CreateFolderSimple(path)
                    .Wait();
    }
}