public void Publish(IMailboxSession session)
{
ArgumentValidator.ThrowIfNull("session", session);
try
{
IDictionary <string, PeopleIKnowMetadata> systemFavorites = this.GetSystemFavorites(session);
if (systemFavorites.Count > 0)
{
PeopleIKnowEmailAddressCollection peopleIKnowEmailAddressCollection = PeopleIKnowEmailAddressCollection.CreateFromStringCollection(systemFavorites, this.tracer, this.traceId, 1);
byte[] data = peopleIKnowEmailAddressCollection.Data;
PeopleIKnowEmailAddressCollection peopleIKnowEmailAddressCollection2 = PeopleIKnowEmailAddressCollection.CreateFromStringCollection(systemFavorites, this.tracer, this.traceId, 2);
byte[] data2 = peopleIKnowEmailAddressCollection2.Data;
using (IFolder folder = this.xsoFactory.BindToFolder(session, DefaultFolderType.Inbox, PeopleIKnowEmailAddressCollectionFolderProperty.PeopleIKnowEmailAddressCollectionPropertyArray))
{
folder[FolderSchema.PeopleIKnowEmailAddressCollection] = data;
folder[FolderSchema.PeopleIKnowEmailAddressRelevanceScoreCollection] = data2;
folder.Save();
goto IL_DA;
}
}
using (IFolder folder2 = this.xsoFactory.BindToFolder(session, DefaultFolderType.Inbox, PeopleIKnowEmailAddressCollectionFolderProperty.PeopleIKnowEmailAddressCollectionPropertyArray))
{
folder2.Delete(FolderSchema.PeopleIKnowEmailAddressCollection);
folder2.Delete(FolderSchema.PeopleIKnowEmailAddressRelevanceScoreCollection);
folder2.Save();
}
IL_DA :;
}
catch (ObjectNotFoundException arg)
{
this.tracer.TraceDebug <IMailboxSession, ObjectNotFoundException>((long)this.GetHashCode(), "People I Know email addresses container has not been initialized or has been deleted for mailbox '{0}'. Exception: {1}", session, arg);
}
}
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 IFolder CreateNewTestFolder(string folderName)
{
IFolder retval = FixtureRootRepoFolder.GetSubFolder(folderName);
if (retval != null)
{
retval.Delete(true, true);
}
retval = FixtureRootRepoFolder.CreateSubfolder(folderName);
return(retval);
}
public void RenameFolder(
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 = "was 1 in past";
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.TrimEnd('/') + "/" + folderName) as IFolder;
if (folder != null)
{
folder.Delete(true);
}
folder = session.GetObjectByPath(remoteFolderPath.TrimEnd('/') + "/" + newFolderName) as IFolder;
if (folder != null)
{
folder.Delete(true);
}
}
catch (CmisObjectNotFoundException) {
}
IFolder newFolder = rootFolder.CreateFolder(properties);
newFolder.Rename(newFolderName, true);
Assert.That(newFolder.Name, Is.EqualTo(newFolderName));
newFolder.Delete(true);
}
public static bool TryDelete(this IFolder folder, string path, bool recursive)
{
folder.ArgumentNullExceptionByNullOrEmpty("folder");
try
{
folder.Delete(path, recursive);
return(true);
}
catch
{
return(false);
}
}
public void _CurrentlyFailing_RemoteFolderCreationThenSameNameDocumentDeletion(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";
IDictionary <string, object> folderProperties = new Dictionary <string, object>();
folderProperties[PropertyIds.Name] = remoteObjectName;
folderProperties[PropertyIds.ObjectTypeId] = "cmis:folder";
IFolder folder = remoteBaseFolder.CreateFolder(folderProperties);
// Wait for a few seconds so that sync gets a chance to sync things.
Thread.Sleep(20 * 1000);
// Check locally
Assert.True(File.Exists(Path.Combine(sync.Folder(), remoteObjectName)));
// Delete remote folder.
folder.Delete(true);
// Immediately create remote file with exact same name
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 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(), remoteObjectName)));
}
private void OnSharedFolderDiscovered(IFolder folder)
{
Logger.Instance.Trace(this, "Shared folder discovered: {0} - {1}", folder.Name, folder.SyncId);
if (folder.SyncId == null || !folder.SyncId.IsCustom)
{
Logger.Instance.Warning(this, "Local folder created in shared folder, deleting: {0} - {1}", folder.Name, folder.SyncId);
// This is a new, locally created folder. Warn and remove
MessageBox.Show(ThisAddIn.Instance.Window,
Properties.Resources.SharedFolders_LocalFolder_Body,
Properties.Resources.SharedFolders_LocalFolder_Title,
MessageBoxButtons.OK,
MessageBoxIcon.Warning
);
folder.Delete();
Logger.Instance.Warning(this, "Local folder created in shared folder, deleted: {0} - {1}", folder.Name, folder.SyncId);
}
else
{
// Check if it was renamed before the events were fully set up
CheckSharedFolderRename(folder);
}
}
private async Task Delete(IFolder folder)
{
var files = folder.Files.ToArray();
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;
}
file.Delete();
++Progress;
}
var folders = folder.Folders.ToArray();
foreach (var f in folders)
{
if (Status == OperationStatus.Cancel)
{
return;
}
await Delete(f);
}
folder.Delete();
}
public void LoadSubfoldersTest()
{
const string topFolderName = "LoadSubfoldersTest";
const string subFolderName1 = "sub1";
const string subFolderName2 = "sub2";
IFolder topFolder = CreateNewTestFolder(topFolderName);
IFolder sub1 = topFolder.CreateSubfolder(subFolderName1);
IFolder sub2 = topFolder.CreateSubfolder(subFolderName2);
Assert.AreEqual(2, topFolder.SubFolders.Count);
Assert.IsNull(sub1.Properties.DisplayName, "Display name must be null after creation");
IRepository repoStandalone = GetStandaloneRepository();
IFolder sub1Alt = repoStandalone.RootFolder.GetDescendant(sub1.LogicalPath, false);
const string newDisplayName1 = "newDisplayName1";
sub1Alt.Properties.DisplayName = newDisplayName1;
// check that instances are preserved
topFolder.LoadSubfolders(true, false, false);
Assert.AreEqual(2, topFolder.SubFolders.Count);
Assert.AreSame(sub1, topFolder.GetSubFolder(subFolderName1), "Existing folder instance not preserved");
Assert.AreSame(sub2, topFolder.GetSubFolder(subFolderName2), "Existing folder instance not preserved");
Assert.IsNull(sub1.Properties.DisplayName, "Contents refreshed ");
// check that missing folder is purged
sub1Alt.Delete(true, true);
Assert.Throws(Is.InstanceOf <InvalidOperationException>(), () => sub1Alt.Delete(true, true));
topFolder.LoadSubfolders(true, false, false);
Assert.AreEqual(1, topFolder.SubFolders.Count);
Assert.AreSame(sub2, topFolder.GetSubFolder(subFolderName2), "Existing folder instance not preserved");
Assert.IsTrue(sub1.IsDetached, "Purged subfolder must be detached after reloading");
// check that subfolders are unloaded
topFolder.UnloadSubfolders();
Assert.IsFalse(topFolder.SubfoldersLoaded);
// now check that with reload OFF folders are reloaded
topFolder.LoadSubfolders(reloadIfLoaded: false, recursive: false, refreshContent: false);
Assert.AreEqual(1, topFolder.SubFolders.Count);
// recreating previously deleted folder
sub1 = topFolder.CreateSubfolder(subFolderName1);
Assert.IsNull(sub1.Properties.DisplayName, "Display name must be null after creation");
// note that tis is required to make sure data folders are loaded to check refreshContent option later
Assert.IsNull(sub1.GetDataFileIterator(false).Seek(DateTime.MinValue));
repoStandalone.RootFolder.UnloadSubfolders();
sub1Alt = repoStandalone.RootFolder.GetDescendant(sub1.LogicalPath, false);
sub1Alt.Properties.Description = newDisplayName1;
using (var writer = sub1Alt.GetWriter())
{
writer.Write(TestDataItem.GetTestItem(2));
}
topFolder.LoadSubfolders(reloadIfLoaded: false, recursive: false, refreshContent: false);
Assert.IsNull(sub1.Properties.Description, "Did not ask for content refreshing");
Assert.IsNull(sub1.GetDataFileIterator(false).Seek(DateTime.MinValue));
topFolder.LoadSubfolders(reloadIfLoaded: true, recursive: false, refreshContent: true);
Assert.AreEqual(newDisplayName1, sub1.Properties.Description, "Did ask for content to be refreshed");
Assert.IsNotNull(sub1.GetDataFileIterator(false).Seek(DateTime.MinValue));
}
public void CoderEncryptorConfigTest()
{
const string topFolderName = "CoderEncryptorConfigTest";
IFolder topFolder = (IFolder)FixtureRootRepoFolder.GetSubFolder(topFolderName);
if (topFolder != null)
{
topFolder.Delete(true, true);
}
topFolder = (IFolder)FixtureRootRepoFolder.CreateSubfolder(topFolderName);
var targetFolder = topFolder.GetDescendant("Intermediate/Target", true);
Assert.AreEqual(string.Empty, targetFolder.Properties.Encryptor);
Assert.AreEqual(string.Empty, targetFolder.Properties.Compressor);
const string coderKey = "my-coder";
const string encKey = "my-encryptor";
using (var repo1 = GetStandaloneRepository())
{
var topFolderInner = repo1.RootFolder.GetDescendant(topFolder.LogicalPath, false);
Assume.That(null != topFolderInner);
Assert.Throws <ArgumentException>(() => topFolderInner.Properties.Compressor = coderKey);
Assert.Throws <ArgumentException>(() => topFolderInner.Properties.Encryptor = encKey);
repo1.ObjectFactory.AddCompressor(new CoderMock(coderKey), false);
repo1.ObjectFactory.AddEncryptor(new CoderMock(encKey), false);
topFolderInner.Properties.Compressor = coderKey;
topFolderInner.Properties.Encryptor = encKey;
topFolderInner.Properties.EnableEncryption = true;
Assert.AreEqual(coderKey, topFolderInner.Properties.Compressor);
Assert.AreEqual(encKey, topFolderInner.Properties.Encryptor);
var targetFolderInner = repo1.RootFolder.GetDescendant(targetFolder.LogicalPath, false);
Assume.That(null != targetFolderInner);
Assert.AreEqual(coderKey, targetFolderInner.Properties.Compressor);
Assert.AreEqual(encKey, targetFolderInner.Properties.Encryptor);
}
using (var repo1 = GetStandaloneRepository())
{
var topFolderInner = repo1.RootFolder.GetDescendant(topFolder.LogicalPath, false);
Assume.That(null != topFolderInner);
repo1.ObjectFactory.AddCompressor(new CoderMock(coderKey), false);
repo1.ObjectFactory.AddEncryptor(new CoderMock(encKey), false);
var targetFolderInner = repo1.RootFolder.GetDescendant(targetFolder.LogicalPath, false);
Assume.That(null != targetFolderInner);
Assert.AreEqual(coderKey, targetFolderInner.Properties.Compressor);
Assert.AreEqual(encKey, targetFolderInner.Properties.Encryptor);
using (var writer = targetFolderInner.GetWriter())
{
IDataRouter dataRouter = new Mock.NumberedDataRouter(2);
writer.DataRouter = dataRouter;
writer.AllowSubfoldersCreation = true;
IDataItem[] data = RepositoryWriterTest.GetTestData(100, DateTime.Now, 2);
for (int n = 0; n < 100; ++n)
{
writer.Write(data[n]);
}
//writer.Flush();
// flushes data
writer.Close();
var enm = targetFolderInner.SubFolders.GetEnumerator();
Assert.IsTrue(enm.MoveNext());
var dataFile = ((IFolder)enm.Current).RootDataFolder.FindFirstDataFile(false);
Assert.IsNotNull(dataFile);
Assert.IsTrue(dataFile.Path.EndsWith(encKey));
using (var reader = targetFolderInner.GetReader(DateTime.MinValue, true))
{
IDataItem[] dataRead = new IDataItem[data.Length];
int n = 0;
while (reader.HasData)
{
dataRead[n] = reader.Read().DataItem;
Assert.AreEqual(data[n], dataRead[n]);
++n;
}
Assert.AreEqual(data.Length, n);
}
}
}
}
public static void Delete(this IFolder folder, string path)
{
folder.ArgumentNullExceptionByNullOrEmpty("folder");
folder.Delete(path, true);
}
public void TestCreate()
{
string testFolderName = "porttest";
if (Session.ExistsPath("/", testFolderName))
{
ICmisObject obj = Session.GetObjectByPath("/", testFolderName, OperationContextUtils.CreateMinimumOperationContext());
if (obj is IFolder)
{
((IFolder)obj).DeleteTree(true, UnfileObject.Delete, true);
}
else
{
obj.Delete();
}
}
// create folder
IFolder root = Session.GetRootFolder();
IFolder newFolder = CreateFolder(root, testFolderName);
Assert.IsNotNull(newFolder);
// create document
string contentString = "Hello World";
IDocument newDoc = CreateTextDocument(newFolder, "test.txt", contentString);
Assert.IsNotNull(newDoc);
// get content
IContentStream newContent = newDoc.GetContentStream();
Assert.IsNotNull(newContent);
Assert.IsNotNull(newContent.Stream);
Assert.AreEqual(contentString, ConvertStreamToString(newContent.Stream));
// fetch it again to get the updated content stream length property
IOperationContext ctxt = OperationContextUtils.CreateMaximumOperationContext();
ICmisObject newObj = Session.GetObject(newDoc, ctxt);
Assert.IsTrue(newObj is IDocument);
IDocument newDoc2 = (IDocument)newObj;
Assert.AreEqual(newDoc.Name, newDoc2.Name);
Assert.AreEqual(Encoding.UTF8.GetBytes(contentString).Length, newDoc2.ContentStreamLength);
// fetch it again
newObj = Session.GetLatestDocumentVersion(newDoc, ctxt);
Assert.IsTrue(newObj is IDocument);
IDocument newDoc3 = (IDocument)newObj;
Assert.AreEqual(newDoc.Id, newDoc3.Id);
Assert.AreEqual(newDoc.Name, newDoc3.Name);
// delete document
newDoc.Delete();
try
{
Session.GetObject(newDoc);
Assert.Fail("Document still exists.");
}
catch (CmisObjectNotFoundException)
{
// expected
}
Assert.IsFalse(Session.Exists(newDoc.Id));
// try an item
IList <IObjectType> types = Session.GetTypeChildren(null, false).ToList();
Assert.IsNotNull(types);
Assert.IsTrue(types.Count >= 2);
if (types.Any(type => type.Id == "cmis:item"))
{
IItem newItem = CreateItem(newFolder, "testItem");
newItem.Delete();
Assert.IsFalse(Session.Exists(newItem.Id));
}
// delete folder
Assert.IsTrue(Session.ExistsPath(newFolder.Path));
newFolder.Delete();
Assert.IsFalse(Session.Exists(newFolder));
}
/// <inheritdoc /> public void Delete() => _folder.Delete();
public void SmokeTestCreateFolder()
{
IDictionary <string, object> properties = new Dictionary <string, object>();
properties[PropertyIds.Name] = "test-smoke";
properties[PropertyIds.ObjectTypeId] = DefaultFolderType;
IFolder folder = TestFolder.CreateFolder(properties);
// check folder
Assert.NotNull(folder);
Assert.NotNull(folder.Id);
Assert.AreEqual(properties[PropertyIds.Name], folder.Name);
Assert.AreEqual(BaseTypeId.CmisFolder, folder.BaseTypeId);
Assert.AreEqual(TestFolder.Id, folder.FolderParent.Id);
Assert.False(folder.IsRootFolder);
Assert.True(folder.Path.StartsWith("/"));
Assert.True(folder.AllowableActions.Actions.Contains(Actions.CanGetProperties));
Assert.True(folder.AllowableActions.Actions.Contains(Actions.CanGetChildren));
Assert.False(folder.AllowableActions.Actions.Contains(Actions.CanGetContentStream));
// check children
foreach (ICmisObject cmisObject in folder.GetChildren())
{
Assert.Fail("Folder shouldn't have children!");
}
// check descendants
bool?descSupport = Session.RepositoryInfo.Capabilities.IsGetDescendantsSupported;
if (descSupport.HasValue && descSupport.Value)
{
IList <ITree <IFileableCmisObject> > list = folder.GetDescendants(-1);
if (list != null)
{
foreach (ITree <IFileableCmisObject> desc in list)
{
Assert.Fail("Folder shouldn't have children!");
}
}
}
else
{
Console.WriteLine("GetDescendants not supported!");
}
// check folder tree
bool?folderTreeSupport = Session.RepositoryInfo.Capabilities.IsGetFolderTreeSupported;
if (folderTreeSupport.HasValue && folderTreeSupport.Value)
{
IList <ITree <IFileableCmisObject> > list = folder.GetFolderTree(-1);
if (list != null)
{
foreach (ITree <IFileableCmisObject> desc in list)
{
Assert.Fail("Folder shouldn't have children!");
}
}
}
else
{
Console.WriteLine("GetFolderTree not supported!");
}
// check parents
IFolder parent = folder.FolderParent;
Assert.NotNull(parent);
Assert.AreEqual(TestFolder.Id, parent.Id);
IList <IFolder> parents = folder.Parents;
Assert.NotNull(parents);
Assert.True(parents.Count > 0);
bool found = false;
foreach (IFolder p in parents)
{
if (TestFolder.Id == p.Id)
{
found = true;
break;
}
}
Assert.True(found);
folder.Delete(true);
try
{
folder.Refresh();
Assert.Fail("Folder shouldn't exist anymore!");
}
catch (CmisObjectNotFoundException) { }
}