/// <summary>
        /// Deletes the specified file.
        /// </summary>
        /// <param name="file">The file to delete.</param>
        /// <exception cref="AccessException">The file could not be accessed.</exception>
        public void DeleteFile(IFileInfo file)
        {
            file.ThrowIfNull(() => file);

            if (!(file is LocalFileInfo))
                throw new ArgumentException("The file must be of type LocalFileInfo.", "file");

            try
            {
                File.SetAttributes(file.FullName, FileAttributes.Normal);
                File.Delete(file.FullName);
            }

            catch (IOException ex)
            {
                throw new AccessException("The file could not be accessed.", ex);
            }

            catch (SecurityException ex)
            {
                throw new AccessException("The file could not be accessed.", ex);
            }

            catch (UnauthorizedAccessException ex)
            {
                throw new AccessException("The file could not be accessed.", ex);
            }
        }

        public bool IsFileAValidModification(IFileInfo file, IProject baseProject, IProject sourceProject, List<string> warnings, List<FileReleaseInfo> releases)
        {
            if (FileIsDeletedItem(file))
                return false;

            if (FileIsSharedResx(file))
            {
                var baseFile = baseProject.Drive.GetFileInfo(file.Url);
                var sourceFile = sourceProject.Drive.GetFileInfo(file.Url);
                ResxDifferences changes = ResxDiffMerge.CompareResxFiles(sourceFile, baseFile);
                if (changes.None)
                    return false;
            }

            if (FileIsRelationship(file))
            {
                Guid sourceId = GetModelItemIdFromFile(file);
                if (sourceId == Guid.Empty)
                    return true;

                OrmRelationship baseRelationship = FindRelationshipInBaseById(sourceId, baseProject);
                if (baseRelationship != null)
                {
                    var sourceRelationship = sourceProject.Get<OrmRelationship>(file.Url);
                    var diffMerge = new ObjectDiffMerge();
                    var changes = diffMerge.CompareObjects(sourceRelationship, baseRelationship);
                    if (!changes.All(change => RelationshipChangeCanBeIgnored(change)))
                        warnings.Add(string.Format("{0} is an existing SalesLogix relationship that was renamed and also modified.  This file will need to be manually merged.", file.Url));

                    return false;
                }
            }

            return true;
        }

        public static void Save(IFileInfo File, string Key, string Content)
        {
            ContentItem item;
            if (File.ContentItemID == Null.NullInteger)
            {
                item = CreateFileContentItem();
                File.ContentItemID = item.ContentItemId;
            }
            else
            {
                item = Util.GetContentController().GetContentItem(File.ContentItemID);
            }
            JObject obj;
            if (string.IsNullOrEmpty(item.Content))
                obj = new JObject();
            else
                obj = JObject.Parse(item.Content);

            if (string.IsNullOrEmpty(Content))
                obj[Key] = new JObject();
            else
                obj[Key] = JObject.Parse(Content);

            item.Content = obj.ToString();
            Util.GetContentController().UpdateContentItem(item);

            FileManager.Instance.UpdateFile(File);
        }

        /// <summary>
        /// Initializes a new instance of the
        /// <see cref="CmisSync.Lib.Storage.Database.Entities.FileTransmissionObject"/> class.
        /// </summary>
        /// <param name="type">Type of transmission.</param>
        /// <param name="localFile">Local file.</param>
        /// <param name="remoteFile">Remote file.</param>
        public FileTransmissionObject(TransmissionType type, IFileInfo localFile, IDocument remoteFile) {
            if (localFile == null) {
                throw new ArgumentNullException("localFile");
            }

            if (!localFile.Exists) {
                throw new ArgumentException(string.Format("'{0} file does not exist", localFile.FullName), "localFile");
            }

            if (remoteFile == null) {
                throw new ArgumentNullException("remoteFile");
            }

            if (remoteFile.Id == null) {
                throw new ArgumentNullException("remoteFile.Id");
            }

            if (string.IsNullOrEmpty(remoteFile.Id)) {
                throw new ArgumentException("empty string", "remoteFile.Id");
            }

            this.Type = type;
            this.LocalPath = localFile.FullName;
            this.LastContentSize = localFile.Length;
            this.LastLocalWriteTimeUtc = localFile.LastWriteTimeUtc;
            this.RemoteObjectId = remoteFile.Id;
            this.LastChangeToken = remoteFile.ChangeToken;
            this.RemoteObjectPWCId = remoteFile.VersionSeriesCheckedOutId;
            this.LastRemoteWriteTimeUtc = remoteFile.LastModificationDate;
            if (this.LastRemoteWriteTimeUtc != null) {
                this.LastRemoteWriteTimeUtc = this.LastRemoteWriteTimeUtc.GetValueOrDefault().ToUniversalTime();
            }
        }

        public async Task<CompilationResult> Compile(IFileInfo fileInfo)
        {
            Directory.CreateDirectory(_tempDir);
            string outFile = Path.Combine(_tempDir, Path.GetRandomFileName() + ".dll");
            StringBuilder args = new StringBuilder("/target:library ");
            args.AppendFormat("/out:\"{0}\" ", outFile);
            foreach (var file in  Directory.EnumerateFiles(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "*.dll"))
            {
                args.AppendFormat("/R:\"{0}\" ", file);
            }
            args.AppendFormat("\"{0}\"", fileInfo.PhysicalPath);
            var outputStream = new MemoryStream();

            // common execute
            var process = CreateProcess(args.ToString());
            int exitCode = await Start(process, outputStream);

            string output = GetString(outputStream);
            if (exitCode != 0)
            {
                IEnumerable<CompilationMessage> messages = output.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries)
                                                                 .Skip(3)
                                                                 .Select(e => new CompilationMessage(e));
                return CompilationResult.Failed(String.Empty, messages);
            }

            var type = Assembly.LoadFrom(outFile)
                               .GetExportedTypes()
                               .First();
            return CompilationResult.Successful(String.Empty, type);
        }

 public FileProjectItem(string kind, IFileInfo fileInfo, IFileSystem fileSystem, PathInfo subPath) 
     : base(subPath.ToString(), kind)
 {
     _subPath = subPath;
     _fileSystem = fileSystem;
     FileInfo = fileInfo;
 }

        public bool IsFileAValidAddition(IFileInfo file, IProject baseProject, IProject sourceProject, List<string> warnings)
        {
            if (FileIsOrderCollection(file))
                return OrderedCollectionIsAValidAddition(file, baseProject, sourceProject, warnings);

            return true;
        }

        private async Task<CompilationResult> CompileCore(IFileInfo file)
        {
            var host = new MvcRazorHost();
            var engine = new RazorTemplateEngine(host);
            GeneratorResults results;
            using (TextReader rdr = new StreamReader(file.CreateReadStream()))
            {
                results = engine.GenerateCode(rdr, '_' + Path.GetFileNameWithoutExtension(file.Name), "Asp", file.PhysicalPath ?? file.Name);
            }

            string generatedCode;

            using (var writer = new StringWriter())
            using (var codeProvider = new CSharpCodeProvider())
            {
                codeProvider.GenerateCodeFromCompileUnit(results.GeneratedCode, writer, new CodeGeneratorOptions());
                generatedCode = writer.ToString();
            }

            if (!results.Success) 
            {
                return CompilationResult.Failed(generatedCode, results.ParserErrors.Select(e => new CompilationMessage(e.Message)));
            }

            Directory.CreateDirectory(_tempPath);
            string tempFile = Path.Combine(_tempPath, Path.GetRandomFileName() + ".cs");

            File.WriteAllText(tempFile, generatedCode);

            _tempFileSystem.TryGetFileInfo(tempFile, out file);
            return await _baseCompilationService.Compile(file);
        }

        public FileProviderGlobbingDirectory(
            [NotNull] IFileProvider fileProvider,
            IFileInfo fileInfo,
            FileProviderGlobbingDirectory parent)
        {
            _fileProvider = fileProvider;
            _fileInfo = fileInfo;
            _parent = parent;

            if (_fileInfo == null)
            {
                // We're the root of the directory tree
                RelativePath = string.Empty;
                _isRoot = true;
            }
            else if (!string.IsNullOrEmpty(parent?.RelativePath))
            {
                // We have a parent and they have a relative path so concat that with my name
                RelativePath = _parent.RelativePath + DirectorySeparatorChar + _fileInfo.Name;
            }
            else
            {
                // We have a parent which is the root, so just use my name
                RelativePath = _fileInfo.Name;
            }
        }

        public UrlForm(IFileInfo fileInfo)
        {
            InitializeComponent();

            this.fileInfo = fileInfo;
            this.Url = fileInfo.Url;
        }

        /// <summary>
        /// Downloads an image at the provided URL and converts it to a valid Data Uri scheme (https://en.wikipedia.org/wiki/Data_URI_scheme)
        /// </summary>
        /// <param name="url">The url where the image is located.</param>
        /// <param name="logger">A logger.</param>
        /// <param name="fallbackFileInfo">A FileInfo to retrieve the local fallback image.</param>
        /// <param name="fallbackMediaType">The media type of the fallback image.</param>
        /// <param name="messageHandler">An optional message handler.</param>
        /// <returns>A string that contains the data uri of the downloaded image, or a default image on any error.</returns>
        public static async Task<string> DownloadImageAndConvertToDataUri(this string url, ILogger logger, IFileInfo fallbackFileInfo, string fallbackMediaType = "image/png", HttpMessageHandler messageHandler = null)
        {
            // exclude completely invalid URLs
            if (!string.IsNullOrWhiteSpace(url))
            {
                try
                {
                    // set a timeout to 10 seconds to avoid waiting on that forever
                    using (var client = new HttpClient(messageHandler) { Timeout = TimeSpan.FromSeconds(10) })
                    {
                        var response = await client.GetAsync(url);
                        response.EnsureSuccessStatusCode();

                        // set the media type and default to JPG if it wasn't provided
                        string mediaType = response.Content.Headers.ContentType?.MediaType;
                        mediaType = string.IsNullOrWhiteSpace(mediaType) ? "image/jpeg" : mediaType;

                        // return the data URI according to the standard
                        return (await response.Content.ReadAsByteArrayAsync()).ToDataUri(mediaType);
                    }
                }
                catch (Exception ex)
                {
                    logger.LogInformation(0, ex, "Error while downloading resource");
                }
            }

            // any error or invalid URLs just return the default data uri
            return await fallbackFileInfo.ToDataUri(fallbackMediaType);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="FileCopyErrorEventArgs"/> class.
        /// </summary>
        /// <param name="file">The file.</param>
        /// <param name="targetDirectory">The target directory.</param>
        public FileCopyErrorEventArgs(IFileInfo file, IDirectoryInfo targetDirectory)
        {
            file.ThrowIfNull(() => file);
            targetDirectory.ThrowIfNull(() => targetDirectory);

            this.File = file;
            this.TargetDirectory = targetDirectory;
        }

        /// <summary>
        /// Get one file.
        /// </summary>
        /// <param name="path"> File path. </param>
        /// <param name="file"> File. </param>
        /// <returns> Whether the file was found or not. </returns>
        public override bool GetFile(string path, List<string> currentPath, Queue<string> remainingPathParts, out IFileInfo file)
        {
            string currentPathStr = this.GetPathString(currentPath);
            path = path.Substring(currentPathStr.Length);

            var found = this.FileSystem.TryGetFileInfo(path, out file);
            return found;
        }

 /// <summary>
 /// Returns file info extracted from the request.
 /// Good point to add extra fields or override some of them
 /// </summary>
 /// <param name="fileInfo"></param>
 /// <param name="contentHeaders"></param>
 /// <returns></returns>
 protected virtual IFileInfo SetFileInfo(IFileInfo fileInfo, HttpContentHeaders contentHeaders)
 {
     return new IncomeFileInfo
     {
         MimeType = contentHeaders.ContentType.ToString(),
         OriginalName = GetOriginalFileName(contentHeaders),
     };
 }

 public SpaContext(HttpContext context, SpaOptions options, IFileInfo fileInfo, ILogger logger)
 {
     Debug.Assert(fileInfo.Exists, $"The file {fileInfo.Name} does not exist");
     _context = context; 
     _options = options;
     _logger = logger;
     _fileInfo = fileInfo;
 }

        public SnapshotForm(Bitmap image, IFileInfo fileInfo)
        {
            InitializeComponent();

            this.SnapshotImage = image;
            this.fileInfo = fileInfo;
            snapshotPicbox_SizeChanged(null, null);
        }

 public static Mock<IMappedObject> AddLocalFile(this Mock<IMetaDataStorage> db, IFileInfo path, string id) {
     var file = new Mock<IMappedObject>();
     file.SetupAllProperties();
     file.Setup(o => o.Type).Returns(MappedObjectType.File);
     file.Object.RemoteObjectId = id;
     file.Object.Name = path.Name;
     db.AddMappedFile(file.Object, path.FullName);
     return file;
 }

 public bool TryGetFileInfo(string subpath, out IFileInfo fileInfo)
 {
     if (subpath == EnvironmentScriptSubpath)
     {
         fileInfo = _environmentScript;
         return true;
     }
     var tryGetFileInfo = _fileSystem.TryGetFileInfo(subpath, out fileInfo);
     return tryGetFileInfo;
 }

 /// <summary>
 /// GetImageFileUrl - this method returns the valid URL for any file, regardless to folder or folder provider in use
 /// </summary>
 /// <param name="Image">Fully loaded IFileInfo object</param>
 /// <returns></returns>
 /// <remarks>
 /// WARNING!!! This method can return exceptions. They should be caught and processed in the UI though.
 /// </remarks>
 public string GetImageFileUrl(IFileInfo Image)
 {
     /*******************************************************'
     ' WARNING!!!
     ' This method can return exceptions. They should be
     ' caught and processed in the UI though.
     '*******************************************************/
     var mapFolder = FolderMappingController.Instance.GetFolderMapping(Image.FolderMappingID);
     return FolderProvider.Instance(mapFolder.FolderProviderType).GetFileUrl(Image);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="CmisSync.Lib.Events.FileMovedEvent"/> class.
 /// </summary>
 /// <param name="oldLocalFile">Old local file.</param>
 /// <param name="newLocalFile">New local file.</param>
 /// <param name="oldRemoteFilePath">Old remote file path.</param>
 /// <param name="newRemoteFile">New remote file.</param>
 public FileMovedEvent(
     IFileInfo oldLocalFile = null,
     IFileInfo newLocalFile = null,
     string oldRemoteFilePath = null,
     IDocument newRemoteFile = null)
     : base(newLocalFile, newRemoteFile) {
     this.Local = MetaDataChangeType.MOVED;
     this.OldLocalFile = oldLocalFile;
     this.OldRemoteFilePath = oldRemoteFilePath;
 }