public SyncFolderWizardViewModel(Controller controller, Config.SyncConfig.SyncFolder model) : base(controller, model) { Pages = new List<Object> { new ViewModels.SyncFolderWizard.AccountPageViewModel(Controller, this), new ViewModels.SyncFolderWizard.RemotePageViewModel(Controller, this), new ViewModels.SyncFolderWizard.LocalPageViewModel(Controller, this) }; }
public MissingFolderDialog(Config.SyncConfig.SyncFolder repo) { this.repo = repo; selectNewCommand = new RelayCommand(selectNew); removeFromSyncCommand = new RelayCommand(removeFromSync); resyncCommand = new RelayCommand(resync); InitializeComponent(); }
public static void OpenRemoteFolder(Config.SyncConfig.SyncFolder repo) { if (repo != null) { Process.Start(CmisSync.Lib.Cmis.CmisUtils.GetBrowsableURL(repo)); } else { Logger.Warn("Could not find requested config for \"" + repo + "\""); } }
/// <summary></summary> /// <param name="localPath"></param> /// <param name="repoInfo"></param> public LocalPathSyncItem(string localPath, Config.SyncConfig.SyncFolder repoInfo) { this.localRootPath = repoInfo.LocalPath; this.remoteRootPath = repoInfo.RemotePath; this.localRelativePath = localPath; if (localPath.StartsWith(this.localRootPath)) { this.localRelativePath = localPath.Substring(this.localRootPath.Length).TrimStart(Path.DirectorySeparatorChar); } this.remoteRelativePath = PathRepresentationConverter.LocalToRemote(this.localRelativePath); }
/// <summary></summary> /// <param name="localFolder"></param> /// <param name="fileName"></param> /// <param name="repoInfo"></param> public LocalPathSyncItem(string localFolder, string fileName, Config.SyncConfig.SyncFolder repoInfo) { if (!isValidFileName(fileName)) { throw new ArgumentException(); } this.localRootPath = repoInfo.LocalPath; this.remoteRootPath = repoInfo.RemotePath; this.localRelativePath = Path.Combine(localFolder, fileName); if (localRelativePath.StartsWith(this.localRootPath)) { this.localRelativePath = localRelativePath.Substring(this.localRootPath.Length).TrimStart(Path.DirectorySeparatorChar); } this.remoteRelativePath = PathRepresentationConverter.LocalToRemote(this.localRelativePath); }
/// <summary> /// Create a new CmisSync synchronized folder. /// </summary> public void AddAndStartNewSyncFolderSyncronization(Config.SyncConfig.SyncFolder syncFolderInfo) { //TODO: check repoInfo data checkDefaultRepositoryStncFolder(); // Check that the folder don't exists. if (Directory.Exists(syncFolderInfo.LocalPath)) { Logger.Fatal(String.Format("Fetcher | ERROR - Cmis Repository Folder {0} already exist", syncFolderInfo.LocalPath)); throw new UnauthorizedAccessException("Repository folder already exists!"); } Directory.CreateDirectory(syncFolderInfo.LocalPath); // Add folder to XML config file. ConfigureAndStartSyncFolderSyncronization(syncFolderInfo); ConfigManager.CurrentConfig.AddSyncFolder(syncFolderInfo); }
public void TestConfig() { string configpath = Path.GetFullPath("testconfig.conf"); try { //Create new config file with default values Config config = new Config(configpath); //Notifications should be switched on by default Assert.IsTrue(config.Notifications); Assert.AreEqual(config.Folders.Count, 0); config.Save(); config = new Config(configpath); } catch (Exception) { if (File.Exists(configpath)) File.Delete(configpath); throw; } File.Delete(configpath); }
/// <summary> /// Initialize (in the GUI and syncing mechanism) an existing CmisSync synchronized folder. /// </summary> /// <param name="repositoryInfo">Synchronized folder path</param> private void ConfigureAndStartSyncFolderSyncronization(Config.SyncConfig.SyncFolder repositoryInfo) { //create the local directory System.IO.Directory.CreateDirectory(repositoryInfo.LocalPath); CmisSync.Lib.Sync.SyncFolderSyncronizer syncronizer = new CmisSync.Lib.Sync.SyncFolderSyncronizer(repositoryInfo); syncronizer.Event += syncronizer_Event; this.SyncFolders.Add(syncronizer); syncronizer.Initialize(); }
internal bool deleteAccount(Config.SyncConfig.Account account) { if (account == null) { return false; } if (account.SyncFolders.Count != 0) { MessageBox.Show("There are " + account.SyncFolders.Count + " synced folders commected to this account, remove them first.", "Unable to delete active Account"); return false; } MessageBoxResult result = MessageBox.Show("Are you sure you want to remove the account '" + account.DisplayName + "' (pointing to '" + (account.RemoteUrl != null ? account.RemoteUrl.ToString() : "") + "')", "Delete Account", MessageBoxButton.YesNoCancel); if (result == MessageBoxResult.Yes) { ConfigManager.CurrentConfig.Accounts.Remove(account); ConfigManager.CurrentConfig.Save(); return true; } else { return false; } }
public AccountViewModel(Controller controller, Config.SyncConfig.Account account) : this(controller) { this._account = account; }
public FolderViewModel(FolderViewModel parent, Config.SyncConfig.RemoteFolder folder) : base(parent, true) { this.folder = folder; }
/// <summary> /// Check whether the directory is worth syncing or not. /// Directories that are not worth syncing include ignored, system, and hidden folders. /// </summary> public static bool IsDirectoryWorthSyncing(string localDirectory, Config.SyncConfig.SyncFolder repoInfo) { if (!localDirectory.StartsWith(repoInfo.LocalPath)) { Logger.WarnFormat("Local directory is outside repo target directory. local={0}, repo={1}", localDirectory, repoInfo.LocalPath); return false; } //Check for ignored path... string path = localDirectory.Substring(repoInfo.LocalPath.Length).Replace("\\", "/"); if (repoInfo.isPathIgnored(path)) { Logger.DebugFormat("Skipping {0}: hidden folder", localDirectory); return false; } //Check system/hidden DirectoryInfo directoryInfo = new DirectoryInfo(localDirectory); if (directoryInfo.Exists) { if (directoryInfo.Attributes.HasFlag(FileAttributes.Hidden)) { Logger.DebugFormat("Skipping {0}: hidden folder", localDirectory); return false; } if (directoryInfo.Attributes.HasFlag(FileAttributes.System)) { Logger.DebugFormat("Skipping {0}: system folder", localDirectory); return false; } } return true; }
/// <summary></summary> /// <param name="folder"></param> /// <param name="fileName"></param> /// <param name="repoInfo"></param> /// <returns></returns> public static SyncItem CreateFromRemotePath(string folder, string fileName, Config.SyncConfig.SyncFolder repoInfo) { return new RemotePathSyncItem(Path.Combine(folder, fileName), repoInfo); }
/// <summary></summary> /// <param name="remoteFolder"></param> /// <param name="LocalFileName"></param> /// <param name="repoInfo"></param> /// <returns></returns> public static SyncItem CreateFromRemoteFolderAndLocalName(string remoteFolder, string LocalFileName, Config.SyncConfig.SyncFolder repoInfo) { return new RemotePathSyncItem(remoteFolder, LocalFileName, repoInfo); }
/// <summary></summary> /// <param name="path"></param> /// <param name="repoInfo"></param> /// <returns></returns> public static SyncItem CreateFromRemotePath(string path, Config.SyncConfig.SyncFolder repoInfo) { return new RemotePathSyncItem(path, repoInfo); }
/// <summary></summary> /// <param name="localFolder"></param> /// <param name="remoteFileName"></param> /// <param name="repoInfo"></param> /// <returns></returns> public static SyncItem CreateFromLocalFolderAndRemoteName(string localFolder, string remoteFileName, Config.SyncConfig.SyncFolder repoInfo) { return new LocalPathSyncItem(localFolder, remoteFileName, repoInfo); }
/// <summary></summary> /// <param name="remotePath">either relative or absolute</param> /// <param name="syncFolderInfo"></param> public RemotePathSyncItem(string remotePath, Config.SyncConfig.SyncFolder syncFolderInfo) { this.localRootPath = syncFolderInfo.LocalPath; this.remoteRootPath = syncFolderInfo.RemotePath; this.remoteRelativePath = remotePath; if (remotePath.StartsWith(this.remoteRootPath)) { this.remoteRelativePath = remotePath.Substring(this.remoteRootPath.Length).TrimStart(CmisPath.DirectorySeparatorChar); } this.localRelativePath = PathRepresentationConverter.RemoteToLocal(this.remoteRelativePath); }
/// <summary> /// Remove a synchronized folder from the CmisSync configuration. /// This happens after the user removes the folder. /// </summary> /// <param name="folder_path">The synchronized folder to remove</param> private void RemoveRepository(Config.SyncConfig.Folder folder) { if (this.repositories.Count > 0) { for (int i = 0; i < this.repositories.Count; i++) { RepoBase repo = this.repositories[i]; if (repo.LocalPath.Equals(folder.LocalPath)) { repo.Dispose(); this.repositories.Remove(repo); repo = null; break; } } } // Remove Cmis Database File string dbfilename = folder.DisplayName; dbfilename = dbfilename.Replace("\\", "_"); dbfilename = dbfilename.Replace("/", "_"); RemoveDatabase(dbfilename); }
private void handleMissingSyncFolder(Config.SyncConfig.SyncFolder syncFolderInfo) { bool handled = false; while (handled == false) { Views.MissingFolderDialog dialog = new Views.MissingFolderDialog(syncFolderInfo); dialog.ShowDialog(); if (dialog.Result == Views.MissingFolderDialog.Action.MOVE) { String startPath = Directory.GetParent(syncFolderInfo.LocalPath).FullName; System.Windows.Forms.FolderBrowserDialog fbd = new System.Windows.Forms.FolderBrowserDialog(); fbd.SelectedPath = startPath; fbd.Description = "Select the folder you have moved or renamed"; fbd.ShowNewFolderButton = false; System.Windows.Forms.DialogResult result = fbd.ShowDialog(); if (result == System.Windows.Forms.DialogResult.OK && fbd.SelectedPath.Length > 0) { if (!Directory.Exists(fbd.SelectedPath)) { throw new InvalidDataException(); } Logger.Info("ControllerBase | Folder '" + syncFolderInfo.DisplayName + "' ('" + syncFolderInfo.LocalPath + "') moved to '" + fbd.SelectedPath + "'"); syncFolderInfo.LocalPath = fbd.SelectedPath; ConfigureAndStartSyncFolderSyncronization(syncFolderInfo); handled = true; } } else if (dialog.Result == Views.MissingFolderDialog.Action.REMOVE) { StopAndRemoveSyncFolderSyncronization(syncFolderInfo, true); ConfigManager.CurrentConfig.SyncFolders.Remove(syncFolderInfo); Logger.Info("ControllerBase | Removed folder '" + syncFolderInfo.DisplayName + "' from config"); handled = true; } else if (dialog.Result == Views.MissingFolderDialog.Action.RECREATE) { StopAndRemoveSyncFolderSyncronization(syncFolderInfo, true); AddAndStartNewSyncFolderSyncronization(syncFolderInfo); //TODO: also remove and recreate the config to ensure a fresh start Logger.Info("ControllerBase | Folder '" + syncFolderInfo.DisplayName + "' recreated"); handled = true; } else { throw new InvalidOperationException(); } } }
/// <summary> /// Get the list of repositories of a CMIS server /// Each item contains id + /// </summary> /// <returns>The list of repositories. Each item contains the identifier and the human-readable name of the repository.</returns> private static List<Config.SyncConfig.RemoteRepository> doGetRepositories(Config.SyncConfig.Account account) { // If no URL was provided, return empty result. if (account.RemoteUrl == null) { throw new System.ArgumentException(); } IList<IRepository> repositories; try { repositories = Auth.Auth.GetCmisRepositories(account.RemoteUrl, account.Credentials.UserName, account.Credentials.Password); } catch (CmisPermissionDeniedException e) { Logger.Error("CMIS server found, but permission denied. Please check username/password. ", e); throw; } catch (CmisRuntimeException e) { Logger.Error("No CMIS server at this address, or no connection. ", e); throw; } catch (CmisObjectNotFoundException e) { Logger.Error("No CMIS server at this address, or no connection. ", e); throw; } catch (CmisConnectionException e) { Logger.Error("No CMIS server at this address, or no connection. ", e); throw; } catch (CmisInvalidArgumentException e) { Logger.Error("Invalid URL, maybe Alfresco Cloud? ", e); throw; } List<Config.SyncConfig.RemoteRepository> result = new List<Config.SyncConfig.RemoteRepository>(); // Populate the result list with identifier and name of each repository. foreach (IRepository repo in repositories) { // Repo name is sometimes empty (ex: Alfresco), in such case show the repo id instead. string name = repo.Name.Length == 0 ? repo.Id : repo.Name; result.Add(new Config.SyncConfig.RemoteRepository(account, repo.Id, name)); } return result; }
private void StopAndRemoveSyncFolderSyncronization(Config.SyncConfig.SyncFolder syncFolderInfo, bool? keepLocalFiles = null) { bool found = false; //search and stop the syncher if already started foreach (CmisSync.Lib.Sync.SyncFolderSyncronizer syncher in this.SyncFolders) { //FIXME: can we identify a synced folder by it's localPath? if (syncFolderInfo.LocalPath.Equals(syncher.SyncFolderInfo.LocalPath)) { StopAndRemoveSyncFolderSyncronization(syncher, keepLocalFiles); found = true; break; } } if (found == false) { Logger.Warn("StopAndRemoveSyncFolderSyncronization(Config.SyncConfig.SyncFolder) cant find a SyncFolderSyncronizer for the provided SyncFolder (" + syncFolderInfo + "). The configuration will be removed from the CurrentConfig, but might be some leftover (local files, database, ecc...)"); ConfigManager.CurrentConfig.RemoveSyncFolder(syncFolderInfo); } }
/// <summary> /// Check whether the file is worth syncing or not. /// Files that are not worth syncing include temp files, locks, etc. /// </summary> public static Boolean IsWorthSyncing(string localDirectory, string filename, Config.SyncConfig.SyncFolder repoInfo) { return IsFilenameWorthSyncing(localDirectory, filename) && IsDirectoryWorthSyncing(localDirectory, repoInfo) && IsFileWorthSyncing(Path.Combine(localDirectory, filename), repoInfo); }
/// <summary> /// Try to find the CMIS server associated to any URL. /// Users can provide the URL of the web interface, and we have to return the CMIS URL /// Returns the list of repositories as well. /// </summary> public static ReadOnlyCollection<Config.SyncConfig.RemoteRepository> GetRepositories(Config.SyncConfig.Account account, bool discoverCorrectUriAndUpdate) { List<Config.SyncConfig.RemoteRepository> repositories = null; Exception firstException = null; // Try the given URL, maybe user directly entered the CMIS AtomPub endpoint URL. try { repositories = doGetRepositories(account); } catch (CmisRuntimeException e) { if (e.Message == "ConnectFailure") { throw new NetworkException(e); } firstException = e; } catch (Exception e) { // Save first Exception and try other possibilities. firstException = e; } if (repositories != null) { // Found! return new ReadOnlyCollection<Config.SyncConfig.RemoteRepository>(repositories); } if (discoverCorrectUriAndUpdate == false) { throw firstException; } // Extract protocol and server name or IP address string prefix = account.RemoteUrl.GetLeftPart(UriPartial.Authority); // See https://github.com/aegif/CmisSync/wiki/What-address for the list of ECM products prefixes // Please send us requests to support more CMIS servers: https://github.com/aegif/CmisSync/issues string[] suffixes = { "/alfresco/api/-default-/public/cmis/versions/1.1/atom", // Alfresco 4.2 CMIS 1.1 "/alfresco/api/-default-/public/cmis/versions/1.0/atom", // Alfresco 4.2 CMIS 1.0 "/alfresco/cmisatom", // Alfresco 4.0 and 4.1 "/alfresco/service/cmis", // Alfresco 3.x "/cmis/atom11", // OpenDataSpace "/rest/private/cmisatom/", // eXo Platform "/xcmis/rest/cmisatom", // xCMIS "/files/basic/cmis/my/servicedoc", // IBM Connections "/p8cmis/resources/Service", // IBM FileNet "/_vti_bin/cmis/rest?getRepositories", // Microsoft SharePoint "/nemakiware/atom/bedroom", // NemakiWare TODO: different port, typically 8080 for Web UI and 3000 for CMIS "/nuxeo/atom/cmis", // Nuxeo "/cmis/atom", "/cmis/resources/", // EMC Documentum "/emc-cmis-ea/resources/", // EMC Documentum "/emc-cmis-weblogic/resources/", // EMC Documentum "/emc-cmis-wls/resources/", // EMC Documentum "/emc-cmis-was61/resources/", // EMC Documentum "/emc-cmis-wls1030/resources/", // EMC Documentum "/docushare/ds_mobile_connector/atom", // Xerox DocuShare "/documents/ds_mobile_connector/atom" // Xerox DocuShare TODO: can be anything instead of "documents" }; Uri originalUrl = account.RemoteUrl; string bestUrl = null; // Try all suffixes for (int i = 0; i < suffixes.Length; i++) { string fuzzyUrl = prefix + suffixes[i]; Logger.Info("Sync | Trying with " + fuzzyUrl); try { account.RemoteUrl = new Uri(fuzzyUrl); repositories = doGetRepositories(account); } catch (CmisPermissionDeniedException e) { firstException = e; bestUrl = fuzzyUrl; } catch (Exception e) { // Do nothing, try other possibilities. Logger.Debug(e.Message); } if (repositories != null) { // Found! return new ReadOnlyCollection<Config.SyncConfig.RemoteRepository>(repositories); } } //restore the original url account.RemoteUrl = originalUrl; // Not found. Return also the first exception to inform the user correctly throw new ServerNotFoundException(firstException) { BestTryedUrl = new Uri(bestUrl) }; }
public static void TestAccount(Config.SyncConfig.Account account) { //TODO: can we perform a simplier test? ReadOnlyCollection<Config.SyncConfig.RemoteRepository> repositories = CmisUtils.GetRepositories(account, true); }
private void handleMissingSyncFolder(Config.SyncConfig.Folder f) { bool handled = false; while (handled == false) { MissingFolderDialog dialog = new MissingFolderDialog(f); dialog.ShowDialog(); if (dialog.action == MissingFolderDialog.Action.MOVE) { String startPath = Directory.GetParent(f.LocalPath).FullName; FolderBrowserDialog fbd = new FolderBrowserDialog(); fbd.SelectedPath = startPath; fbd.Description = "Select the folder you have moved or renamed"; fbd.ShowNewFolderButton = false; DialogResult result = fbd.ShowDialog(); if (result == DialogResult.OK && fbd.SelectedPath.Length > 0) { if (!Directory.Exists(fbd.SelectedPath)) { throw new InvalidDataException(); } Logger.Info("ControllerBase | Folder '" + f.DisplayName + "' ('" + f.LocalPath + "') moved to '" + fbd.SelectedPath + "'"); f.LocalPath = fbd.SelectedPath; AddRepository(f.GetRepoInfo()); handled = true; } } else if (dialog.action == MissingFolderDialog.Action.REMOVE) { RemoveRepository(f); ConfigManager.CurrentConfig.Folders.Remove(f); Logger.Info("ControllerBase | Removed folder '" + f.DisplayName + "' from config"); handled = true; } else if (dialog.action == MissingFolderDialog.Action.RECREATE) { RepoInfo info = f.GetRepoInfo(); RemoveRepository(f); ConfigManager.CurrentConfig.Folders.Remove(f); CreateRepository(info.Name, info.Address, info.User, info.Password.ToString(), info.RepoID, info.RemotePath, info.TargetDirectory, info.getIgnoredPaths().OfType<String>().ToList(), info.SyncAtStartup); Logger.Info("ControllerBase | Folder '" + f.DisplayName + "' recreated"); handled = true; } else { throw new InvalidOperationException(); } } //handled == true //now resume the sincronization (if ever was suspended) //FIXME: the problem is that if the user suspended this repo it will get resumed anyway (ignoring the user setting) Program.Controller.ResumeRepositorySynchronization(f.DisplayName); }
public SyncFolderViewModel(Controller controller, Config.SyncConfig.SyncFolder model) : base(controller) { this.model = model; }
/// <summary> /// Check whether the file is worth syncing or not. /// This optionally excludes blank files or files too large. /// </summary> public static bool IsFileWorthSyncing(string filepath, Config.SyncConfig.SyncFolder repoInfo) { if (File.Exists(filepath)) { bool allowBlankFiles = true; //TODO: add a preference repoInfo.allowBlankFiles bool limitFilesize = false; //TODO: add preference for filesize limiting long filesizeLimit = 256 * 1024 * 1024; //TODO: add a preference for filesize limit FileInfo fileInfo = new FileInfo(filepath); //Check permissions if (fileInfo.Attributes.HasFlag(FileAttributes.Hidden)) { Logger.DebugFormat("Skipping {0}: hidden file", filepath); return false; } if (fileInfo.Attributes.HasFlag(FileAttributes.System)) { Logger.DebugFormat("Skipping {0}: system file", filepath); return false; } //Check filesize if (!allowBlankFiles && fileInfo.Length <= 0) { Logger.DebugFormat("Skipping {0}: blank file", filepath); return false; } if (limitFilesize && fileInfo.Length > filesizeLimit) { Logger.DebugFormat("Skipping {0}: file too large {1}MB", filepath, fileInfo.Length / (1024f * 1024f)); return false; } } else if (Directory.Exists(filepath)) { return IsDirectoryWorthSyncing(filepath, repoInfo); } return true; }
/// <summary> /// Guess the web address where files can be seen using a browser. /// Not bulletproof. It depends on the server, and on some servers there is no web UI at all. /// </summary> public static string GetBrowsableURL(Config.SyncConfig.SyncFolder repo) { if (null == repo) { throw new ArgumentNullException("repo"); } // Case of Alfresco. string suffix1 = "alfresco/cmisatom"; string suffix2 = "alfresco/service/cmis"; if (repo.Account.RemoteUrl.AbsoluteUri.EndsWith(suffix1) || repo.Account.RemoteUrl.AbsoluteUri.EndsWith(suffix2)) { // Detect suffix length. int suffixLength = 0; if (repo.Account.RemoteUrl.AbsoluteUri.EndsWith(suffix1)) suffixLength = suffix1.Length; if (repo.Account.RemoteUrl.AbsoluteUri.EndsWith(suffix2)) suffixLength = suffix2.Length; string root = repo.Account.RemoteUrl.AbsoluteUri.Substring(0, repo.Account.RemoteUrl.AbsoluteUri.Length - suffixLength); if (repo.RemotePath.StartsWith("/Sites")) { // Case of Alfresco Share. // Example RemotePath: /Sites/thesite // Result: http://server/share/page/site/thesite/documentlibrary // Example RemotePath: /Sites/thesite/documentLibrary/somefolder/anotherfolder // Result: http://server/share/page/site/thesite/documentlibrary#filter=path|%2Fsomefolder%2Fanotherfolder // Example RemotePath: /Sites/s1/documentLibrary/éß和ệ // Result: http://server/share/page/site/s1/documentlibrary#filter=path|%2F%25E9%25DF%25u548C%25u1EC7 // Example RemotePath: /Sites/s1/documentLibrary/a#bc/éß和ệ // Result: http://server/share/page/site/thesite/documentlibrary#filter=path%7C%2Fa%2523bc%2F%25E9%25DF%25u548C%25u1EC7%7C string path = repo.RemotePath.Substring("/Sites/".Length); if (path.Contains("documentLibrary")) { int firstSlashPosition = path.IndexOf('/'); string siteName = path.Substring(0, firstSlashPosition); string pathWithinSite = path.Substring(firstSlashPosition + "/documentLibrary".Length); string escapedPathWithinSite = HttpUtility.UrlEncode(pathWithinSite); string reescapedPathWithinSite = HttpUtility.UrlEncode(escapedPathWithinSite); string sharePath = reescapedPathWithinSite.Replace("%252f", "%2F"); sharePath = sharePath.Replace("%2b", "%20"); return root + "share/page/site/" + siteName + "/documentlibrary#filter=path|" + sharePath; } else { // Site name only. return root + "share/page/site/" + path + "/documentlibrary"; } } else { // Case of Alfresco Web Client. Difficult to build a direct URL, so return root. return root; } } else { // Another server was detected, try to open the thinclient url, otherwise try to open the repo path try { // Connect to the CMIS repository. ISession session = Auth.Auth.GetCmisSession(repo.Account.RemoteUrl, repo.Account.Credentials, repo.RepositoryId); if (session.RepositoryInfo.ThinClientUri == null || String.IsNullOrEmpty(session.RepositoryInfo.ThinClientUri.ToString())) { Logger.Error("CmisUtils GetBrowsableURL | Repository does not implement ThinClientUri: " + repo.Account.RemoteUrl.AbsoluteUri); return repo.Account.RemoteUrl.AbsoluteUri + repo.RemotePath; } else { // Return CmisServer-provided thin URL. return session.RepositoryInfo.ThinClientUri.ToString(); } } catch (Exception e) { Logger.Error("CmisUtils GetBrowsableURL | Exception " + e.Message, e); // Server down or authentication problem, no way to know the right URL, so just open server. return repo.Account.RemoteUrl.AbsoluteUri + repo.RemotePath; } } }
/// <summary> /// Remove a synchronized folder from the CmisSync configuration. /// This happens after the user removes the folder. /// </summary> /// <param name="folder">The synchronized folder to remove</param> private void RemoveRepository(Config.SyncConfig.Folder folder) { foreach (RepoBase repo in this.repositories) { if (repo.LocalPath.Equals(folder.LocalPath)) { repo.CancelSync(); repo.Dispose(); this.repositories.Remove(repo); Logger.Info("Removed Repository: " + repo.Name); break; } } // Remove Cmis Database File string dbfilename = folder.DisplayName; dbfilename = dbfilename.Replace("\\", "_"); dbfilename = dbfilename.Replace("/", "_"); RemoveDatabase(dbfilename); }
public RepositoryViewModel(Config.SyncConfig.RemoteRepository repo) : base(null, repo) { }