コード例 #1
0
        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;
        }
コード例 #2
0
        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;
        }
コード例 #3
0
        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;
        }
コード例 #4
0
        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;
        }
コード例 #5
0
        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;
        }
コード例 #6
0
        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;
        }
コード例 #7
0
        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;
        }