public static RopResult FastTransferDestinationConfigure(int serverId, int objHandleIndex, SourceOperation option, FastTransferDestinationConfigureCopyFlags copyFlag, out int uploadContextHandleIndex)
{
// The construction conditions.
Condition.IsTrue(connections.Count > 0);
Condition.IsTrue(connections.Keys.Contains(serverId));
// Initialize return value.
RopResult result = RopResult.InvalidParameter;
if (requirementContainer.ContainsKey(3492001))
{
if ((copyFlag == FastTransferDestinationConfigureCopyFlags.Invalid) &&
requirementContainer[3492001] == true)
{
// FastTransferDestinationConfigureCopyFlags is invalid parameter and exchange server version is not ExchangeServer2007 .
uploadContextHandleIndex = -1;
ModelHelper.CaptureRequirement(
3492001,
@"[In Appendix A: Product Behavior] If unknown flags in the CopyFlags field are set, implementation does fail the operation. <36> Section 3.2.5.8.2.1: Exchange 2010, Exchange 2013 and Exchange 2016 fail the ROP [RopFastTransferDestinationConfigure ROP] if unknown bit flags in the CopyFlags field are set.");
return result;
}
}
if (option == SourceOperation.CopyProperties || option == SourceOperation.CopyTo || option == SourceOperation.CopyFolder || option == SourceOperation.CopyMessages)
{
priorOperation = MS_OXCFXICS.PriorOperation.RopFastTransferDestinationConfigure;
}
sourOperation = option;
// Create a new Upload context.
AbstractUploadInfo uploadInfo = new AbstractUploadInfo();
// Set value for upload context.
uploadContextHandleIndex = AdapterHelper.GetHandleIndex();
uploadInfo.UploadHandleIndex = uploadContextHandleIndex;
ConnectionData changeConnection = connections[serverId];
connections.Remove(serverId);
// Add the new Upload context to UploadContextContainer.
changeConnection.UploadContextContainer = changeConnection.UploadContextContainer.Add(uploadInfo);
connections.Add(serverId, changeConnection);
result = RopResult.Success;
ModelHelper.CaptureRequirement(
581,
@"[In RopFastTransferDestinationConfigure ROP] The RopFastTransferDestinationConfigure ROP ([MS-OXCROPS] section 2.2.12.1) initializes a FastTransfer operation for uploading content encoded in a client-provided FastTransfer stream into a mailbox.");
if (requirementContainer.ContainsKey(3492002))
{
if ((copyFlag == FastTransferDestinationConfigureCopyFlags.Invalid) &&
requirementContainer[3492002] == true)
{
// Exchange 2007 ignore unknown values of the CopyFlags field.
ModelHelper.CaptureRequirement(
3492002,
@"[In Appendix A: Product Behavior] If unknown flags in the CopyFlags field are set, implementation does not fail the operation. <37> Section 3.2.5.8.2.1: Exchange 2007 ignore unknown values of the CopyFlags field.");
return result;
}
}
return result;
}
public static RopResult SynchronizationConfigure(int serverId, int folderHandleIndex, SynchronizationTypes synchronizationType, SendOptionAlls option, SynchronizationFlag synchronizationFlag, SynchronizationExtraFlag synchronizationExtraFlag, Sequence<string> property, out int downloadcontextHandleIndex)
{
// The contractions conditions.
Condition.IsTrue(connections.Count > 0);
Condition.IsTrue(connections.Keys.Contains(serverId));
Condition.IsTrue(connections[serverId].FolderContainer.Count > 0);
// Initialize return value.
RopResult result = RopResult.Success;
downloadcontextHandleIndex = -1;
if ((option & SendOptionAlls.Invalid) == SendOptionAlls.Invalid && (requirementContainer.ContainsKey(3463) && requirementContainer[3463]))
{
result = RopResult.InvalidParameter;
return result;
}
// SynchronizationFlag MUST match the value of the Unicode flag from SendOptions field.
if ((synchronizationFlag & SynchronizationFlag.Unicode) == SynchronizationFlag.Unicode)
{
Condition.IsTrue((option & SendOptionAlls.Unicode) == SendOptionAlls.Unicode);
}
// When SynchronizationType is 0X04 then Servers return 0x80070057.
if (synchronizationType == SynchronizationTypes.InvalidParameter)
{
if (requirementContainer.ContainsKey(2695) && requirementContainer[2695])
{
result = RopResult.NotSupported;
}
else
{
result = RopResult.InvalidParameter;
ModelHelper.CaptureRequirement(2695, "[In Receiving a RopSynchronizationConfigure ROP Request] [SynchronizationType Constraints] Servers MUST return 0x80070057 if SynchronizationType is 0x04.");
}
}
else if ((synchronizationFlag & SynchronizationFlag.Reserved) == SynchronizationFlag.Reserved)
{
// When SynchronizationType is Reserved then Servers MUST fail the ROP request.
result = RopResult.RpcFormat;
ModelHelper.CaptureRequirement(2180, "[In Receiving a RopSynchronizationConfigure ROP Request] [SynchronizationType Constraints] The server MUST fail the ROP request if the Reserved flag of the SynchronizationFlags field is set.");
}
else
{
// Get ConnectionData value.
ConnectionData changeConnection = connections[serverId];
// Identify whether the CurrentFolder is existent or not.
bool isCurrentFolderExist = false;
// Identify whether the Current Folder is existent or not.
foreach (AbstractFolder tempfolder in changeConnection.FolderContainer)
{
if (tempfolder.FolderHandleIndex == folderHandleIndex)
{
// Set the value to the variable when the current folder is existent.
isCurrentFolderExist = true;
}
}
// The condition of CurrentFolder is existent.
if (isCurrentFolderExist)
{
// Initialize the Download information.
AbstractDownloadInfo abstractDownloadInfo = new AbstractDownloadInfo
{
UpdatedState =
new AbstractUpdatedState
{
CnsetRead = new Set<int>(),
CnsetSeen = new Set<int>(),
CnsetSeenFAI = new Set<int>(),
IdsetGiven = new Set<int>()
},
DownloadHandleIndex = AdapterHelper.GetHandleIndex()
};
// Get the download Handle for download context.
downloadcontextHandleIndex = abstractDownloadInfo.DownloadHandleIndex;
ModelHelper.CaptureRequirement(669, "[In RopSynchronizationConfigure ROP Response Buffer]OutputServerObject: This value MUST be the synchronization download context.");
// Record the flags.
abstractDownloadInfo.Sendoptions = option;
abstractDownloadInfo.SynchronizationType = synchronizationType;
abstractDownloadInfo.Synchronizationflag = synchronizationFlag;
abstractDownloadInfo.SynchronizationExtraflag = synchronizationExtraFlag;
// Record the Property.
abstractDownloadInfo.Property = property;
// Record folder handle of related to the download context.
abstractDownloadInfo.RelatedObjectHandleIndex = folderHandleIndex;
switch (synchronizationType)
{
// Record synchronizationType value for condition of Synchronization type is Contents.
case SynchronizationTypes.Contents:
abstractDownloadInfo.AbstractFastTransferStreamType = FastTransferStreamType.contentsSync;
abstractDownloadInfo.ObjectType = ObjectType.Folder;
break;
// Record synchronizationType value for condition of Synchronization type is Hierarchy.
case SynchronizationTypes.Hierarchy:
abstractDownloadInfo.AbstractFastTransferStreamType = FastTransferStreamType.hierarchySync;
abstractDownloadInfo.ObjectType = ObjectType.Folder;
break;
default:
// Condition ofsynchronizationType is invalid parameter.
result = RopResult.InvalidParameter;
break;
}
// Condition of the operation return success.
if (result == RopResult.Success)
{
// Add the new value to DownloadContextContainer.
changeConnection.DownloadContextContainer = changeConnection.DownloadContextContainer.Add(abstractDownloadInfo);
connections[serverId] = changeConnection;
priorDownloadOperation = PriorDownloadOperation.RopSynchronizationConfigure;
priorOperation = MS_OXCFXICS.PriorOperation.RopSynchronizationConfigure;
ModelHelper.CaptureRequirement(
641,
@"[In RopSynchronizationConfigure] The RopSynchronizationConfigure ROP ([MS-OXCROPS] section 2.2.13.1) is used to define the synchronization scope and parameters of the synchronization download operation.");
}
}
}
return result;
}
public static RopResult FastTransferSourceCopyMessages(int serverId, int objHandleIndex, RopFastTransferSourceCopyMessagesCopyFlags copyFlag, SendOptionAlls option, Sequence<int> messageIds, out int downloadContextHandleIndex)
{
// The contraction conditions
Condition.IsTrue(connections.Count > 0);
Condition.IsTrue(connections.Keys.Contains(serverId));
// Initialize the return value.
RopResult result = RopResult.InvalidParameter;
if (option == SendOptionAlls.Invalid)
{
if (requirementContainer.ContainsKey(3479) && requirementContainer[3479])
{
// SendOption flags value is invalid
downloadContextHandleIndex = -1;
return result;
}
}
// Modify the logical
if ((copyFlag & RopFastTransferSourceCopyMessagesCopyFlags.Unused3) == RopFastTransferSourceCopyMessagesCopyFlags.Unused3)
{
// CopyFlags is set to Unused3
downloadContextHandleIndex = -1;
}
else
{
// Identify whether the current folder is existent or not.
ConnectionData changeConnection = connections[serverId];
bool isFolderExist = false;
foreach (AbstractFolder tempFolder in changeConnection.FolderContainer)
{
if (tempFolder.FolderHandleIndex == objHandleIndex)
{
isFolderExist = true;
}
}
Condition.IsTrue(isFolderExist);
// Set value for new download context.
AbstractDownloadInfo downloadInfo = new AbstractDownloadInfo();
downloadContextHandleIndex = AdapterHelper.GetHandleIndex();
downloadInfo.DownloadHandleIndex = downloadContextHandleIndex;
connections.Remove(serverId);
downloadInfo.AbstractFastTransferStreamType = FastTransferStreamType.MessageList;
downloadInfo.CopyMessageCopyFlag = copyFlag;
// Record the FastTransferOperation
downloadInfo.RelatedFastTransferOperation = EnumFastTransferOperation.FastTransferSourceCopyMessage;
priorDownloadOperation = PriorDownloadOperation.RopFastTransferSourceCopyMessage;
// Set value for new download context.
downloadInfo.Sendoptions = option;
downloadInfo.RelatedObjectHandleIndex = objHandleIndex;
downloadInfo.ObjectType = ObjectType.Folder;
// Add new download context to DownloadContextContainer.
changeConnection.DownloadContextContainer = changeConnection.DownloadContextContainer.Add(downloadInfo);
connections.Add(serverId, changeConnection);
priorOperation = MS_OXCFXICS.PriorOperation.RopFastTransferSourceCopyMessage;
result = RopResult.Success;
// If the server returns success result, it means the RopFastTransferSourceCopyMessages ROP initializes the FastTransfer operation successfully. And then this requirement can be captured.
ModelHelper.CaptureRequirement(
3125,
@"[In RopFastTransferSourceCopyMessages ROP] The RopFastTransferSourceCopyMessages ROP ([MS-OXCROPS] section 2.2.12.5) initializes a FastTransfer operation on a folder for downloading content and descendant subobjects of messages identified by a set of MID structures ([MS-OXCDATA] section 2.2.1.2).");
}
return result;
}
public static RopResult SynchronizationImportMessageMove(int serverId, int synchronizationUploadContextHandleIndex, int sourceFolderIdIndex, int destinationFolderIdIndex, int sourceMessageIdIndex, int sourceFolderHandleIndex, int destinationFolderHandleIndex, bool inewerClientChange, out bool iolderversion, out bool icnpc)
{
// The contractions conditions.
Condition.IsTrue(connections.Count > 0);
Condition.IsTrue(connections.Keys.Contains(serverId));
Condition.IsTrue(connections[serverId].FolderContainer.Count > 1);
// Initialize the return value.
RopResult result = RopResult.InvalidParameter;
iolderversion = false;
icnpc = false;
// Get the current ConnectionData value.
ConnectionData changeConnection = connections[serverId];
// Identify whether Current Upload information is existent or not.
bool isCurrentUploadinfoExist = false;
// Record the current Upload information.
int currentUploadIndex = 0;
AbstractUploadInfo uploadInfo = new AbstractUploadInfo();
foreach (AbstractUploadInfo tempUploadInfo in changeConnection.UploadContextContainer)
{
if (tempUploadInfo.UploadHandleIndex == synchronizationUploadContextHandleIndex)
{
// Set the value for current upload information when current upload Information is existent.
isCurrentUploadinfoExist = true;
uploadInfo = tempUploadInfo;
currentUploadIndex = changeConnection.UploadContextContainer.IndexOf(tempUploadInfo);
}
}
// Create variable of relate to source Folder.
AbstractFolder sourceFolder = new AbstractFolder();
bool isSourceFolderExist = false;
int sourceFolderIndex = 0;
// Create variable of relate to destination Folder.
AbstractFolder destinationFolder = new AbstractFolder();
bool isdestinationFolderExist = false;
int destinationFolderIndex = 0;
// Create a new message.
AbstractMessage movedMessage = new AbstractMessage();
// Identify whether the Moved Message is existent or not.
bool isMovedMessageExist = false;
int movedMessageIndex = 0;
foreach (AbstractFolder tempFolder in changeConnection.FolderContainer)
{
if (tempFolder.FolderIdIndex == sourceFolderIdIndex && tempFolder.FolderHandleIndex == sourceFolderHandleIndex)
{
// Set the value to the variable when the source folder is existent.
isSourceFolderExist = true;
sourceFolder = tempFolder;
sourceFolderIndex = changeConnection.FolderContainer.IndexOf(tempFolder);
}
}
foreach (AbstractFolder tempFolder in changeConnection.FolderContainer)
{
if (tempFolder.FolderIdIndex == destinationFolderIdIndex && tempFolder.FolderHandleIndex == destinationFolderHandleIndex)
{
// Set the value to the related variable when the destination folder is existent.
isdestinationFolderExist = true;
destinationFolder = tempFolder;
destinationFolderIndex = changeConnection.FolderContainer.IndexOf(tempFolder);
}
}
foreach (AbstractMessage tempMessage in changeConnection.MessageContainer)
{
if (tempMessage.MessageIdIndex == sourceMessageIdIndex)
{
// Set the value to the related variable when the source Message is existent.
isMovedMessageExist = true;
movedMessage = tempMessage;
movedMessageIndex = changeConnection.MessageContainer.IndexOf(tempMessage);
}
}
if (isSourceFolderExist && isdestinationFolderExist && isMovedMessageExist && isCurrentUploadinfoExist)
{
// Set value for the new abstract message property.
movedMessage.FolderIdIndex = destinationFolder.FolderIdIndex;
movedMessage.FolderHandleIndex = destinationFolder.FolderHandleIndex;
// Assigned a new change.
movedMessage.ChangeNumberIndex = ModelHelper.GetChangeNumberIndex();
// Assigned a new message id.
movedMessage.MessageIdIndex = AdapterHelper.GetObjectIdIndex();
// Update message Container.
changeConnection.MessageContainer = changeConnection.MessageContainer.Update(movedMessageIndex, movedMessage);
// Remove the current message id from MessageIds of source folder.
sourceFolder.MessageIds = sourceFolder.MessageIds.Remove(movedMessage.MessageIdIndex);
changeConnection.FolderContainer = changeConnection.FolderContainer.Update(sourceFolderIndex, sourceFolder);
// Remove the current message id from MessageIds of destination Folder.
destinationFolder.MessageIds = destinationFolder.MessageIds.Add(movedMessage.MessageIdIndex);
changeConnection.FolderContainer = changeConnection.FolderContainer.Update(destinationFolderIndex, destinationFolder);
// Add information of Upload context
uploadInfo.IsnewerClientChange = inewerClientChange;
uploadInfo.RelatedFastTransferOperation = EnumFastTransferOperation.SynchronizationImportMessageMove;
// Update the upload context container
changeConnection.UploadContextContainer = changeConnection.UploadContextContainer.Update(currentUploadIndex, uploadInfo);
connections[serverId] = changeConnection;
// Identify whether the IsnewerClientChange is true or false.
if (uploadInfo.IsnewerClientChange == false)
{
result = RopResult.Success;
ModelHelper.CaptureRequirement(
2449,
@"[In Uploading Changes Using ICS] Value is Success indicates No error occurred, or a conflict has been resolved.");
// Because if the result is success means the information about moving a message between two existing folders within the same mailbox imported
ModelHelper.CaptureRequirement(
839,
@"[In RopSynchronizationImportMessageMove ROP] The RopSynchronizationImportMessageMove ROP ([MS-OXCROPS] section 2.2.13.6) imports information about moving a message between two existing folders within the same mailbox.");
}
else
{
// Set out put parameter value
iolderversion = true;
ModelHelper.CaptureRequirement(
875,
@"[In RopSynchronizationImportMessageMove ROP Response Buffer] [
Return value (4 bytes):] The following table[In section 2.2.3.2.4.4] contains additional return values[NewerClientChange] , if the ROP succeeded, but the server replica had an older version of a message than the local replica, the return value is 0x00040821.");
icnpc = true;
ModelHelper.CaptureRequirement(
876,
@"[In RopSynchronizationImportMessageMove ROP Response Buffer] [
Return value (4 bytes):] The following table[In section 2.2.3.2.4.4] contains additional return values[NewerClientChange] , if the values of the ChangeNumber and PredecessorChangeList fields, specified in section 2.2.3.2.4.4.1, were not applied to the destination message, the return value is 0x00040821.");
ModelHelper.CaptureRequirement(
1892,
"[In Identifying Objects and Maintaining Change Numbers]Copying of messaging objects within a mailbox or moving messages between folders of the same mailbox translates into creation of new messaging objects and therefore, new internal identifiers MUST be assigned to new copies.");
result = RopResult.NewerClientChange;
}
// Record RopSynchronizationImportMessageMove operation.
priorUploadOperation = PriorOperation.RopSynchronizationImportMessageMove;
}
return result;
}
public static RopResult SynchronizationImportMessageChange(int serverId, int uploadContextHandleIndex, int messageIdindex, ImportFlag importFlag, out int importMessageHandleIndex)
{
// The contractions conditions.
Condition.IsTrue(connections.Count > 0);
Condition.IsTrue(connections.Keys.Contains(serverId));
Condition.IsTrue(connections[serverId].UploadContextContainer.Count > 0 && connections[serverId].LogonHandleIndex > 0);
// Initialize the return value.
RopResult result = RopResult.InvalidParameter;
importMessageHandleIndex = -1;
if ((importFlag & ImportFlag.InvalidParameter) == ImportFlag.InvalidParameter &&
requirementContainer.ContainsKey(3509001) && requirementContainer[3509001])
{
result = RopResult.InvalidParameter;
ModelHelper.CaptureRequirement(
3509001,
@"[In Appendix A: Product Behavior] If unknown flags are set, implementation does fail the operation. <40> Section 3.2.5.9.4.2: Exchange 2010, Exchange 2013 and Exchange 2016 fail the ROP [RopSynchronizationImportMessageChange] if unknown bit flags are set.");
return result;
}
else if ((importFlag & ImportFlag.InvalidParameter) == ImportFlag.InvalidParameter &&
requirementContainer.ContainsKey(350900201) && requirementContainer[350900201])
{
result = RopResult.Success;
ModelHelper.CaptureRequirement(
350900201,
@"[In Appendix A: Product Behavior] If unknown flags are set, implementation does not fail the operation. <41> Section 3.2.5.9.4.2: Exchange 2007 do not fail the ROP [RopSynchronizationImportMessageChange] if unknown bit flags are set.");
}
// Get ConnectionData value.
ConnectionData changeConnection = connections[serverId];
AbstractUploadInfo uploadInfo = new AbstractUploadInfo();
// Identify whether the current Upload information is existent or not.
bool isCurrentUploadinfoExist = false;
// Record current Upload information.
int currentUploadIndex = 0;
foreach (AbstractUploadInfo tempUploadInfo in changeConnection.UploadContextContainer)
{
if (tempUploadInfo.UploadHandleIndex == uploadContextHandleIndex)
{
// Set the value to the current upload context variable when the current upload context is existent.
isCurrentUploadinfoExist = true;
uploadInfo = tempUploadInfo;
currentUploadIndex = changeConnection.UploadContextContainer.IndexOf(tempUploadInfo);
}
}
if (isCurrentUploadinfoExist)
{
// Create a new Message
AbstractMessage currentMessage = new AbstractMessage();
// Identify whether the current message is existent or not.
bool isMessageExist = false;
// Record the current Message.
int currentMessageIndex = 0;
foreach (AbstractMessage tempMessage in changeConnection.MessageContainer)
{
if (tempMessage.MessageIdIndex == messageIdindex)
{
// Set the value to the variable when the message is existent.
isMessageExist = true;
currentMessage = tempMessage;
currentMessageIndex = changeConnection.MessageContainer.IndexOf(tempMessage);
}
}
if (isMessageExist)
{
// Set new change number
currentMessage.ChangeNumberIndex = ModelHelper.GetChangeNumberIndex();
ModelHelper.CaptureRequirement(1898, "[In Identifying Objects and Maintaining Change Numbers]A new change number is assigned to a messaging object each time it is modified.");
// Update the MessageContainer
changeConnection.MessageContainer = changeConnection.MessageContainer.Update(currentMessageIndex, currentMessage);
}
else
{
// Set the new message handle
currentMessage.MessageHandleIndex = AdapterHelper.GetHandleIndex();
// Set property value of abstract message object
currentMessage.FolderHandleIndex = uploadInfo.RelatedObjectHandleIndex;
currentMessage.FolderIdIndex = uploadInfo.RelatedObjectIdIndex;
currentMessage.MessageProperties = new Sequence<string>();
currentMessage.IsRead = true;
if ((importFlag & ImportFlag.Normal) == ImportFlag.Normal)
{
currentMessage.IsFAImessage = false;
}
if ((importFlag & ImportFlag.Associated) == ImportFlag.Associated)
{
currentMessage.IsFAImessage = true;
// When the Associated is set and the message being imported is an FAI message this requirement is captured.
ModelHelper.CaptureRequirement(
813,
@"[In RopSynchronizationImportMessageChange ROP Request Buffer] [ImportFlag,when the name is Associated, the value is 0x10] If this flag is set, the message being imported is an FAI message.");
}
else
{
currentMessage.IsFAImessage = false;
// When the Associated is not set and the message being imported is a normal message this requirement is captured.
ModelHelper.CaptureRequirement(
814,
@"[In RopSynchronizationImportMessageChange ROP Request Buffer] [ImportFlag,when the name is Associated, the value is 0x10] If this flag is not set, the message being imported is a normal message.");
}
// Out the new message handle
importMessageHandleIndex = currentMessage.MessageHandleIndex;
// Because this is out messageHandle so the OutputServerObject is a Message object.
ModelHelper.CaptureRequirement(805, "[In RopSynchronizationImportMessageChange ROP Response Buffer]OutputServerObject: The value of this field MUST be the Message object into which the client will upload the rest of the message changes.");
currentMessage.ChangeNumberIndex = ModelHelper.GetChangeNumberIndex();
ModelHelper.CaptureRequirement(1897, "[In Identifying Objects and Maintaining Change Numbers]When a new object is created, it is assigned a change number.");
// Add new Message to MessageContainer
changeConnection.MessageContainer = changeConnection.MessageContainer.Add(currentMessage);
// Record the related FastTransferOperation for Upload Information.
uploadInfo.RelatedFastTransferOperation = EnumFastTransferOperation.SynchronizationImportMessageChange;
// Update the UploadContextContainer.
changeConnection.UploadContextContainer = changeConnection.UploadContextContainer.Update(currentUploadIndex, uploadInfo);
connections[serverId] = changeConnection;
// Record RopSynchronizationImportMessageChange operation.
priorOperation = PriorOperation.RopSynchronizationImportMessageChange;
result = RopResult.Success;
ModelHelper.CaptureRequirement(
2449,
@"[In Uploading Changes Using ICS] Value is Success indicates No error occurred, or a conflict has been resolved.");
// Because if the result is success means the messages or changes are imported.
ModelHelper.CaptureRequirement(
782,
@"[In RopSynchronizationImportMessageChange ROP] The RopSynchronizationImportMessageChange ROP ([MS-OXCROPS] section 2.2.13.2) is used to import new messages or changes to existing messages into the server replica.");
}
}
return result;
}
public static RopResult SynchronizationImportHierarchyChange(int serverId, int uploadContextHandleIndex, int parentFolderHandleIndex, Set<string> properties, int localFolderIdIndex, out int folderIdIndex)
{
// The contractions conditions.
Condition.IsTrue(connections.Count > 0);
Condition.IsTrue(connections.Keys.Contains(serverId));
Condition.IsTrue(connections[serverId].UploadContextContainer.Count > 0);
// Initialize the return value.
RopResult result = RopResult.InvalidParameter;
folderIdIndex = -1;
if (parentFolderHandleIndex == -1)
{
result = RopResult.NoParentFolder;
ModelHelper.CaptureRequirement(
2450,
@"[In Uploading Changes Using ICS] Value is NoParentFolder indicates An attempt is being made to upload a hierarchy change for a folder whose parent folder does not yet exist.");
}
else
{
// Get ConnectionData value.
ConnectionData changeConnection = connections[serverId];
// Record current Upload Information.
AbstractUploadInfo currentUploadInfo = new AbstractUploadInfo();
// Identify current Upload handle.
bool isCurrentUploadHandleExist = false;
foreach (AbstractUploadInfo tempUploadInfo in changeConnection.UploadContextContainer)
{
if (tempUploadInfo.UploadHandleIndex == uploadContextHandleIndex)
{
// Set the value to the variable when the current upload context is existent.
isCurrentUploadHandleExist = true;
currentUploadInfo = tempUploadInfo;
}
}
if (isCurrentUploadHandleExist)
{
// Initialize the variable
AbstractFolder parentfolder = new AbstractFolder();
bool isParentFolderExist = false;
int parentfolderIndex = 0;
AbstractFolder currentFolder = new AbstractFolder();
bool isFolderExist = false;
int currentFolderIndex = 0;
// Research the local folder Id.
foreach (AbstractFolder tempFolder in changeConnection.FolderContainer)
{
if (tempFolder.FolderIdIndex == localFolderIdIndex)
{
// Set the value to the current Folder variable when the current folder is existent.
isFolderExist = true;
currentFolder = tempFolder;
currentFolderIndex = changeConnection.FolderContainer.IndexOf(tempFolder);
}
if (tempFolder.FolderIdIndex == currentUploadInfo.RelatedObjectIdIndex)
{
// Set the value to the parent folder variable when the current parent folder is existent.
isParentFolderExist = true;
parentfolder = tempFolder;
parentfolderIndex = changeConnection.FolderContainer.IndexOf(tempFolder);
}
}
if (isFolderExist & isParentFolderExist)
{
foreach (string tempProperty in properties)
{
if (!currentFolder.FolderProperties.Contains(tempProperty))
{
// Add Property for folder
currentFolder.FolderProperties = currentFolder.FolderProperties.Add(tempProperty);
}
}
// Get the new change Number
currentFolder.ChangeNumberIndex = ModelHelper.GetChangeNumberIndex();
// Update the folder Container
changeConnection.FolderContainer = changeConnection.FolderContainer.Update(currentFolderIndex, currentFolder);
}
else
{
// Create a new folder
AbstractFolder newFolder = new AbstractFolder
{
FolderIdIndex = AdapterHelper.GetObjectIdIndex()
};
// Set new folder Id
folderIdIndex = newFolder.FolderIdIndex;
// Set value for new folder
newFolder.FolderProperties = properties;
newFolder.ParentFolderHandleIndex = parentfolder.FolderHandleIndex;
newFolder.ParentFolderIdIndex = parentfolder.FolderIdIndex;
newFolder.SubFolderIds = new Set<int>();
newFolder.MessageIds = new Set<int>();
// Add the new folder to parent folder
parentfolder.SubFolderIds = parentfolder.SubFolderIds.Add(newFolder.FolderIdIndex);
newFolder.FolderPermission = PermissionLevels.FolderOwner;
newFolder.ChangeNumberIndex = ModelHelper.GetChangeNumberIndex();
ModelHelper.CaptureRequirement(1897, "[In Identifying Objects and Maintaining Change Numbers]When a new object is created, it is assigned a change number.");
// Update FolderContainer information
changeConnection.FolderContainer = changeConnection.FolderContainer.Add(newFolder);
changeConnection.FolderContainer = changeConnection.FolderContainer.Update(parentfolderIndex, parentfolder);
}
// Return Success
connections[serverId] = changeConnection;
// Record RopSynchronizationImportHierarchyChange operation.
priorUploadOperation = PriorOperation.RopSynchronizationImportHierarchyChange;
result = RopResult.Success;
ModelHelper.CaptureRequirement(
2449,
@"[In Uploading Changes Using ICS] Value is Success indicates No error occurred, or a conflict has been resolved.");
// Because if the result is success means the folders or changes are imported.
ModelHelper.CaptureRequirement(
816,
@"[In RopSynchronizationImportHierarchyChange ROP] The RopSynchronizationImportHierarchyChange ROP ([MS-OXCROPS] section 2.2.13.4) is used to import new folders, or changes to existing folders, into the server replica.");
}
}
return result;
}
public static RopResult SynchronizationOpenCollector(int serverId, int folderHandleIndex, SynchronizationTypes synchronizationType, out int uploadContextHandleIndex)
{
// The contractions conditions.
Condition.IsTrue(connections.Count > 0);
Condition.IsTrue(connections.Keys.Contains(serverId));
Condition.IsTrue(connections[serverId].FolderContainer.Count > 0);
// Initialize return value
RopResult result = RopResult.InvalidParameter;
uploadContextHandleIndex = -1;
// Get ConnectionData value.
ConnectionData changeConnection = connections[serverId];
AbstractFolder currentfolder = new AbstractFolder();
// Identify whether the CurrentFolder is existent or not.
bool isCurrentFolderExist = false;
// Identify whether the Current Folder is existent or not.
foreach (AbstractFolder tempfolder in changeConnection.FolderContainer)
{
if (tempfolder.FolderHandleIndex == folderHandleIndex)
{
// Set the value to the variable when the current folder is existent.
isCurrentFolderExist = true;
currentfolder = tempfolder;
}
}
if (isCurrentFolderExist)
{
// Initialize the upload information.
AbstractUploadInfo abstractUploadInfo = new AbstractUploadInfo
{
UploadHandleIndex = AdapterHelper.GetHandleIndex()
};
uploadContextHandleIndex = abstractUploadInfo.UploadHandleIndex;
ModelHelper.CaptureRequirement(778, "[In RopSynchronizationOpenCollector ROP Response Buffer]OutputServerObject: The value of this field MUST be the synchronization upload context.");
abstractUploadInfo.SynchronizationType = synchronizationType;
abstractUploadInfo.RelatedObjectHandleIndex = folderHandleIndex;
abstractUploadInfo.RelatedObjectIdIndex = currentfolder.FolderIdIndex;
// Initialize the updatedState information.
abstractUploadInfo.UpdatedState.IdsetGiven = new Set<int>();
abstractUploadInfo.UpdatedState.CnsetRead = new Set<int>();
abstractUploadInfo.UpdatedState.CnsetSeen = new Set<int>();
abstractUploadInfo.UpdatedState.CnsetSeenFAI = new Set<int>();
// Add the new value to UploadContextContainer.
changeConnection.UploadContextContainer = changeConnection.UploadContextContainer.Add(abstractUploadInfo);
connections[serverId] = changeConnection;
// Record RopSynchronizationImportHierarchyChange operation.
priorOperation = PriorOperation.RopSynchronizationOpenCollector;
result = RopResult.Success;
if (uploadContextHandleIndex != -1)
{
// Because if uploadContextHandleIndex doesn't equal -1 and the ROP return success, so only if this ROP success and return a valid handler this requirement will be verified.
ModelHelper.CaptureRequirement(
769,
@"[In RopSynchronizationOpenCollector ROP] The RopSynchronizationOpenCollector ROP ([MS-OXCROPS] section 2.2.13.7) configures the synchronization upload operation and returns a handle to a synchronization upload context.");
}
}
return result;
}
