コード例 #1
0
        /// <summary>
        /// This method is used to map abstract, client-defined named properties to concrete 16-bit property IDs. 
        /// </summary>
        /// <param name="isTestOrder">Indicates whether to test returned PropertyNames order.</param>
        /// <param name="isCreateFlagSet">Indicates whether the "Create" Flags in request parameter is set.</param>
        /// <param name="isPropertyNameExisting">Indicates whether PropertyName is existing in object mapping.</param>
        /// <param name="specialPropertyName">Specifies PropertyName of request parameter</param>
        /// <param name="isCreatedEntryReturned">If Create Flags is set: If set, indicates that the server MUST create new
        /// entries for any name parameters that are not found in the existing mapping set, and return existing entries for any
        /// name parameters that are found in the existing mapping set.</param>
        /// <param name="error">Specifies the ErrorCode when server reached limit.</param>
        public void RopGetPropertyIdsFromNamesMethod(
            bool isTestOrder,
            bool isCreateFlagSet,
            bool isPropertyNameExisting,
            SpecificPropertyName specialPropertyName,
            out bool isCreatedEntryReturned,
            out CPRPTErrorCode error)
        {
            #region Initialize parameters
            // Specify whether the order in response is the same as that in request.
            bool isOrder = true;

            // Specify whether the property names and ids are mapped.
            bool isNamesAndIdsMapping = false;

            // Set default value for the out parameter.
            isCreatedEntryReturned = false;
            error = CPRPTErrorCode.None;

            // Set value for flags in RopGetPropertyIdsFromNames.
            byte flags = (byte)GetPropertyIdsFromNamesFlags.None;
            if (isCreateFlagSet)
            {
                flags = (byte)GetPropertyIdsFromNamesFlags.Create;
            }

            PropertyName[] propertyNames = null;

            if (isTestOrder)
            {
                propertyNames = new PropertyName[ConstValues.TestPropertyCount];
            }
            else
            {
                propertyNames = new PropertyName[1];
            }

            switch (specialPropertyName)
            {
                case SpecificPropertyName.Kind0x01:
                case SpecificPropertyName.NoConstraint:
                    propertyNames[0] = this.GetPropertyName((byte)Kind.NameField);
                    break;
                case SpecificPropertyName.PS_MAPIAndKind0x01:
                    propertyNames[0] = this.GetPropertyName((byte)Kind.NameField);
                    propertyNames[0].Guid = (new Guid(PSMAPI)).ToByteArray();
                    break;
                case SpecificPropertyName.PS_MAPIAndKind0x00:
                    propertyNames[0] = this.GetPropertyName((byte)Kind.LidField);
                    propertyNames[0].Guid = (new Guid(PSMAPI)).ToByteArray();
                    break;
                default:
                    Site.Assert.Fail("Invalid SpecificPropertyName enum value {0}.", specialPropertyName);
                    break;
            }

            if (!isPropertyNameExisting && !isCreateFlagSet)
            {
                propertyNames[0].Kind = (byte)Kind.NameField;
                propertyNames[0].Name = Encoding.Unicode.GetBytes(PropertyNameNotMapped + "\0");
                propertyNames[0].NameSize = (byte)propertyNames[0].Name.Length;
                propertyNames[0].Guid = (new Guid(PropertyNameNotMappedGuid)).ToByteArray();
            }

            // The existing property ID.
            ushort existId = 0;

            // If the property exists, create it.
            if (isPropertyNameExisting)
            {
                PropertyName[] propertyNameTmp = new PropertyName[1];
                propertyNameTmp[0] = propertyNames[0];
                RopGetPropertyIdsFromNamesResponse ptyNameExistingRes = this.RopGetPropertyIdsFromNames(this.cprptCurrentHandle, (byte)GetPropertyIdsFromNamesFlags.Create, propertyNameTmp, true);
                existId = ptyNameExistingRes.PropertyIds[0].ID;
            }

            // The second property ID.
            ushort secondId = 0;

            // The third property ID.
            ushort thirdId = 0;

            // If the PropertyNames order need to verify, create the second and the third properties.
            if (isTestOrder)
            {
                // Add second property.
                PropertyName[] propertyNameTmp = new PropertyName[1];
                propertyNameTmp[0] = this.GetPropertyName((byte)Kind.NameField);
                propertyNameTmp[0].Name[0]++;
                propertyNameTmp[0].Guid[0]++;
                propertyNames[1] = propertyNameTmp[0];
                RopGetPropertyIdsFromNamesResponse ptyNameExistingRes = this.RopGetPropertyIdsFromNames(this.cprptCurrentHandle, (byte)GetPropertyIdsFromNamesFlags.Create, propertyNameTmp, true);
                secondId = ptyNameExistingRes.PropertyIds[0].ID;

                // Add second property.
                propertyNameTmp[0] = this.GetPropertyName((byte)Kind.NameField);
                propertyNameTmp[0].Name[0]--;
                propertyNameTmp[0].Guid[0]--;
                propertyNames[2] = propertyNameTmp[0];
                ptyNameExistingRes = this.RopGetPropertyIdsFromNames(this.cprptCurrentHandle, (byte)GetPropertyIdsFromNamesFlags.Create, propertyNameTmp, true);
                thirdId = ptyNameExistingRes.PropertyIds[0].ID;
            }
            #endregion

            RopGetPropertyIdsFromNamesResponse getPropertyIdsFromNamesResponse = this.RopGetPropertyIdsFromNames(this.cprptCurrentHandle, flags, propertyNames, false);

            #region When property exists, check if names and ids are mapping
            if (isPropertyNameExisting)
            {
                RopGetNamesFromPropertyIdsResponse getPropertyNamesFromPropertyIdsResponse = this.RopGetNamesFromPropertyIds(this.cprptCurrentHandle, getPropertyIdsFromNamesResponse.PropertyIds);

                // Verify whether property name and id is mapping.
                for (int i = 0; i < getPropertyNamesFromPropertyIdsResponse.PropertyNameCount; i++)
                {
                    if (getPropertyNamesFromPropertyIdsResponse.PropertyNames[i].Kind == (byte)Kind.LidField)
                    {
                        if ((getPropertyNamesFromPropertyIdsResponse.PropertyNames[i].Guid.ToString() == propertyNames[i].Guid.ToString()) &&
                            (getPropertyNamesFromPropertyIdsResponse.PropertyNames[i].Kind == propertyNames[i].Kind) &&
                            (getPropertyNamesFromPropertyIdsResponse.PropertyNames[i].LID == propertyNames[i].LID))
                        {
                            isNamesAndIdsMapping = true;
                        }
                        else
                        {
                            isNamesAndIdsMapping = false;
                            break;
                        }
                    }
                    else if (getPropertyNamesFromPropertyIdsResponse.PropertyNames[i].Kind == (byte)Kind.NameField)
                    {
                        if ((getPropertyNamesFromPropertyIdsResponse.PropertyNames[i].Guid.ToString() == propertyNames[i].Guid.ToString()) &&
                            (getPropertyNamesFromPropertyIdsResponse.PropertyNames[i].Kind == propertyNames[i].Kind) &&
                            (getPropertyNamesFromPropertyIdsResponse.PropertyNames[i].NameSize == propertyNames[i].NameSize) &&
                            (getPropertyNamesFromPropertyIdsResponse.PropertyNames[i].Name.ToString() == propertyNames[i].Name.ToString()))
                        {
                            isNamesAndIdsMapping = true;
                        }
                        else
                        {
                            isNamesAndIdsMapping = false;
                            break;
                        }
                    }
                }
            }
            #endregion

            #region Test order
            if (getPropertyIdsFromNamesResponse.PropertyIds != null && propertyNames.Length == ConstValues.TestPropertyCount && getPropertyIdsFromNamesResponse.PropertyIds.Length == ConstValues.TestPropertyCount)
            {
                if (getPropertyIdsFromNamesResponse.PropertyIds[1].ID != secondId || getPropertyIdsFromNamesResponse.PropertyIds[2].ID != thirdId)
                {
                    isOrder = false;
                }
            }
            #endregion

            this.VerifyRopGetPropertyIdsFromNames((ushort)propertyNames.Length, propertyNames, flags, getPropertyIdsFromNamesResponse, isOrder, this.cprptCurrentType, isPropertyNameExisting, isNamesAndIdsMapping);

            #region Check error and isCreateEnrtyReturned

            switch ((CPRPTErrorCode)getPropertyIdsFromNamesResponse.ReturnValue)
            {
                case CPRPTErrorCode.None:

                    // Verify whether the created entry is returned.
                    if (isCreateFlagSet)
                    {
                        if (isPropertyNameExisting)
                        {
                            isCreatedEntryReturned = false;
                        }
                        else if (getPropertyIdsFromNamesResponse.PropertyIds[0].ID != existId)
                        {
                            isCreatedEntryReturned = true;
                        }
                    }

                    break;
                case CPRPTErrorCode.ecWarnWithErrors:
                    error = CPRPTErrorCode.ecWarnWithErrors;
                    break;
                case CPRPTErrorCode.NotEnoughMemory:
                    error = CPRPTErrorCode.NotEnoughMemory;
                    break;
                default:
                    Site.Assert.Fail("Unexpected RopGetPropertyIdsFromNames error code.Error: 0x{0:X8}", getPropertyIdsFromNamesResponse.ReturnValue);
                    break;
            }

            #endregion
        }
コード例 #2
0
        public static void RopGetPropertyIdsFromNamesMethod(
            bool isTestOrder,
            bool isCreateFlagSet,
            bool isPropertyNameExisting,
            SpecificPropertyName specialPropertyName,
            out bool isCreatedEntryReturned,
            out CPRPTErrorCode error)
        {
            Condition.IsTrue(isInitialized);

            isCreatedEntryReturned = false;
            error = CPRPTErrorCode.None;

            if (isCreateFlagSet && !isPropertyNameExisting)
            {
                isCreatedEntryReturned = true;
                ModelHelper.CaptureRequirement(
                    628,
                    @"[In RopGetPropertyIdsFromNames ROP Request Buffer] Flags: This field is set to 0x02 to request that a new entry be created for 
                    each named property that is not found in the existing mapping table; ");
            }

            if (!isCreateFlagSet)
            {
                isCreatedEntryReturned = false;
                ModelHelper.CaptureRequirement(
                    62801,
                    @"[In RopGetPropertyIdsFromNames ROP Request Buffer] Flags: This field is set to 0x00 otherwise[If not request a new entry to be created for each named property that is not found in the existing mapping table].");
            }
        }