private void RecursiveDeleteEmptyDirectories(IDirectory dir, bool importfolder) { FileSystemResult fr = dir.Populate(); if (fr.IsOk) { if (dir.Files.Count > 0) { return; } foreach (IDirectory d in dir.Directories) { RecursiveDeleteEmptyDirectories(d, false); } } if (importfolder) { return; } fr = dir.Populate(); if (fr.IsOk) { if (dir.Files.Count == 0 && dir.Directories.Count == 0) { fr = dir.Delete(true); if (!fr.IsOk) { logger.Warn("Unable to DELETE directory: {0} error {1}", dir.FullName, fr?.Error ?? String.Empty); } } } }
public static void GetFilesForImportFolder(IDirectory sDir, ref List <string> fileList) { try { if (sDir == null) { logger.Error("Filesystem not found"); return; } // get root level files FileSystemResult r = sDir.Populate(); if (r.Status != Status.Ok) { logger.Error($"Unable to retrieve folder {sDir.FullName}"); return; } fileList.AddRange(sDir.Files.Select(a => a.FullName)); // search sub folders foreach (IDirectory dir in sDir.Directories) { GetFilesForImportFolder(dir, ref fileList); } } catch (Exception excpt) { logger.Error(excpt.Message); } }
public static IFile ResolveFile(string fullname) { if (string.IsNullOrEmpty(fullname)) { return(null); } Tuple <SVR_ImportFolder, string> tup = VideoLocal_PlaceRepository.GetFromFullPath(fullname); IFileSystem fs = tup?.Item1?.FileSystem; if (fs == null) { return(null); } try { FileSystemResult <IObject> fobj = fs.Resolve(fullname); if (fobj == null || !fobj.IsOk || fobj.Result is IDirectory) { return(null); } return(fobj.Result as IFile); } catch (Exception) { logger.Warn("File with Exception: " + fullname); return(null); } }
public async Task <FileSystemResult> MoveAsync(IDirectory destination) { if (Parent == null) { return(new FileSystemResult("Unable to move root directory")); } if (!(destination is GoogleDriveDirectory)) { return(new FileSystemResult("Destination should be a Google Drive Directory")); } GoogleDriveDirectory dest = (GoogleDriveDirectory)destination; if (dest.Id == ((GoogleDriveDirectory)Parent).Id) { return(new FileSystemResult("Source Directory and Destination Directory should be different")); } string addParents = dest.Id; string removeParents = ((GoogleDriveDirectory)Parent).Id; string url = GooglePatch.FormatRest(Id); url += "?addParents=" + addParents + "&removeParents=" + removeParents; FileSystemResult <string> ex = await FS.OAuth.CreateMetadataStream <string>(url, null, null, new HttpMethod("PATCH")); if (ex.IsOk) { string oldFullname = this.FullName; this.SetData(ex.Result); ChangeObjectDirectory <GoogleDriveDirectory, GoogleDriveFile>(oldFullname, FS.Refs, this, (GoogleDriveDirectory)Parent, dest); return(new FileSystemResult()); } return(new FileSystemResult <IDirectory>(ex.Error)); }
public async Task <FileSystemResult <IDirectory> > CreateDirectoryAsync(string name, Dictionary <string, object> properties) { if (properties == null) { properties = new Dictionary <string, object>(); } CreateDirectoryRequest req = new CreateDirectoryRequest(); req.Name = name; req.Folder = new Folder(); string requesturl = CreateDir.FormatRest(this is OneDriveRoot ? "root" : Id); FileSystemResult <ExpandoObject> ex = await FS.OAuth.CreateMetadataStream <ExpandoObject>(requesturl, Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(req)), "application/json"); if (ex.IsOk) { string id; if (InternalTryGetProperty(ex.Result, "id", out id)) { FileSystemResult <ExpandoObject> ex2 = await FS.OAuth.CreateMetadataStream <ExpandoObject>(Item.FormatRest(FS.OneDriveUrl, id)); OneDriveDirectory dir = new OneDriveDirectory(FullName, FS) { Parent = this }; dir.SetData(JsonConvert.SerializeObject(ex.Result)); FS.Refs[dir.FullName] = dir; _directories.Add(dir); return(new FileSystemResult <IDirectory>(dir)); } return(new FileSystemResult <IDirectory>("Unable to get id from the created directory")); } return(new FileSystemResult <IDirectory>(ex.Error)); }
public IFileSystem Connect(Window owner) { if (string.IsNullOrEmpty(Provider)) { throw new Exception("Empty provider supplied"); } Dictionary <string, object> auth = AuthInstance.AuthorizationProvider.Get(Provider); if (auth == null) { throw new Exception("Application Authorization Not Found"); } _plugin = CloudFileSystemPluginFactory.Instance.List.FirstOrDefault(a => a.Name == Provider); if (_plugin == null) { throw new Exception("Cannot find cloud provider '" + Provider + "'"); } Icon = _plugin.CreateIconImage(); FileSystemResult <IFileSystem> res = _plugin.Init(Name, new AuthProvider(owner), auth, ConnectionString); if (!res.IsOk) { throw new Exception("Unable to connect to '" + Provider + "'"); } string userauth = res.Result.GetUserAuthorization(); if (ConnectionString != userauth) { NeedSave = true; ConnectionString = userauth; } return(res.Result); }
public List <TextStream> GetStreams(SVR_VideoLocal_Place vplace) { // TODO Scan the folder for filename.lang.sub files string dirname = Path.GetDirectoryName(vplace.FullServerPath); string fname = Path.GetFileNameWithoutExtension(vplace.FilePath); if (string.IsNullOrEmpty(dirname) || string.IsNullOrEmpty(fname)) { return(new List <TextStream>()); } string basename = Path.Combine(dirname, fname); var path = basename + ".sub"; if (!File.Exists(basename + ".idx") || !File.Exists(path)) { return(new List <TextStream>()); } FileSystemResult <IObject> r = vplace.ImportFolder.FileSystem.Resolve(path); if (r == null || !r.IsOk || !(r.Result is IFile)) { return(new List <TextStream>()); } MediaContainer m = MediaInfo.GetMediaInfo(path); if (m == null) { return(new List <TextStream>()); } m.TextStreams.ForEach(a => a.Filename = path); return(m.TextStreams); }
internal async Task <FileSystemResult> MayRefreshToken(bool force = false) { if (Token == null) { return(new FileSystemResult("Authorization Token not found")); } if (Token.ExpirationDate.AddMinutes(3) < DateTime.Now || force) { string refreshToken = Token.RefreshToken; Dictionary <string, string> postdata = new Dictionary <string, string>(); postdata.Add("grant_type", "refresh_token"); postdata.Add("refresh_token", Token.RefreshToken); postdata.Add("client_id", ClientId); postdata.Add("client_secret", ClientSecret); Token = null; FileSystemResult <Token> fs = await CreateMetadataStream <Token>(OAuthUrl, Encoding.UTF8.GetBytes(postdata.PostFromDictionary())); if (!fs.IsOk) { return(new FileSystemResult(fs.Error)); } Token = fs.Result; if (string.IsNullOrEmpty(Token.RefreshToken)) { Token.RefreshToken = refreshToken; } } return(new FileSystemResult()); }
internal async Task <FileSystemResult <dynamic> > List(string url) { string baseurl = url; int count; List <dynamic> accum = new List <dynamic>(); do { FileSystemResult <ExpandoObject> cl = await FS.OAuth.CreateMetadataStream <ExpandoObject>(url); if (!cl.IsOk) { return(new FileSystemResult <dynamic>(cl.Error)); } dynamic obj = cl.Result; count = obj.data.Count; if (count > 0) { accum.AddRange(obj.data); if (!((IDictionary <String, object>)obj).ContainsKey("nextToken")) { count = 0; } else { url = baseurl + "&startToken=" + obj.nextToken; } } } while (count > 0); return(new FileSystemResult <dynamic>(accum)); }
public override FileSystemResult DehydrateFolder(string relativePath) { FileSystemResult result = new FileSystemResult(FSResult.Ok, 0); GitIndexProjection.PathSparseState sparseState = this.FileSystemCallbacks.GitIndexProjection.GetFolderPathSparseState(relativePath); if (sparseState == GitIndexProjection.PathSparseState.Included) { // When the folder is included we need to create the placeholder to make sure it is on disk for enumeration result = this.WritePlaceholderDirectory(relativePath); if (result.Result == FSResult.Ok) { this.FileSystemCallbacks.OnPlaceholderFolderCreated(relativePath, string.Empty); } else if (result.Result == FSResult.FileOrPathNotFound) { // This will happen when the parent folder is also in the dehydrate list and is no longer on disk. result = new FileSystemResult(FSResult.Ok, 0); } else { EventMetadata metadata = this.CreateEventMetadata(relativePath); metadata.Add(nameof(result.Result), result.Result); metadata.Add(nameof(result.RawResult), result.RawResult); this.Context.Tracer.RelatedError(metadata, $"{nameof(this.DehydrateFolder)}: Write placeholder failed"); } } return(result); }
public List <Stream> Process(SVR_VideoLocal_Place vplace) { string dirname = Path.GetDirectoryName(vplace.FullServerPath); string fname = Path.GetFileNameWithoutExtension(vplace.FilePath); if (string.IsNullOrEmpty(dirname) || string.IsNullOrEmpty(fname)) { return(null); } string basename = Path.Combine(dirname, fname); List <Stream> streams = new List <Stream>(); if (File.Exists(basename + ".idx") && File.Exists(basename + ".sub")) { FileSystemResult <IObject> r = vplace.ImportFolder.FileSystem.Resolve(basename + ".sub"); if (r != null && r.IsOk && r.Result is IFile) { List <Stream> ss = GetStreams((IFile)r.Result); if ((ss != null) && (ss.Count > 0)) { streams.AddRange(ss); } } } return(streams); }
public async Task <FileSystemResult> WriteMetadataAsync(ExpandoObject metadata) { //Only Name, Description and Labels supported Json.MetaPatch patch = new Json.MetaPatch(); string v; if (InternalTryGetProperty(metadata, "name", out v)) { patch.name = v; } if (InternalTryGetProperty(metadata, "description", out v)) { patch.description = v; } List <string> labels; if (InternalTryGetProperty(metadata, "labels", out labels)) { patch.labels = labels; } string url = AmazonPatch.FormatRest(FS.OAuth.EndPoint.MetadataUrl, Id); FileSystemResult <string> ex = await FS.OAuth.CreateMetadataStream <string>(url, Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(patch)), "application/json", new HttpMethod("PATCH")); if (ex.IsOk) { this.SetData(ex.Result); return(new FileSystemResult()); } return(new FileSystemResult <IDirectory>(ex.Error)); }
public new async Task <FileSystemResult <FileSystemSizes> > QuotaAsync() { FileSystemResult <ExpandoObject> cl = await FS.OAuth.CreateMetadataStream <ExpandoObject>(GoogleQuota); if (!cl.IsOk) { return(new FileSystemResult <FileSystemSizes>(cl.Error)); } IDictionary <string, object> dic = cl.Result; Sizes = new FileSystemSizes(); if (dic.ContainsKey("quotaBytesTotal")) { Sizes.TotalSize = ParseLong(dic["quotaBytesTotal"]); } if (dic.ContainsKey("quotaBytesUsed")) { Sizes.UsedSize = ParseLong(dic["quotaBytesUsed"]); } if (dic.ContainsKey("quotaBytesUsedAggregate")) { Sizes.AvailableSize = Sizes.TotalSize - ParseLong(dic["quotaBytesUsedAggregate"]); } return(new FileSystemResult <FileSystemSizes>(Sizes)); }
public async Task <FileSystemResult> DeleteAsync(bool skipTrash) { if (Parent == null) { return(new FileSystemResult("Unable to delete root directory")); } string url = AmazonTrash.FormatRest(FS.OAuth.EndPoint.MetadataUrl, Id); FileSystemResult <ExpandoObject> ex = await FS.OAuth.CreateMetadataStream <ExpandoObject>(url, null, null, HttpMethod.Put); if (ex.IsOk) { if (this is AmazonFile) { Parent.Files.Remove((IFile)this); } else if (this is AmazonDirectory) { Parent.Directories.Remove((IDirectory)this); } this.Parent = null; return(new FileSystemResult()); } return(new FileSystemResult <IDirectory>(ex.Error)); }
public async Task <FileSystemResult> MoveAsync(IDirectory destination) { if (Parent == null) { return(new FileSystemResult("Unable to move root directory")); } if (!(destination is AmazonDirectory)) { return(new FileSystemResult("Destination should be an Amazon Cloud Drive Directory")); } AmazonDirectory dest = (AmazonDirectory)destination; if (dest.Id == ((AmazonDirectory)Parent).Id) { return(new FileSystemResult("Source Directory and Destination Directory should be different")); } Json.MoveData j = new Json.MoveData(); j.childId = Id; j.fromParent = ((AmazonDirectory)Parent).Id; string url = AmazonMove.FormatRest(FS.OAuth.EndPoint.MetadataUrl, dest.Id); FileSystemResult <string> ex = await FS.OAuth.CreateMetadataStream <string>(url, Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(j)), "application/json"); //TODO Some kind of locking if (ex.IsOk) { string oldFullname = this.FullName; this.SetData(ex.Result); ChangeObjectDirectory <AmazonDirectory, AmazonFile>(oldFullname, FS.Refs, this, (AmazonDirectory)Parent, dest); return(new FileSystemResult()); } return(new FileSystemResult <IDirectory>(ex.Error)); }
public static IFile ResolveFile(string fullname) { Tuple <ImportFolder, string> tup = VideoLocal_PlaceRepository.GetFromFullPath(fullname); IFileSystem fs = tup?.Item1.FileSystem; if (fs == null) { return(null); } try { FileSystemResult <IObject> fobj = fs?.Resolve(fullname); if (!fobj.IsOk || fobj.Result is IDirectory) { logger.Warn("File not found: " + fullname); return(null); } return(fobj.Result as IFile); } catch (Exception) { logger.Warn("File with Exception: " + fullname); throw; } }
public List <Stream> Process(SVR_VideoLocal_Place vplace) { string dirname = Path.GetDirectoryName(vplace.FullServerPath); string fname = Path.GetFileNameWithoutExtension(vplace.FilePath); if (string.IsNullOrEmpty(dirname) || string.IsNullOrEmpty(fname)) { return(null); } string basename = Path.Combine(dirname, fname); HashSet <string> extensions = new HashSet <string>(SubtitleHelper.Extensions.Keys); extensions.Remove("idx"); List <Stream> streams = new List <Stream>(); foreach (string n in extensions) { string newname = basename + "." + n; FileSystemResult <IObject> r = vplace.ImportFolder.FileSystem.Resolve(newname); if (r != null && r.IsOk && r.Result is IFile) { List <Stream> ss = GetStreams((IFile)r.Result); if ((ss != null) && (ss.Count > 0)) { streams.AddRange(ss); } } } return(streams); }
public List <TextStream> GetStreams(SVR_VideoLocal_Place vplace) { // TODO Scan the folder for filename.lang.sub files string dirname = Path.GetDirectoryName(vplace.FullServerPath); string fname = Path.GetFileNameWithoutExtension(vplace.FilePath); if (string.IsNullOrEmpty(dirname) || string.IsNullOrEmpty(fname)) { return(new List <TextStream>()); } string basename = Path.Combine(dirname, fname); HashSet <string> extensions = new HashSet <string>(SubtitleHelper.Extensions.Keys); extensions.Remove("idx"); List <TextStream> streams = new List <TextStream>(); foreach (string n in extensions) { string newname = $"{basename}.{n}"; FileSystemResult <IObject> r = vplace.ImportFolder.FileSystem.Resolve(newname); if (r == null || !r.IsOk || !(r.Result is IFile)) { continue; } MediaContainer m = MediaInfo.GetMediaInfo(newname); List <TextStream> tStreams = m?.TextStreams; if (tStreams != null && tStreams.Count > 0) { tStreams.ForEach(a => a.Filename = newname); streams.AddRange(tStreams); } } return(streams); }
public IFileSystem Connect() { if (string.IsNullOrEmpty(Provider)) { throw new Exception("Empty provider supplied"); } Dictionary <string, object> auth = AuthInstance.AuthorizationProvider.Get(Provider); if (auth == null) { throw new Exception("Application Authorization Not Found"); } _plugin = CloudFileSystemPluginFactory.Instance.List.FirstOrDefault(a => a.Name.EqualsInvariantIgnoreCase(Provider)); if (_plugin == null) { throw new Exception("Cannot find cloud provider '" + Provider + "'"); } FileSystemResult <IFileSystem> res = _plugin.Init(Name, ShokoServer.Instance.OAuthProvider, auth, ConnectionString); if (res == null || !res.IsOk) { throw new Exception("Unable to connect to '" + Provider + "'"); } string userauth = res.Result.GetUserAuthorization(); if (ConnectionString != userauth) { NeedSave = true; ConnectionString = userauth; } return(res.Result); }
internal async Task <FileSystemResult <dynamic> > List(string url) { int count; List <dynamic> accum = new List <dynamic>(); do { FileSystemResult <ExpandoObject> cl = await FS.OAuth.CreateMetadataStream <ExpandoObject>(url); if (!cl.IsOk) { return(new FileSystemResult <dynamic>(cl.Error)); } dynamic obj = cl.Result; count = obj.children.Count; if (count > 0) { accum.AddRange(obj.items); if (!((IDictionary <string, object>)obj).ContainsKey("@odata.nextLink")) { count = 0; } else { url = (string)((IDictionary <string, object>)obj)["@odata.nextLink"]; } } } while (count > 0); return(new FileSystemResult <dynamic>(accum)); }
public bool TryDehydrateFolder(string relativePath, out string errorMessage) { List <IPlaceholderData> removedPlaceholders = null; List <string> removedModifiedPaths = null; errorMessage = string.Empty; try { relativePath = GVFSDatabase.NormalizePath(relativePath); removedPlaceholders = this.placeholderDatabase.RemoveAllEntriesForFolder(relativePath); removedModifiedPaths = this.modifiedPaths.RemoveAllEntriesForFolder(relativePath); FileSystemResult result = this.fileSystemVirtualizer.DehydrateFolder(relativePath); if (result.Result != FSResult.Ok) { errorMessage = $"{nameof(this.TryDehydrateFolder)} failed with {result.Result}"; this.context.Tracer.RelatedError(errorMessage); } } catch (Exception ex) { errorMessage = $"{nameof(this.TryDehydrateFolder)} threw an exception - {ex.Message}"; EventMetadata metadata = this.CreateEventMetadata(relativePath, ex); this.context.Tracer.RelatedError(metadata, errorMessage); } if (!string.IsNullOrEmpty(errorMessage)) { if (removedPlaceholders != null) { foreach (IPlaceholderData data in removedPlaceholders) { try { this.placeholderDatabase.AddPlaceholderData(data); } catch (Exception ex) { EventMetadata metadata = this.CreateEventMetadata(data.Path, ex); this.context.Tracer.RelatedError(metadata, $"{nameof(FileSystemCallbacks)}.{nameof(this.TryDehydrateFolder)} failed to add '{data.Path}' back into PlaceholderDatabase"); } } } if (removedModifiedPaths != null) { foreach (string modifiedPath in removedModifiedPaths) { if (!this.modifiedPaths.TryAdd(modifiedPath, isFolder: modifiedPath.EndsWith(GVFSConstants.GitPathSeparatorString), isRetryable: out bool isRetryable)) { this.context.Tracer.RelatedError($"{nameof(FileSystemCallbacks)}.{nameof(this.TryDehydrateFolder)}: failed to add '{modifiedPath}' back into ModifiedPaths"); } } } } return(string.IsNullOrEmpty(errorMessage)); }
internal virtual async Task <FileSystemResult> Login(Dictionary <string, object> authorization, string name, bool isUserAuth, bool scopescommaseparated) { if (!authorization.ContainsKey(ClientIdString) || !(authorization[ClientIdString] is string)) { return(new FileSystemResult("Unable to find " + name + " '" + ClientIdString + "' in settings")); } ClientId = (string)authorization[ClientIdString]; if (!authorization.ContainsKey(ClientSecretString) || !(authorization[ClientSecretString] is string)) { return(new FileSystemResult("Unable to find " + name + " '" + ClientSecretString + "' in settings")); } ClientSecret = (string)authorization[ClientSecretString]; if (!authorization.ContainsKey(RedirectUriString) || !(authorization[RedirectUriString] is string)) { RedirectUri = DefaultRedirectUri; } else { RedirectUri = (string)authorization[RedirectUriString]; } if (!authorization.ContainsKey(ScopesString) || !(authorization[ScopesString] is List <string>)) { Scopes = DefaultScopes; } else { Scopes = (List <string>)authorization[ScopesString]; } if (!authorization.ContainsKey(UserAgentString) || !(authorization[UserAgentString] is string)) { UserAgent = "CloudFileSystem/1.0"; } else { UserAgent = (string)authorization[UserAgentString]; } if (isUserAuth) { FileSystemResult r = await FillFromUserAuth(); return(r); } if (_provider == null) { return(new FileSystemResult <IFileSystem>("Cannot find valid Authorization Provider for " + name)); } AuthRequest request = new AuthRequest { Name = name, LoginUrl = OAuthLoginUrl, ClientId = ClientId, Scopes = Scopes, RedirectUri = RedirectUri, ScopesCommaSeparated = scopescommaseparated }; AuthResult result = await _provider.Login(request); if (result.HasError) { return(new FileSystemResult <IFileSystem>(result.ErrorString)); } return(await FillFromLogin(result.Code)); }
public IFile GetFile() { IFileSystem fs = ImportFolder.FileSystem; FileSystemResult <IObject> fobj = fs?.Resolve(FullServerPath); if (fobj == null || !fobj.IsOk || fobj.Result is IDirectory) { return(null); } return(fobj.Result as IFile); }
public async Task <FileSystemResult> TouchAsync() { string url = GoogleTouch.FormatRest(Id); FileSystemResult <string> ex = await FS.OAuth.CreateMetadataStream <string>(url, null, null, HttpMethod.Post); if (ex.IsOk) { SetData(ex.Result); return(new FileSystemResult()); } return(new FileSystemResult <IDirectory>(ex.Error)); }
public async Task <FileSystemResult <IFileSystem> > InitAsync(string fname, IOAuthProvider provider, Dictionary <string, object> settings, string userauthorization = null) { FileSystemResult <OneDriveFileSystem> r = await OneDriveFileSystem.Create(fname, provider, settings, Name, userauthorization); if (!r.IsOk) { return(new FileSystemResult <IFileSystem>(r.Error)); } OneDriveFileSystem f = r.Result; return(new FileSystemResult <IFileSystem>(f)); }
public async Task <FileSystemResult> WriteMetadataAsync(ExpandoObject metadata) { string url = Item.FormatRest(Id); FileSystemResult <string> ex = await FS.OAuth.CreateMetadataStream <string>(url, Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata)), "application/json", new HttpMethod("PATCH")); if (ex.IsOk) { SetData(ex.Result); return(new FileSystemResult()); } return(new FileSystemResult <IDirectory>(ex.Error)); }
internal async Task <FileSystemResult> CheckExpirations() { FileSystemResult r = await OAuth.MayRefreshToken(); if (!r.IsOk) { return(r); } r = await OAuth.MayRefreshEndPoint(); return(r); }
public async Task <FileSystemResult> PopulateAsync() { using (await _populateLock.LockAsync()) { FileSystemResult r = await FS.CheckExpirations(); if (!r.IsOk) { return(r); } string url = AmazonList.FormatRest(FS.OAuth.EndPoint.MetadataUrl, Id); FileSystemResult <dynamic> fr = await List(url); if (!fr.IsOk) { return(new FileSystemResult(fr.Error)); } IntFiles = new List <AmazonFile>(); List <IDirectory> dirlist = new List <IDirectory>(); foreach (dynamic v in fr.Result) { if (v.kind == "FOLDER") { AmazonDirectory dir = new AmazonDirectory(FullName, FS) { Parent = this }; dir.SetData(JsonConvert.SerializeObject(v)); if ((dir.Attributes & ObjectAttributes.Trashed) != ObjectAttributes.Trashed) { dirlist.Add(dir); } } else if (v.kind == "FILE") { AmazonFile f = new AmazonFile(FullName, FS) { Parent = this }; f.SetData(JsonConvert.SerializeObject(v)); if ((f.Attributes & ObjectAttributes.Trashed) != ObjectAttributes.Trashed) { IntFiles.Add(f); } } } FS.Refs.AddDirectories(dirlist, this); IntDirectories = dirlist.Cast <AmazonDirectory>().ToList(); IsPopulated = true; return(new FileSystemResult()); } }
public static async Task <FileSystemResult <IFileSystem> > Create(string name) { LocalFileSystem l = new LocalFileSystem(); l.fname = name; FileSystemResult r = await l.PopulateAsync(); if (!r.IsOk) { return(new FileSystemResult <IFileSystem>(r.Error)); } return(new FileSystemResult <IFileSystem>(l)); }
public Media GetMediaFromUser(int userID) { Media n = null; if (Media == null) { VideoLocal_Place pl = GetBestVideoLocalPlace(); if (pl != null) { IFileSystem f = pl.ImportFolder.FileSystem; FileSystemResult <IObject> src = f.Resolve(pl.FullServerPath); if (src != null && src.IsOk && src.Result is IFile) { if (pl.RefreshMediaInfo()) { RepoFactory.VideoLocal.Save(pl.VideoLocal, true); } } } } if (Media != null) { n = Media.DeepClone(); if (n?.Parts != null) { foreach (Part p in n?.Parts) { string name = UrlSafe.Replace(Path.GetFileName(FileName), " ").Replace(" ", " ").Replace(" ", " ").Trim(); name = UrlSafe2.Replace(name, string.Empty).Trim().Replace("..", ".").Replace("..", ".").Replace("__", "_").Replace("__", "_").Replace(" ", "_").Replace("_.", "."); while (name.StartsWith("_")) { name = name.Substring(1); } while (name.StartsWith(".")) { name = name.Substring(1); } p.Key = PlexAndKodi.Helper.ReplaceSchemeHost(PlexAndKodi.Helper.ConstructVideoLocalStream(userID, VideoLocalID.ToString(), name, false)); if (p.Streams != null) { foreach (Stream s in p.Streams.Where(a => a.File != null && a.StreamType == "3")) { s.Key = PlexAndKodi.Helper.ReplaceSchemeHost(PlexAndKodi.Helper.ConstructFileStream(userID, s.File, false)); } } } } } return(n); }
public void MoveFileIfRequired() { try { logger.Trace("Attempting to MOVE file: {0}", this.FullServerPath); // check if this file is in the drop folder // otherwise we don't need to move it if (ImportFolder.IsDropSource == 0) { logger.Trace("Not moving file as it is NOT in the drop folder: {0}", this.FullServerPath); return; } IFileSystem f = this.ImportFolder.FileSystem; if (f == null) { logger.Trace("Unable to MOVE, filesystem not working: {0}", this.FullServerPath); return; } FileSystemResult<IObject> fsrresult = f.Resolve(FullServerPath); if (!fsrresult.IsOk) { logger.Error("Could not find the file to move: {0}", this.FullServerPath); return; } IFile source_file = fsrresult.Result as IFile; if (source_file == null) { logger.Error("Could not find the file to move: {0}", this.FullServerPath); return; } // find the default destination ImportFolder destFolder = null; foreach (ImportFolder fldr in RepoFactory.ImportFolder.GetAll().Where(a => a.CloudID == ImportFolder.CloudID)) { if (fldr.IsDropDestination == 1) { destFolder = fldr; break; } } if (destFolder == null) return; FileSystemResult<IObject> re = f.Resolve(destFolder.ImportFolderLocation); if (!re.IsOk) return; // keep the original drop folder for later (take a copy, not a reference) ImportFolder dropFolder = this.ImportFolder; // we can only move the file if it has an anime associated with it List<CrossRef_File_Episode> xrefs = this.VideoLocal.EpisodeCrossRefs; if (xrefs.Count == 0) return; CrossRef_File_Episode xref = xrefs[0]; // find the series associated with this episode AnimeSeries series = RepoFactory.AnimeSeries.GetByAnimeID(xref.AnimeID); if (series == null) return; // find where the other files are stored for this series // if there are no other files except for this one, it means we need to create a new location bool foundLocation = false; string newFullPath = ""; // sort the episodes by air date, so that we will move the file to the location of the latest episode List<AnimeEpisode> allEps = series.GetAnimeEpisodes().OrderByDescending(a => a.AniDB_EpisodeID).ToList(); IDirectory destination = null; foreach (AnimeEpisode ep in allEps) { // check if this episode belongs to more than one anime // if it does we will ignore it List<CrossRef_File_Episode> fileEpXrefs = RepoFactory.CrossRef_File_Episode.GetByEpisodeID(ep.AniDB_EpisodeID); int? animeID = null; bool crossOver = false; foreach (CrossRef_File_Episode fileEpXref in fileEpXrefs) { if (!animeID.HasValue) animeID = fileEpXref.AnimeID; else { if (animeID.Value != fileEpXref.AnimeID) crossOver = true; } } if (crossOver) continue; foreach (VideoLocal vid in ep.GetVideoLocals().Where(a => a.Places.Any(b=>b.ImportFolder.CloudID == destFolder.CloudID && b.ImportFolder.IsDropSource==0))) { if (vid.VideoLocalID != this.VideoLocalID) { VideoLocal_Place place=vid.Places.FirstOrDefault(a=>a.ImportFolder.CloudID==destFolder.CloudID); string thisFileName = place?.FullServerPath; string folderName = Path.GetDirectoryName(thisFileName); FileSystemResult<IObject> dir = f.Resolve(folderName); if (dir.IsOk) { destination = (IDirectory)dir.Result; newFullPath = folderName; foundLocation = true; break; } } } if (foundLocation) break; } if (!foundLocation) { // we need to create a new folder string newFolderName = Utils.RemoveInvalidFolderNameCharacters(series.GetAnime().PreferredTitle); newFullPath =Path.Combine(destFolder.ParsedImportFolderLocation, newFolderName); FileSystemResult<IObject> dirn = f.Resolve(newFullPath); if (!dirn.IsOk) { dirn = f.Resolve(destFolder.ImportFolderLocation); if (dirn.IsOk) { IDirectory d = (IDirectory)dirn.Result; FileSystemResult<IDirectory> d2 = Task.Run(async () => await d.CreateDirectoryAsync(newFolderName, null)).Result; destination = d2.Result; } } else if (dirn.Result is IFile) { logger.Error("Destination folder is a file: {0}", newFolderName); } else { destination = (IDirectory) dirn.Result; } } string newFullServerPath = Path.Combine(newFullPath, Path.GetFileName(this.FullServerPath)); Tuple<ImportFolder, string> tup = VideoLocal_PlaceRepository.GetFromFullPath(newFullServerPath); if (tup == null) { logger.Error($"Unable to LOCATE file {newFullServerPath} inside the import folders"); return; } logger.Info("Moving file from {0} to {1}", this.FullServerPath, newFullServerPath); FileSystemResult<IObject> dst = f.Resolve(newFullServerPath); if (dst.IsOk) { logger.Trace("Not moving file as it already exists at the new location, deleting source file instead: {0} --- {1}", this.FullServerPath, newFullServerPath); // if the file already exists, we can just delete the source file instead // this is safer than deleting and moving FileSystemResult fr = new FileSystemResult(); try { fr = source_file.Delete(false); if (!fr.IsOk) { logger.Warn("Unable to DELETE file: {0} error {1}", this.FullServerPath, fr?.Error ?? String.Empty); } this.ImportFolderID = tup.Item1.ImportFolderID; this.FilePath = tup.Item2; RepoFactory.VideoLocalPlace.Save(this); // check for any empty folders in drop folder // only for the drop folder if (dropFolder.IsDropSource == 1) { FileSystemResult<IObject> dd = f.Resolve(dropFolder.ImportFolderLocation); if (dd != null && dd.IsOk && dd.Result is IDirectory) { RecursiveDeleteEmptyDirectories((IDirectory)dd.Result, true); } } } catch { logger.Error("Unable to DELETE file: {0} error {1}", this.FullServerPath, fr?.Error ?? String.Empty); } } else { FileSystemResult fr = source_file.Move(destination); if (!fr.IsOk) { logger.Error("Unable to MOVE file: {0} to {1} error {2)", this.FullServerPath, newFullServerPath, fr?.Error ?? String.Empty); return; } string originalFileName = this.FullServerPath; this.ImportFolderID = tup.Item1.ImportFolderID; this.FilePath = tup.Item2; RepoFactory.VideoLocalPlace.Save(this); try { // move any subtitle files foreach (string subtitleFile in Utils.GetPossibleSubtitleFiles(originalFileName)) { FileSystemResult<IObject> src = f.Resolve(subtitleFile); if (src.IsOk && src.Result is IFile) { string newSubPath = Path.Combine(Path.GetDirectoryName(newFullServerPath), ((IFile)src.Result).Name); dst = f.Resolve(newSubPath); if (dst.IsOk && dst.Result is IFile) { FileSystemResult fr2 = src.Result.Delete(true); if (!fr2.IsOk) { logger.Warn("Unable to DELETE file: {0} error {1}", subtitleFile, fr2?.Error ?? String.Empty); } } else { FileSystemResult fr2 = ((IFile)src.Result).Move(destination); if (!fr2.IsOk) { logger.Error("Unable to MOVE file: {0} to {1} error {2)", subtitleFile, newSubPath, fr2?.Error ?? String.Empty); } } } } } catch (Exception ex) { logger.Error( ex,ex.ToString()); } // check for any empty folders in drop folder // only for the drop folder if (dropFolder.IsDropSource == 1) { FileSystemResult<IObject> dd = f.Resolve(dropFolder.ImportFolderLocation); if (dd != null && dd.IsOk && dd.Result is IDirectory) RecursiveDeleteEmptyDirectories((IDirectory)dd.Result,true); } } } catch (Exception ex) { string msg = $"Could not MOVE file: {this.FullServerPath} -- {ex.ToString()}"; logger.Error( ex,msg); } }