public CMISFolder GetSubfolder(CMISFolder baseFolder, string pathExtension, string folderType)
{
IDictionary <string, object> props = new Dictionary <string, object>();
props["cmis:objectTypeId"] = folderType;
IFolder currFolder = baseFolder.IFolder(session);
foreach (string element in pathExtension.Split('/'))
{
if (element == string.Empty)
{
continue; // ignore leadiong "/"
}
List <ICmisObject> childs = currFolder.GetChildren().Where(n => n.Name == element && n is IFolder).ToList();
if (childs.Count > 0)
{
// if subfolder already exists -> use it
currFolder = (IFolder)childs[0];
continue;
}
// else create it
props[PropertyIds.Name] = element;
currFolder = currFolder.CreateFolder(props);
}
return(new CMISFolder(currFolder, session));
}
public IFolder CreateFolder(CmisPath path, bool recursive,
IDictionary <string, object> properties)
{
path = path.WithoutTrailingSlash();
if (recursive)
{
// check if it already exists and proceed to create otherwise
try
{
return(GetFolder(path));
}
catch (CmisObjectNotFoundException)
{
}
}
var components = path.GetComponents();
var dirname = components[0];
var basename = components[1];
IFolder parent = recursive ? CreateFolder(dirname, true, null) : GetFolder(dirname);
var allProps = new Dictionary <string, object>()
{
{ PropertyIds.ObjectTypeId, "cmis:folder" },
{ PropertyIds.Name, basename }
};
Utilities.UpdateDictionary(allProps, properties);
return(parent.CreateFolder(allProps));
}
public void RemoteFolderDeletion(string ignoredCanonicalName, string ignoredLocalPath, string remoteFolderPath,
string url, string user, string password, string repositoryId)
{
// Prepare remote folder and CmisSync process.
IFolder remoteBaseFolder = ClearRemoteCMISFolder(url, user, password, repositoryId, remoteFolderPath);
sync = new CmisSyncProcess(remoteFolderPath, url, user, password, repositoryId);
// Create remote folder
string foldername = "folder1";
IDictionary <string, object> properties = new Dictionary <string, object>();
properties[PropertyIds.Name] = foldername;
properties[PropertyIds.ObjectTypeId] = "cmis:folder";
IFolder folder = remoteBaseFolder.CreateFolder(properties);
// Wait for a few seconds so that sync gets a chance to sync things.
Thread.Sleep(20 * 1000);
// Check locally
Assert.True(Directory.Exists(Path.Combine(sync.Folder(), (String)properties[PropertyIds.Name])));
// Delete the folder.
folder.DeleteTree(true, null, true);
// Wait for 10 seconds so that sync gets a chance to sync things.
Thread.Sleep(10 * 1000);
// Check locally
Assert.False(Directory.Exists(Path.Combine(sync.Folder(), (String)properties[PropertyIds.Name])));
}
public override WebDAVResponse CopyTo(IFolder folder, string destName, bool deep)
{
MultistatusResponse response = new MultistatusResponse();
DirectoryInfo currentDir = fileSystemInfo as DirectoryInfo;
string newFullDir = (folder as Folder).GetFullPath() + '\\' + destName;
string newHierDir = (folder as Folder).GetHierarchyPath() + '/' + destName;
if (!Directory.Exists(newFullDir))
{
response.AddResponses(new ItemResponse(newHierDir, folder.CreateFolder(destName)));
}
if (currentDir != null)
{
if (deep)
{
response.AddResponses(CopyFoldersStructure(currentDir,
new DirectoryInfo(newFullDir)));
}
else
{
response.AddResponses(CopyAllFilesFromFolder(currentDir,
new DirectoryInfo(newFullDir)));
}
}
return(response);
}
public NtStatus CreateDirectory(string fileName, DokanFileInfo info)
{
var cmisPath = fileName.Replace("\\", "/");
var baseDirectoryPath = cmisPath.Substring(0, cmisPath.LastIndexOf("/") + "/".Length);
var newDirectoryName = cmisPath.Substring(baseDirectoryPath.Length);
//if (Directory.Exists(GetPath(fileName))) TODO port to CMIS, not urgent
// return Trace("CreateDirectory", fileName, info, DokanResult.FileExists);
try
{
// Create CMIS folder.
IFolder cmisFolder = (IFolder)cmisSession.GetObjectByPath(baseDirectoryPath);
Dictionary <string, object> properties = new Dictionary <string, object>();
properties.Add(PropertyIds.Name, newDirectoryName);
properties.Add(PropertyIds.ObjectTypeId, "cmis:folder");
cmisFolder.CreateFolder(properties);
//Directory.CreateDirectory(GetPath(fileName));
return(Trace("CreateDirectory", fileName, info, DokanResult.Success));
}
catch (Exception) // TODO
{
return(Trace("CreateDirectory", fileName, info, DokanResult.AccessDenied));
}
}
private void GenerateReferences(IEnumerable <SteamAppBranch> toDownload)
{
foreach (var branch in toDownload)
{
var depotsFolder = ExecutableFolder
.GetFolder("depots")
.GetFolder(_options.SteamDepotId.ToString())
.GetFolder(branch.BuildId.ToString());
var refFolder = ExecutableFolder
.CreateFolder("ref", CreationCollisionOption.OpenIfExists)
.CreateFolder(_options.SteamDepotId.ToString(), CreationCollisionOption.OpenIfExists)
.CreateFolder(branch.BuildId.ToString(), CreationCollisionOption.OpenIfExists);
// core
var coreRefFolder = refFolder
.GetModuleFolder("")
.CreateFolder("bin", CreationCollisionOption.OpenIfExists)
.CreateFolder("Win64_Shipping_Client", CreationCollisionOption.OpenIfExists);
GenerateReference("", depotsFolder, coreRefFolder);
// official modules
foreach (var module in depotsFolder.GetFolder("Modules").GetFolders())
{
var name = module.Name;
var moduleOutputFolder = refFolder
.GetModuleFolder(name, false)
.CreateFolder("bin", CreationCollisionOption.OpenIfExists)
.CreateFolder("Win64_Shipping_Client", CreationCollisionOption.OpenIfExists);
GenerateReference(name, module, moduleOutputFolder);
}
}
}
public void Undo()
{
if (_FolderDeleted)
{
_Folder.CreateFolder();
}
}
/**
* Upload folder recursively.
* After execution, the hierarchy on server will be: .../remoteBaseFolder/localFolder/...
*/
private void UploadFolderRecursively(IFolder remoteBaseFolder, string localFolder)
{
// Create remote folder.
Dictionary <string, object> properties = new Dictionary <string, object>();
properties.Add(PropertyIds.Name, Path.GetFileName(localFolder));
properties.Add(PropertyIds.ObjectTypeId, "cmis:folder");
IFolder folder = remoteBaseFolder.CreateFolder(properties);
// Create database entry for this folder
// TODO - Yannick - Add metadata
database.AddFolder(localFolder, folder.LastModificationDate);
// Upload each file in this folder.
foreach (string file in Directory.GetFiles(localFolder))
{
if (CheckRules(file, RulesType.File))
{
UploadFile(file, folder);
}
}
// Recurse for each subfolder in this folder.
foreach (string subfolder in Directory.GetDirectories(localFolder))
{
if (CheckRules(subfolder, RulesType.Folder))
{
UploadFolderRecursively(folder, subfolder);
}
}
}
public void RemovingRemoteFolderAndAddingADocumentToItShouldThrowException(
string canonical_name,
string localPath,
string remoteFolderPath,
string url,
string user,
string password,
string repositoryId,
string binding)
{
string subFolderName = "subFolder";
ISession session = DotCMISSessionTests.CreateSession(user, password, url, repositoryId, binding);
try {
IFolder dir = session.GetObjectByPath(remoteFolderPath.TrimEnd('/') + "/" + subFolderName) as IFolder;
if (dir != null)
{
dir.DeleteTree(true, null, true);
}
} catch (CmisObjectNotFoundException) {
}
IFolder folder = (IFolder)session.GetObjectByPath(remoteFolderPath);
IFolder subFolder = folder.CreateFolder(subFolderName);
IFolder subFolderInstanceCopy = (IFolder)session.GetObject(subFolder.Id);
subFolder.DeleteTree(true, null, true);
Assert.Throws <CmisObjectNotFoundException>(() => subFolderInstanceCopy.CreateDocument("testFile.bin", "testContent"));
}
private async Task Add(IFolder folder, IEnumerable <string> files)
{
foreach (var file in files)
{
if (Status == OperationStatus.Cancel)
{
return;
}
if (Status == OperationStatus.Paused)
{
await _resumeEvent.WaitAsync();
if (Status == OperationStatus.Cancel)
{
return;
}
Status = OperationStatus.Work;
}
var di = new DirectoryInfo(file);
if (di.Exists)
{
var subFolder = folder.Folders.FirstOrDefault(x => x.Name.Equals(di.Name, StringComparison.OrdinalIgnoreCase)) ??
folder.CreateFolder(di.Name);
var subFiles = Directory.EnumerateDirectories(di.FullName, "*", SearchOption.TopDirectoryOnly)
.Concat(Directory.EnumerateFiles(di.FullName, "*", SearchOption.TopDirectoryOnly));
await Add(subFolder, subFiles);
continue;
}
var fileName = Path.GetFileName(file);
var data = File.ReadAllBytes(file);
var oldFile = folder.Files.FirstOrDefault(x => x.Name.Equals(fileName, StringComparison.OrdinalIgnoreCase));
if (oldFile == null)
{
folder.CreateFile(fileName, data);
}
else
{
// TODO Need get window somehow - Time to use IoC?
// TODO "Yes All" and "No All" would be cool
var result = await Observable.Start(() => TaskDialog.Show(Program.Window,
$"{oldFile.Parent.FullName + oldFile.Name} already exists. Do you want to replace it?",
buttons: TaskDialogStandardButtons.Yes | TaskDialogStandardButtons.No),
RxApp.MainThreadScheduler)
.ToTask();
if (result == TaskDialogResult.Yes)
{
oldFile.SetData(data);
}
}
++Progress;
}
}
public void Execute()
{
if (!_Folder.FolderExists())
{
_Folder.CreateFolder();
_FolderCreatedByCommand = true;
}
}
/// <summary>
/// Creates a sub folder with the given name.
/// </summary>
/// <returns>The created folder.</returns>
/// <param name="folder">parent folder.</param>
/// <param name="name">Name of the new sub folder.</param>
public static IFolder CreateFolder(this IFolder folder, string name)
{
Dictionary <string, object> properties = new Dictionary <string, object>();
properties.Add(PropertyIds.Name, name);
properties.Add(PropertyIds.ObjectTypeId, BaseTypeId.CmisFolder.GetCmisValue());
return(folder.CreateFolder(properties));
}
public IFolder CreateFolder(IFolder parent, string name)
{
IDictionary <string, object> props = new Dictionary <string, object>();
props[PropertyIds.Name] = name;
props[PropertyIds.ObjectTypeId] = "cmis:folder";
return(parent.CreateFolder(props));
}
protected IFolder CreateRemoteFolder(IFolder folder, string name)
{
Dictionary <string, object> properties = new Dictionary <string, object>();
properties.Add(PropertyIds.Name, name);
properties.Add(PropertyIds.ObjectTypeId, "cmis:folder");
return(folder.CreateFolder(properties));
}
public void Init()
{
this.subfolder = SubfolderBase + Guid.NewGuid().ToString();
Console.WriteLine("Working on " + this.subfolder);
// RepoInfo
this.repoInfo = new RepoInfo {
AuthenticationType = AuthenticationType.BASIC,
LocalPath = Path.Combine(config[1].ToString(), this.subfolder),
RemotePath = config[2].ToString() + "/" + this.subfolder,
Address = new XmlUri(new Uri(config[3].ToString())),
User = config[4].ToString(),
RepositoryId = config[6].ToString()
};
this.repoInfo.RemotePath = this.repoInfo.RemotePath.Replace("//", "/");
this.repoInfo.SetPassword(config[5].ToString());
// FileSystemDir
this.localRootDir = new DirectoryInfo(this.repoInfo.LocalPath);
this.localRootDir.Create();
// Repo
var activityListener = new Mock <IActivityListener>();
var transmissionManager = new ActiveActivitiesManager();
var activityAggregator = new ActivityListenerAggregator(activityListener.Object, transmissionManager);
var queue = new SingleStepEventQueue(new SyncEventManager());
this.repo = new CmisRepoMock(this.repoInfo, activityAggregator, queue);
// Session
var cmisParameters = new Dictionary <string, string>();
cmisParameters[SessionParameter.BindingType] = BindingType.AtomPub;
cmisParameters[SessionParameter.AtomPubUrl] = this.repoInfo.Address.ToString();
cmisParameters[SessionParameter.User] = this.repoInfo.User;
cmisParameters[SessionParameter.Password] = this.repoInfo.GetPassword().ToString();
cmisParameters[SessionParameter.RepositoryId] = this.repoInfo.RepositoryId;
SessionFactory factory = SessionFactory.NewInstance();
this.session = factory.CreateSession(cmisParameters);
IFolder root = (IFolder)this.session.GetObjectByPath(config[2].ToString());
foreach (var child in root.GetChildren())
{
if (child is IFolder && child.Name == this.subfolder)
{
(child as IFolder).DeleteTree(true, null, true);
}
}
root.Refresh();
this.remoteRootDir = root.CreateFolder(this.subfolder);
}
private static IFolder CreateFolder(IFolder target, String newFolderName)
{
IDictionary <string, object> props = new Dictionary <string, object>();
props.Add(PropertyIds.ObjectTypeId, "cmis:folder");
props.Add(PropertyIds.Name, newFolderName);
IFolder newFolder = target.CreateFolder(props);
return(newFolder);
}
private static IFolder CreateFolderPath(IFolder rootFolder, string folderPath)
{
var paths = folderPath.Split(new[] { Path.DirectorySeparatorChar }, StringSplitOptions.RemoveEmptyEntries);
foreach (var path in paths)
{
rootFolder = rootFolder.CreateFolder(path);
}
return(rootFolder);
}
public void _CurrentlyFailing_RemoteFolderRename(string ignoredCanonicalName, string ignoredLocalPath, string remoteFolderPath,
string url, string user, string password, string repositoryId)
{
// Prepare remote folder and CmisSync process.
IFolder remoteBaseFolder = ClearRemoteCMISFolder(url, user, password, repositoryId, remoteFolderPath);
sync = new CmisSyncProcess(remoteFolderPath, url, user, password, repositoryId);
// Create remote folder
string foldername = "folder1";
IDictionary <string, object> folderProperties = new Dictionary <string, object>();
folderProperties[PropertyIds.Name] = foldername;
folderProperties[PropertyIds.ObjectTypeId] = "cmis:folder";
IFolder folder = remoteBaseFolder.CreateFolder(folderProperties);
// Create remote file inside that folder.
string filename = "document.txt";
IDictionary <string, object> properties = new Dictionary <string, object>();
properties[PropertyIds.Name] = filename;
properties[PropertyIds.ObjectTypeId] = "cmis:document";
string contentString = "Hello World!";
byte[] creationContent = UTF8Encoding.UTF8.GetBytes(contentString);
ContentStream creationContentStream = new ContentStream();
creationContentStream.FileName = filename;
creationContentStream.MimeType = "text/plain";
creationContentStream.Length = creationContent.Length;
creationContentStream.Stream = new MemoryStream(creationContent);
IDocument doc = folder.CreateDocument(properties, creationContentStream, null);
// Check locally
Thread.Sleep(20 * 1000);
string syncedContent = File.ReadAllText(Path.Combine(sync.Folder(), foldername, filename));
Assert.AreEqual(contentString, syncedContent);
Assert.True(Directory.Exists(Path.Combine(sync.Folder(), foldername)));
// Rename folder
string newFoldername = "renamed folder";
folder.Rename(newFoldername);
// Check locally
Thread.Sleep(20 * 1000);
Assert.True(File.Exists(Path.Combine(sync.Folder(), newFoldername, filename)), "File not present where it should be");
syncedContent = File.ReadAllText(Path.Combine(sync.Folder(), foldername, filename));
Assert.AreEqual(contentString, syncedContent);
Assert.False(File.Exists(Path.Combine(sync.Folder(), foldername, filename)), "File present where it should not be");
}
public static bool Save(ImageFolder sub_folder, string filename, byte[] data)
{
IFolder rootFolder = Plugin.NetStandardStorage.CrossStorage.FileSystem.LocalStorage;
IFolder folder = rootFolder.CreateFolder(sub_folder.ToString(), CreationCollisionOption.OpenIfExists);
IFile file = folder.CreateFile(filename, CreationCollisionOption.ReplaceExisting);
using (Stream stream = file.Open(FileAccess.ReadWrite))
{
stream.Write(data, 0, data.Length);
}
return(true);
}
public async Task <IFolder> CreateFolderAsync(IFolder parentFolder, string folderName, CreationCollisionOption creationCollisionOption)
{
await Semaphore.WaitAsync();
try
{
return(parentFolder.CreateFolder(folderName, creationCollisionOption));
}
finally
{
Semaphore.Release();
}
}
/// <summary>
/// Upload folder recursively.
/// After execution, the hierarchy on server will be: .../remoteBaseFolder/localFolder/...
/// </summary>
private void UploadFolderRecursively(IFolder remoteBaseFolder, string localFolder)
{
sleepWhileSuspended();
IFolder folder;
try
{
// Create remote folder.
Dictionary <string, object> properties = new Dictionary <string, object>();
properties.Add(PropertyIds.Name, Path.GetFileName(localFolder));
properties.Add(PropertyIds.ObjectTypeId, "cmis:folder");
properties.Add(PropertyIds.CreationDate, Directory.GetCreationTime(localFolder));
properties.Add(PropertyIds.LastModificationDate, Directory.GetLastWriteTime(localFolder));
folder = remoteBaseFolder.CreateFolder(properties);
// Create database entry for this folder
database.AddFolder(localFolder, folder.LastModificationDate);
Logger.Info("Added folder to database: " + localFolder);
}
catch (CmisBaseException e)
{
ProcessRecoverableException("Could not create remote directory: " + remoteBaseFolder.Path + "/" + Path.GetFileName(localFolder), e);
return;
}
try
{
// Upload each file in this folder.
foreach (string file in Directory.GetFiles(localFolder))
{
if (Utils.WorthSyncing(localFolder, Path.GetFileName(file), repoinfo))
{
UploadFile(file, folder);
}
}
// Recurse for each subfolder in this folder.
foreach (string subfolder in Directory.GetDirectories(localFolder))
{
if (Utils.WorthSyncing(localFolder, Path.GetFileName(subfolder), repoinfo))
{
UploadFolderRecursively(folder, subfolder);
}
}
}
catch (Exception e)
{
ProcessRecoverableException("Could not uploading folder: " + localFolder, e);
}
}
/// <summary>
/// Upload folder recursively.
/// After execution, the hierarchy on server will be: .../remoteBaseFolder/localFolder/...
/// </summary>
private void UploadFolderRecursively(IFolder remoteBaseFolder, string localFolder)
{
// Create remote folder.
Dictionary <string, object> properties = new Dictionary <string, object>();
properties.Add(PropertyIds.Name, Path.GetFileName(localFolder));
properties.Add(PropertyIds.ObjectTypeId, "cmis:folder");
IFolder folder = remoteBaseFolder.CreateFolder(properties);
// Create database entry for this folder
// TODO Add metadata
database.AddFolder(localFolder, folder.LastModificationDate);
try
{
// Upload each file in this folder.
foreach (string file in Directory.GetFiles(localFolder))
{
if (Utils.WorthSyncing(file))
{
UploadFile(file, folder);
}
}
// Recurse for each subfolder in this folder.
foreach (string subfolder in Directory.GetDirectories(localFolder))
{
string path = subfolder.Substring(repoinfo.TargetDirectory.Length);
path = path.Replace("\\\\", "/");
if (Utils.WorthSyncing(subfolder) && !repoinfo.isPathIgnored(path))
{
UploadFolderRecursively(folder, subfolder);
}
}
}
catch (Exception e)
{
if (e is System.IO.DirectoryNotFoundException ||
e is IOException)
{
Logger.Warn("Folder deleted while trying to upload it, reverting.");
// Folder has been deleted while we were trying to upload/checksum/add.
// In this case, revert the upload.
folder.DeleteTree(true, null, true);
}
else
{
throw;
}
}
}
public void RemoteDocumentDeletionThenSameNameFolderCreation(string ignoredCanonicalName, string ignoredLocalPath, string remoteFolderPath,
string url, string user, string password, string repositoryId)
{
// Prepare remote folder and CmisSync process.
IFolder remoteBaseFolder = ClearRemoteCMISFolder(url, user, password, repositoryId, remoteFolderPath);
sync = new CmisSyncProcess(remoteFolderPath, url, user, password, repositoryId);
// Remote file creation
string remoteObjectName = "document.or.folder";
// Create remote file
IDictionary <string, object> properties = new Dictionary <string, object>();
properties[PropertyIds.Name] = remoteObjectName;
properties[PropertyIds.ObjectTypeId] = "cmis:document";
byte[] creationContent = UTF8Encoding.UTF8.GetBytes("Hello World!");
ContentStream creationContentStream = new ContentStream();
creationContentStream.FileName = remoteObjectName;
creationContentStream.MimeType = "text/plain";
creationContentStream.Length = creationContent.Length;
creationContentStream.Stream = new MemoryStream(creationContent);
IDocument document = remoteBaseFolder.CreateDocument(properties, creationContentStream, null);
// Wait for 10 seconds so that sync gets a chance to sync things.
Thread.Sleep(10 * 1000);
// Check locally
Assert.True(File.Exists(Path.Combine(sync.Folder(), remoteObjectName)));
// Delete remote document
document.DeleteAllVersions();
// Immediately create remote folder with exact same name
IDictionary <string, object> folderProperties = new Dictionary <string, object>();
folderProperties[PropertyIds.Name] = remoteObjectName;
folderProperties[PropertyIds.ObjectTypeId] = "cmis:folder";
IFolder folder = remoteBaseFolder.CreateFolder(folderProperties);
// Wait for 10 seconds so that sync gets a chance to sync things.
Thread.Sleep(10 * 1000);
// Check locally
Assert.True(Directory.Exists(Path.Combine(sync.Folder(), remoteObjectName)));
}
public void CheckoutTest(
string canonical_name,
string localPath,
string remoteFolderPath,
string url,
string user,
string password,
string repositoryId,
string binding)
{
string subFolderName = "subFolder";
string fileName = "testFile.bin";
string subFolderPath = remoteFolderPath.TrimEnd('/') + "/" + subFolderName;
string filePath = subFolderPath + "/" + fileName;
ISession session = DotCMISSessionTests.CreateSession(user, password, url, repositoryId, binding);
if (!session.ArePrivateWorkingCopySupported())
{
Assert.Ignore("PWCs are not supported");
}
try {
IFolder dir = session.GetObjectByPath(remoteFolderPath.TrimEnd('/') + "/" + subFolderName) as IFolder;
if (dir != null)
{
dir.DeleteTree(true, null, true);
}
} catch (CmisObjectNotFoundException) {
}
IFolder folder = (IFolder)session.GetObjectByPath(remoteFolderPath);
IFolder subFolder = folder.CreateFolder(subFolderName);
IDocument doc = subFolder.CreateDocument(fileName, "testContent", checkedOut: true);
IObjectId checkoutId = doc.CheckOut();
IDocument docCheckout = (IDocument)session.GetObject(checkoutId);
Assert.AreEqual(doc.ContentStreamLength, docCheckout.ContentStreamLength);
doc.Refresh();
Assert.IsTrue(doc.IsVersionSeriesCheckedOut.GetValueOrDefault());
Assert.AreEqual(checkoutId.Id, doc.VersionSeriesCheckedOutId);
docCheckout.CancelCheckOut();
doc.Refresh();
Assert.IsFalse(doc.IsVersionSeriesCheckedOut.GetValueOrDefault());
Assert.IsNull(doc.VersionSeriesCheckedOutId);
}
private IAddressBook CreateGABContacts(string domainName)
{
if (_store != null)
{
_store.Dispose();
_store = null;
}
_store = ZPushLocalStore.GetInstance(ThisAddIn.Instance);
if (_store == null)
{
return(null);
}
// Try to find the existing GAB
using (IFolder root = _store.GetRootFolder())
{
IAddressBook gab = FindGABForDomain(root, domainName);
if (gab == null)
{
Logger.Instance.Debug(this, "Creating new GAB folder for {0}", domainName);
string name = string.Format(Properties.Resources.GAB_FolderFormat, domainName);
gab = root.CreateFolder <IAddressBook>(name);
}
else
{
Logger.Instance.Debug(this, "Found existing GAB folder for {0}", domainName);
}
// The local folders are hidden, unhide tha GAB folder
gab.AttrHidden = false;
// Update admin
_gabFolders.Add(gab.EntryID);
GABInfo gabInfo = GABInfo.Get(gab, domainName);
gabInfo.Store(gab);
if (SuppressModifications)
{
// Hook BeforeMove event to prevent modifications
// TODO: use ZPushWatcher for this?
gab.BeforeItemMove += SuppressMoveEventHandler;
}
return(gab);
}
}
public void RenameRemoteFolderChangesChangeLogToken(
string canonical_name,
string localPath,
string remoteFolderPath,
string url,
string user,
string password,
string repositoryId)
{
ISession session = DotCMISSessionTests.CreateSession(user, password, url, repositoryId);
IFolder rootFolder = (IFolder)session.GetObjectByPath(remoteFolderPath);
string folderName = "1";
string newFolderName = "2";
Dictionary <string, object> properties = new Dictionary <string, object>();
properties.Add(PropertyIds.Name, folderName);
properties.Add(PropertyIds.ObjectTypeId, "cmis:folder");
try {
IFolder folder = session.GetObjectByPath(remoteFolderPath + "/" + folderName) as IFolder;
if (folder != null)
{
folder.Delete(true);
}
folder = session.GetObjectByPath(remoteFolderPath + "/" + newFolderName) as IFolder;
if (folder != null)
{
folder.Delete(true);
}
}
catch (CmisObjectNotFoundException) {
}
IFolder newFolder = rootFolder.CreateFolder(properties);
string changeLogToken = session.RepositoryInfo.LatestChangeLogToken;
string changeToken = newFolder.ChangeToken;
newFolder.Rename(newFolderName, true);
Assert.That(newFolder.ChangeToken, Is.Not.EqualTo(changeToken));
newFolder.Delete(true);
}
public static byte[] Load(ImageFolder sub_folder, string filename)
{
IFolder rootFolder = Plugin.NetStandardStorage.CrossStorage.FileSystem.LocalStorage;
IFolder folder = rootFolder.CreateFolder(sub_folder.ToString(), CreationCollisionOption.OpenIfExists);
if (!folder.CheckFileExists(folder.FullPath + "/" + filename))
{
return(null);
}
IFile file = folder.GetFile(filename);
using (Stream stream = file.Open(FileAccess.ReadWrite))
{
long length = stream.Length;
byte[] streamBuffer = new byte[length];
stream.Read(streamBuffer, 0, (int)length);
return(streamBuffer);
}
}
public void RenameRemoteFolderChangesChangeLogToken(
string canonical_name,
string localPath,
string remoteFolderPath,
string url,
string user,
string password,
string repositoryId,
string binding)
{
ISession session = DotCMISSessionTests.CreateSession(user, password, url, repositoryId, binding);
IFolder rootFolder = (IFolder)session.GetObjectByPath(remoteFolderPath);
string folderName = "1";
string newFolderName = "2";
try {
IFolder folder = session.GetObjectByPath(remoteFolderPath.TrimEnd('/') + "/" + folderName) as IFolder;
if (folder != null)
{
folder.DeleteTree(true, null, true);
}
folder = session.GetObjectByPath(remoteFolderPath.TrimEnd('/') + "/" + newFolderName) as IFolder;
if (folder != null)
{
folder.DeleteTree(true, null, true);
}
}
catch (CmisObjectNotFoundException) {
}
IFolder newFolder = rootFolder.CreateFolder(folderName);
string changeLogToken = session.RepositoryInfo.LatestChangeLogToken;
string changeToken = newFolder.ChangeToken;
newFolder.Rename(newFolderName, true);
Assert.That(newFolder.ChangeToken, Is.Not.EqualTo(changeToken));
newFolder.DeleteTree(true, null, true);
}
public IFolder CreateOrUpdateFolder(string name, string description, IFolder parent)
{
try
{
// Too long names gives problems
if (name.Length > 240)
{
name = name.Substring(0, 240);
}
name = GetValidFileName(name);
var folder = parent.GetDescendants(1)?.FirstOrDefault(c => ComparisonByIdIfPossible(c.Item, name))?.Item as IFolder;
if (folder == null)
{
Log.Information($"Create folder: {name}");
folder = parent.CreateFolder(new Dictionary <string, object>
{
{ PropertyIds.ObjectTypeId, "cmis:folder" },
{ PropertyIds.Name, name.Trim() },
{ "cmis:description", description }
});
}
else
{
Log.Information($"Update folder: {name}");
folder.UpdateProperties(new Dictionary <string, object>
{
{ PropertyIds.Name, name },
{ "cmis:description", description }
});
}
return(folder);
}
catch (Exception ex)
{
Log.Error(ex, $"Failed to create or update folder: {name}");
return(null);
}
}
public void RemovingRemoteFolderAndAddingADocumentToItShouldThrowException(
string canonical_name,
string localPath,
string remoteFolderPath,
string url,
string user,
string password,
string repositoryId)
{
ISession session = DotCMISSessionTests.CreateSession(user, password, url, repositoryId);
IFolder folder = (IFolder)session.GetObjectByPath(remoteFolderPath);
IFolder subFolder = folder.CreateFolder("subFolder");
IFolder subFolderInstanceCopy = (IFolder)session.GetObject(subFolder.Id);
subFolder.DeleteTree(true, null, true);
Assert.Throws <CmisObjectNotFoundException>(() => subFolderInstanceCopy.CreateDocument("testFile.bin", "testContent"));
}
private void SetDaysFolder(event_followup_log followup, ref IFolder folder)
{
var date = followup.date_created.Value;
string year = date.Year.ToString();
string month = date.Month.ToString();
string days = date.Day.ToString();
if (folder.ItemExists(year))
folder = folder.GetFolder(year);
else
{
folder = folder.CreateFolder(year);
}
if (folder.ItemExists(month))
folder = folder.GetFolder(month);
else
folder = folder.CreateFolder(month);
if (folder.ItemExists(days))
folder = folder.GetFolder(days);
else
folder = folder.CreateFolder(days);
}
/**
* Crawl local folders in a given directory (not recursive).
*/
private void crawlLocalFolders(string localFolder, IFolder remoteFolder, IList remoteFolders)
{
foreach (string folderPath in Directory.GetDirectories(localFolder))
{
string folderName = Path.GetFileName(folderPath);
if (!remoteFolders.Contains(folderName))
{
// This local folder is not on the CMIS server now, so
// check whether it used to exist on server or not.
if(database.ContainsFolder(folderPath))
{
// Folder has been deleted on server, delete it locally too.
SparkleLogger.LogInfo("Sync", "Removing remotely deleted folder: " + folderPath);
Directory.Delete(folderPath, true);
// Delete folder from database.
database.RemoveFolder(folderPath);
}
else
{
if (BIDIRECTIONAL)
{
// New folder, sync up.
Dictionary<string, object> properties = new Dictionary<string, object>();
properties.Add(PropertyIds.Name, folderName);
properties.Add(PropertyIds.ObjectTypeId, "cmis:folder");
IFolder folder = remoteFolder.CreateFolder(properties);
// Create database entry for this folder.
database.AddFolder(folderPath, folder.LastModificationDate);
}
}
}
}
}
public IFolder CreateFolder(IFolder folder, string name)
{
Dictionary<string, object> properties = new Dictionary<string, object>();
properties.Add(PropertyIds.Name, name);
properties.Add(PropertyIds.ObjectTypeId, "cmis:folder");
return folder.CreateFolder(properties);
}
/// <summary>
/// Upload folder recursively.
/// After execution, the hierarchy on server will be: .../remoteBaseFolder/localFolder/...
/// </summary>
private bool UploadFolderRecursively(IFolder remoteBaseFolder, string localFolder)
{
bool success = true;
SleepWhileSuspended();
IFolder folder = null;
try
{
var syncItem = database.GetFolderSyncItemFromLocalPath(localFolder);
if (null == syncItem)
{
syncItem = SyncItemFactory.CreateFromLocalPath(localFolder, repoinfo);
}
// Create remote folder.
Dictionary<string, object> properties = new Dictionary<string, object>();
properties.Add(PropertyIds.Name, syncItem.RemoteFileName);
properties.Add(PropertyIds.ObjectTypeId, "cmis:folder");
properties.Add(PropertyIds.CreationDate, Directory.GetCreationTime(localFolder));
properties.Add(PropertyIds.LastModificationDate, Directory.GetLastWriteTime(localFolder));
try
{
Logger.Debug(String.Format("Creating remote folder {0} for local folder {1}", syncItem.RemoteFileName, localFolder));
folder = remoteBaseFolder.CreateFolder(properties);
Logger.Debug(String.Format("Created remote folder {0}({1}) for local folder {2}", syncItem.RemoteFileName, folder.Id ,localFolder));
}
catch (CmisNameConstraintViolationException)
{
foreach (ICmisObject cmisObject in remoteBaseFolder.GetChildren())
{
if (cmisObject.Name == syncItem.RemoteFileName)
{
folder = cmisObject as IFolder;
}
}
if (folder == null)
{
Logger.Warn("Remote file conflict with local folder " + syncItem.LocalFileName);
// TODO Show error message
return false;
}
success = false;
}
catch (Exception e)
{
ProcessRecoverableException(String.Format("Exception when create remote folder for local folder {0}: {1}", localFolder, e.Message), e);
return false;
}
// Create database entry for this folder
// TODO Add metadata
database.AddFolder(syncItem, folder.Id, folder.LastModificationDate);
Logger.Info("Added folder to database: " + localFolder);
}
catch (CmisBaseException e)
{
ProcessRecoverableException("Could not create remote directory: " + remoteBaseFolder.Path + "/" + Path.GetFileName(localFolder), e);
return false;
}
try
{
// Upload each file in this folder.
foreach (string file in Directory.GetFiles(localFolder))
{
if (Utils.WorthSyncing(localFolder, Path.GetFileName(file), repoinfo))
{
success &= UploadFile(file, folder);
}
}
// Recurse for each subfolder in this folder.
foreach (string subfolder in Directory.GetDirectories(localFolder))
{
if (Utils.WorthSyncing(localFolder, Path.GetFileName(subfolder), repoinfo))
{
success &= UploadFolderRecursively(folder, subfolder);
}
}
}
catch (Exception e)
{
ProcessRecoverableException("Could not uploading folder: " + localFolder, e);
return false;
}
return success;
}
/// <summary>
/// Upload folder recursively.
/// After execution, the hierarchy on server will be: .../remoteBaseFolder/localFolder/...
/// </summary>
private void UploadFolderRecursively(IFolder remoteBaseFolder, string localFolder)
{
sleepWhileSuspended();
IFolder folder;
try
{
// Create remote folder.
Dictionary<string, object> properties = new Dictionary<string, object>();
properties.Add(PropertyIds.Name, Path.GetFileName(localFolder));
properties.Add(PropertyIds.ObjectTypeId, "cmis:folder");
properties.Add(PropertyIds.CreationDate, Directory.GetCreationTime(localFolder));
properties.Add(PropertyIds.LastModificationDate, Directory.GetLastWriteTime(localFolder));
folder = remoteBaseFolder.CreateFolder(properties);
// Create database entry for this folder
database.AddFolder(localFolder, folder.LastModificationDate);
Logger.Info("Added folder to database: " + localFolder);
}
catch (CmisBaseException e)
{
ProcessRecoverableException("Could not create remote directory: " + remoteBaseFolder.Path + "/" + Path.GetFileName(localFolder), e);
return;
}
try
{
// Upload each file in this folder.
foreach (string file in Directory.GetFiles(localFolder))
{
if (Utils.WorthSyncing(localFolder, Path.GetFileName(file), repoinfo))
{
UploadFile(file, folder);
}
}
// Recurse for each subfolder in this folder.
foreach (string subfolder in Directory.GetDirectories(localFolder))
{
if (Utils.WorthSyncing(localFolder, Path.GetFileName(subfolder), repoinfo))
{
UploadFolderRecursively(folder, subfolder);
}
}
}
catch (Exception e)
{
ProcessRecoverableException("Could not uploading folder: " + localFolder, e);
}
}
/// <summary>
/// Upload folder recursively.
/// After execution, the hierarchy on server will be: .../remoteBaseFolder/localFolder/...
/// </summary>
private void UploadFolderRecursively(IFolder remoteBaseFolder, string localFolder)
{
// Create remote folder.
Dictionary<string, object> properties = new Dictionary<string, object>();
properties.Add(PropertyIds.Name, Path.GetFileName(localFolder));
properties.Add(PropertyIds.ObjectTypeId, "cmis:folder");
IFolder folder = remoteBaseFolder.CreateFolder(properties);
// Create database entry for this folder
// TODO Add metadata
database.AddFolder(localFolder, folder.LastModificationDate);
try
{
// Upload each file in this folder.
foreach (string file in Directory.GetFiles(localFolder))
{
if (Utils.WorthSyncing(file))
UploadFile(file, folder);
}
// Recurse for each subfolder in this folder.
foreach (string subfolder in Directory.GetDirectories(localFolder))
{
string path = subfolder.Substring(repoinfo.TargetDirectory.Length);
path = path.Replace("\\\\","/");
if (Utils.WorthSyncing(subfolder) && !repoinfo.isPathIgnored(path))
UploadFolderRecursively(folder, subfolder);
}
}
catch (Exception e)
{
if (e is System.IO.DirectoryNotFoundException ||
e is IOException)
{
Logger.Warn("Folder deleted while trying to upload it, reverting.");
// Folder has been deleted while we were trying to upload/checksum/add.
// In this case, revert the upload.
folder.DeleteTree(true, null, true);
}
else
{
throw;
}
}
}
/// <summary>
/// Upload folder recursively.
/// After execution, the hierarchy on server will be: .../remoteBaseFolder/localFolder/...
/// </summary>
private bool UploadFolderRecursively(IFolder remoteBaseFolder, string localFolder)
{
bool success = true;
CheckPendingCancelation();
IFolder folder = null;
try
{
SyncItem syncItem = getSyncItemFromLocalPath(localFolder);
// Create remote folder.
Dictionary<string, object> properties = new Dictionary<string, object>();
properties.Add(PropertyIds.Name, syncItem.RemoteFileName);
properties.Add(PropertyIds.ObjectTypeId, "cmis:folder");
properties.Add(PropertyIds.CreationDate, Directory.GetCreationTime(localFolder));
properties.Add(PropertyIds.LastModificationDate, Directory.GetLastWriteTime(localFolder));
try
{
Logger.Debug(String.Format("Creating remote folder {0} for local folder {1}", syncItem.RemoteFileName, localFolder));
folder = remoteBaseFolder.CreateFolder(properties);
Logger.Debug(String.Format("Created remote folder {0}({1}) for local folder {2}", syncItem.RemoteFileName, folder.Id, localFolder));
}
catch (CmisNameConstraintViolationException e)
{
HandleException(new DirectoryCreationRemoteFileCollisionException(syncItem.LocalFileName, e));
return false;
}
// Create database entry for this folder
// TODO Add metadata
database.AddFolder(syncItem, folder.Id, folder.LastModificationDate);
Logger.Info("Added folder to database: " + localFolder);
}
catch (CmisBaseException e)
{
HandleException(new CreateRemoteDirectory(remoteBaseFolder.Path + "/" + Path.GetFileName(localFolder), e));
return false;
}
try
{
// Upload each file in this folder.
foreach (string file in Directory.GetFiles(localFolder))
{
if (SyncUtils.IsWorthSyncing(localFolder, Path.GetFileName(file), SyncFolderInfo))
{
success &= UploadFile(file, folder);
}
}
// Recurse for each subfolder in this folder.
foreach (string subfolder in Directory.GetDirectories(localFolder))
{
if (SyncUtils.IsWorthSyncing(localFolder, Path.GetFileName(subfolder), SyncFolderInfo))
{
success &= UploadFolderRecursively(folder, subfolder);
}
}
}
catch (Exception e)
{
HandleException(new UploadFolderException(localFolder, e));
return false;
}
return success;
}