Beispiel #1
0
        /// <summary>
        /// Executes file at specified path.
        /// </summary>
        /// <param name="manager"></param>
        /// <param name="path">Path to file with fake root.</param>
        /// <returns></returns>
        private bool Exec(IManipulatorsManager manager, string path)
        {
            var c    = manager.GetContext <FileSystemContext>();
            var root = c.Roots.Find(GetRoot(path));

            if (root == null)
            {
                return(false);
            }

            var pathOrig = root.ToActualPath(path);

            if (!File.Exists(pathOrig))
            {
                return(false);
            }

            if (!string.IsNullOrWhiteSpace(c.FileSearchPattern))
            {
                // Check if file matches search pattern:
                var dir   = Directory.GetParent(pathOrig);
                var files = dir.GetFiles(c.FileSearchPattern).Select(x => x.FullName.ToLowerInvariant());
                if (!files.Contains(pathOrig.ToLowerInvariant()))
                {
                    return(false);
                }
            }

            // Check if folders filter allows that file containing folder.
            if (c.FolderFilter?.Invoke(Directory.GetParent(pathOrig)?.FullName) == false)
            {
                return(false);
            }

            // Check if file filter allows that file.
            if (c.FileFilter?.Invoke(pathOrig) == false)
            {
                return(false);
            }

            try
            {
                var process = new Process
                {
                    StartInfo = new ProcessStartInfo
                    {
                        UseShellExecute = true,
                        FileName        = pathOrig
                    }
                };
                process.Start();
                return(true);
            }
            catch
            {
                // ignored
            }

            return(false);
        }
Beispiel #2
0
        /// <inheritdoc />
        public object Execute(IManipulatorsManager manager, string param)
        {
            var context = manager.GetContext <T>();

            return(context != null &&
                   _action.Invoke(context, param));
        }
Beispiel #3
0
        /// <summary>
        /// Enumerates content of specified directory.
        /// </summary>
        /// <param name="manager"></param>
        /// <param name="param">Path to directory with fake root.</param>
        /// <returns></returns>
        private IReadOnlyDictionary <string, IEnumerable <string> > List(IManipulatorsManager manager, string param)
        {
            var c  = manager.GetContext <FileSystemContext>();
            var rv = new Dictionary <string, IEnumerable <string> >();

            if (c?.Roots?.Any() != true)
            {
                return(null);
            }

            if (string.IsNullOrWhiteSpace(param))
            {
                if (c.Roots.Count == 1)
                {
                    PopulateContent(rv, c, c.Roots[0].Path);
                }
                else
                {
                    rv["folders"] = c.Roots.Select(x => x.Name).ToArray();
                }

                return(rv);
            }

            PopulateContent(rv, c, param);

            return(rv.Any() ? rv : null);
        }