Webiant Logo Webiant Logo
  1. No results found.

    Try your search with a different keyword or use * as a wildcard.

INopFileProvider.cs

using System.Security.AccessControl;
using System.Text;
using Microsoft.Extensions.FileProviders;

namespace Nop.Core.Infrastructure;

/// 
/// A file provider abstraction
/// 
public partial interface INopFileProvider : IFileProvider
{
    /// 
    /// Combines an array of strings into a path
    /// 
    /// An array of parts of the path
    /// The combined paths
    string Combine(params string[] paths);

    /// 
    /// Creates all directories and subdirectories in the specified path unless they already exist
    /// 
    /// The directory to create
    void CreateDirectory(string path);

    /// 
    /// Creates a file in the specified path
    /// 
    /// The path and name of the file to create
    void CreateFile(string path);

    /// 
    /// Depth-first recursive delete, with handling for descendant directories open in Windows Explorer.
    /// 
    /// Directory path
    void DeleteDirectory(string path);

    /// 
    /// Deletes the specified file
    /// 
    /// The name of the file to be deleted. Wildcard characters are not supported
    void DeleteFile(string filePath);

    /// 
    /// Determines whether the given path refers to an existing directory on disk
    /// 
    /// The path to test
    /// 
    /// true if path refers to an existing directory; false if the directory does not exist or an error occurs when
    /// trying to determine if the specified file exists
    /// 
    bool DirectoryExists(string path);

    /// 
    /// Moves a file or a directory and its contents to a new location
    /// 
    /// The path of the file or directory to move
    /// 
    /// The path to the new location for sourceDirName. If sourceDirName is a file, then destDirName
    /// must also be a file name
    /// 
    void DirectoryMove(string sourceDirName, string destDirName);

    /// 
    /// Returns an enumerable collection of file names that match a search pattern in
    /// a specified path, and optionally searches subdirectories.
    /// 
    /// The path to the directory to search
    /// 
    /// The search string to match against the names of files in path. This parameter
    /// can contain a combination of valid literal path and wildcard (* and ?) characters
    /// , but doesn't support regular expressions.
    /// 
    /// 
    /// Specifies whether to search the current directory, or the current directory and all
    /// subdirectories
    /// 
    /// 
    /// An enumerable collection of the full names (including paths) for the files in
    /// the directory specified by path and that match the specified search pattern
    /// 
    IEnumerable EnumerateFiles(string directoryPath, string searchPattern, bool topDirectoryOnly = true);

    /// 
    /// Copies an existing file to a new file. Overwriting a file of the same name is allowed
    /// 
    /// The file to copy
    /// The name of the destination file. This cannot be a directory
    /// true if the destination file can be overwritten; otherwise, false
    void FileCopy(string sourceFileName, string destFileName, bool overwrite = false);

    /// 
    /// Determines whether the specified file exists
    /// 
    /// The file to check
    /// 
    /// True if the caller has the required permissions and path contains the name of an existing file; otherwise,
    /// false.
    /// 
    bool FileExists(string filePath);

    /// 
    /// Gets the length of the file in bytes, or -1 for a directory or non-existing files
    /// 
    /// File path
    /// The length of the file
    long FileLength(string path);

    /// 
    /// Moves a specified file to a new location, providing the option to specify a new file name
    /// 
    /// The name of the file to move. Can include a relative or absolute path
    /// The new path and name for the file
    void FileMove(string sourceFileName, string destFileName);

    /// 
    /// Returns the absolute path to the directory
    /// 
    /// An array of parts of the path
    /// The absolute path to the directory
    string GetAbsolutePath(params string[] paths);

    /// 
    /// Gets a System.Security.AccessControl.DirectorySecurity object that encapsulates the access control list (ACL) entries for a specified directory
    /// 
    /// The path to a directory containing a System.Security.AccessControl.DirectorySecurity object that describes the file's access control list (ACL) information
    /// An object that encapsulates the access control rules for the file described by the path parameter
    DirectorySecurity GetAccessControl(string path);

    /// 
    /// Returns the creation date and time of the specified file or directory
    /// 
    /// The file or directory for which to obtain creation date and time information
    /// 
    /// A System.DateTime structure set to the creation date and time for the specified file or directory. This value
    /// is expressed in local time
    /// 
    DateTime GetCreationTime(string path);

    /// 
    /// Returns the names of the subdirectories (including their paths) that match the
    /// specified search pattern in the specified directory
    /// 
    /// The path to the directory to search
    /// 
    /// The search string to match against the names of subdirectories in path. This
    /// parameter can contain a combination of valid literal and wildcard characters
    /// , but doesn't support regular expressions.
    /// 
    /// 
    /// Specifies whether to search the current directory, or the current directory and all
    /// subdirectories
    /// 
    /// 
    /// An array of the full names (including paths) of the subdirectories that match
    /// the specified criteria, or an empty array if no directories are found
    /// 
    string[] GetDirectories(string path, string searchPattern = "", bool topDirectoryOnly = true);

    /// 
    /// Returns the directory information for the specified path string
    /// 
    /// The path of a file or directory
    /// 
    /// Directory information for path, or null if path denotes a root directory or is null. Returns
    /// System.String.Empty if path does not contain directory information
    /// 
    string GetDirectoryName(string path);

    /// 
    /// Returns the directory name only for the specified path string
    /// 
    /// The path of directory
    /// The directory name
    string GetDirectoryNameOnly(string path);

    /// 
    /// Returns the extension of the specified path string
    /// 
    /// The path string from which to get the extension
    /// The extension of the specified path (including the period ".")
    string GetFileExtension(string filePath);

    /// 
    /// Returns the file name and extension of the specified path string
    /// 
    /// The path string from which to obtain the file name and extension
    /// The characters after the last directory character in path
    string GetFileName(string path);

    /// 
    /// Returns the file name of the specified path string without the extension
    /// 
    /// The path of the file
    /// The file name, minus the last period (.) and all characters following it
    string GetFileNameWithoutExtension(string filePath);

    /// 
    /// Returns the names of files (including their paths) that match the specified search
    /// pattern in the specified directory, using a value to determine whether to search subdirectories.
    /// 
    /// The path to the directory to search
    /// 
    /// The search string to match against the names of files in path. This parameter
    /// can contain a combination of valid literal path and wildcard (* and ?) characters
    /// , but doesn't support regular expressions.
    /// 
    /// 
    /// Specifies whether to search the current directory, or the current directory and all
    /// subdirectories
    /// 
    /// 
    /// An array of the full names (including paths) for the files in the specified directory
    /// that match the specified search pattern, or an empty array if no files are found.
    /// 
    string[] GetFiles(string directoryPath, string searchPattern = "", bool topDirectoryOnly = true);

    /// 
    /// Returns the date and time the specified file or directory was last accessed
    /// 
    /// The file or directory for which to obtain access date and time information
    /// A System.DateTime structure set to the date and time that the specified file
    DateTime GetLastAccessTime(string path);

    /// 
    /// Returns the date and time the specified file or directory was last written to
    /// 
    /// The file or directory for which to obtain write date and time information
    /// 
    /// A System.DateTime structure set to the date and time that the specified file or directory was last written to.
    /// This value is expressed in local time
    /// 
    DateTime GetLastWriteTime(string path);

    /// 
    /// Returns the date and time, in coordinated universal time (UTC), that the specified file or directory was last
    /// written to
    /// 
    /// The file or directory for which to obtain write date and time information
    /// 
    /// A System.DateTime structure set to the date and time that the specified file or directory was last written to.
    /// This value is expressed in UTC time
    /// 
    DateTime GetLastWriteTimeUtc(string path);

    /// 
    /// Creates or opens a file at the specified path for read/write access
    /// 
    /// The path and name of the file to create
    /// A  that provides read/write access to the file specified in 
    FileStream GetOrCreateFile(string path);

    /// 
    /// Retrieves the parent directory of the specified path
    /// 
    /// The path for which to retrieve the parent directory
    /// The parent directory, or null if path is the root directory, including the root of a UNC server or share name
    string GetParentDirectory(string directoryPath);

    /// 
    /// Gets a virtual path from a physical disk path.
    /// 
    /// The physical disk path
    /// The virtual path. E.g. "~/bin"
    string GetVirtualPath(string path);

    /// 
    /// Checks if the path is directory
    /// 
    /// Path for check
    /// True, if the path is a directory, otherwise false
    bool IsDirectory(string path);

    /// 
    /// Maps a virtual path to a physical disk path.
    /// 
    /// The path to map. E.g. "~/bin"
    /// The physical path. E.g. "c:\inetpub\wwwroot\bin"
    string MapPath(string path);

    /// 
    /// Reads the contents of the file into a byte array
    /// 
    /// The file for reading
    /// 
    /// A task that represents the asynchronous operation
    /// The task result contains a byte array containing the contents of the file
    /// 
    Task ReadAllBytesAsync(string filePath);

    /// 
    /// Opens a file, reads all lines of the file with the specified encoding, and then closes the file.
    /// 
    /// The file to open for reading
    /// The encoding applied to the contents of the file
    /// 
    /// A task that represents the asynchronous operation
    /// The task result contains a string containing all lines of the file
    /// 
    Task ReadAllTextAsync(string path, Encoding encoding);

    /// 
    /// Opens a file, reads all lines of the file with the specified encoding, and then closes the file.
    /// 
    /// The file to open for reading
    /// The encoding applied to the contents of the file
    /// A string containing all lines of the file
    string ReadAllText(string path, Encoding encoding);

    /// 
    /// Writes the specified byte array to the file
    /// 
    /// The file to write to
    /// The bytes to write to the file
    /// A task that represents the asynchronous operation
    Task WriteAllBytesAsync(string filePath, byte[] bytes);

    /// 
    /// Creates a new file, writes the specified string to the file using the specified encoding,
    /// and then closes the file. If the target file already exists, it is overwritten.
    /// 
    /// The file to write to
    /// The string to write to the file
    /// The encoding to apply to the string
    /// A task that represents the asynchronous operation
    Task WriteAllTextAsync(string path, string contents, Encoding encoding);

    /// 
    /// Creates a new file, writes the specified string to the file using the specified encoding,
    /// and then closes the file. If the target file already exists, it is overwritten.
    /// 
    /// The file to write to
    /// The string to write to the file
    /// The encoding to apply to the string
    void WriteAllText(string path, string contents, Encoding encoding);

    /// 
    /// Gets or sets the absolute path to the directory that contains the web-servable application content files.
    /// 
    string WebRootPath { get; }
}