/// <summary>
        /// Find same claim record from internal database
        /// </summary>
        /// <param name="principalDN">Distinguished Name of principal</param>
        /// <param name="principalClass">principal type</param>
        /// <param name="sourceType">claim source type, AD or certificate</param>
        /// <param name="claimID">ID of claim</param>
        /// <param name="valueType">claim value type</param>
        /// <param name="unobjected_values">values parsed into string and split with |ClaimUtilitySpliter|</param>
        /// <returns>true if found matched</returns>
        public static bool FoundMatchedClaim(string principalDN, ClaimsPrincipalClass principalClass, CLAIMS_SOURCE_TYPE sourceType, string claimID, CLAIM_TYPE valueType, string unobjected_values)
        {
            #region parse values from the string
            object[] values = ClaimUtility.ConvertStringToEntryUnion(valueType, unobjected_values);
            #endregion

            #region find same claim record
            for (int i = 0; i < sourceClaims.Length; i++)
            {
                if (sourceClaims[i].usClaimsSourceType == (short)sourceType)
                {
                    for (int j = 0; j < sourceClaims[i].ClaimEntries.Length; j++)
                    {
                        CLAIM_ENTRY entry = sourceClaims[i].ClaimEntries[j];
                        if (entry.Id == claimID && entry.Type == valueType)
                        {
                            //found claim with same ID and value type, need to check values
                            switch (valueType)
                            {
                                case CLAIM_TYPE.CLAIM_TYPE_BOOLEAN:
                                    {
                                        if (entry.Values.Struct4.BooleanValues.Length != values.Length)
                                            return false;

                                        for (int k = 0; k < entry.Values.Struct4.BooleanValues.Length; k++)
                                        {

                                            if ((bool)values[k] != entry.Values.Struct4.BooleanValues[k])
                                                return false;
                                        }
                                        return true;
                                    }
                                case CLAIM_TYPE.CLAIM_TYPE_INT64:
                                    {
                                        if (entry.Values.Struct1.Int64Values.Length != values.Length)
                                            return false;

                                        for (int k = 0; k < entry.Values.Struct1.Int64Values.Length; k++)
                                        {
                                            if ((int)values[k] != entry.Values.Struct1.Int64Values[k])
                                                return false;
                                        }
                                        return true;
                                    }
                                case CLAIM_TYPE.CLAIM_TYPE_STRING:
                                    {
                                        if (entry.Values.Struct3.StringValues.Length != values.Length)
                                            return false;

                                        for (int k = 0; k < entry.Values.Struct3.StringValues.Length; k++)
                                        {

                                            if ((string)values[k] != entry.Values.Struct3.StringValues[k])
                                                return false;
                                        }
                                        return true;
                                    }
                                case CLAIM_TYPE.CLAIM_TYPE_UINT64:
                                    {
                                        if (entry.Values.Struct2.Uint64Values.Length != values.Length)
                                            return false;

                                        for (int k = 0; k < entry.Values.Struct2.Uint64Values.Length; k++)
                                        {

                                            if ((uint)values[k] != entry.Values.Struct2.Uint64Values[k])
                                                return false;
                                        }
                                        return true;
                                    }
                            }
                        }
                    }
                }
            }
            #endregion
            return false;
        }
Exemple #2
0
        /// <summary>
        /// Find same claim record from internal database
        /// </summary>
        /// <param name="principalDN">Distinguished Name of principal</param>
        /// <param name="principalClass">principal type</param>
        /// <param name="sourceType">claim source type, AD or certificate</param>
        /// <param name="claimID">ID of claim</param>
        /// <param name="valueType">claim value type</param>
        /// <param name="unobjected_values">values parsed into string and split with |ClaimUtilitySpliter|</param>
        /// <returns>true if found matched</returns>
        public static bool FoundMatchedClaim(string principalDN, ClaimsPrincipalClass principalClass, CLAIMS_SOURCE_TYPE sourceType, string claimID, CLAIM_TYPE valueType, string unobjected_values)
        {
            #region parse values from the string
            object[] values = ClaimUtility.ConvertStringToEntryUnion(valueType, unobjected_values);
            #endregion

            #region find same claim record
            for (int i = 0; i < sourceClaims.Length; i++)
            {
                if (sourceClaims[i].usClaimsSourceType == (short)sourceType)
                {
                    for (int j = 0; j < sourceClaims[i].ClaimEntries.Length; j++)
                    {
                        CLAIM_ENTRY entry = sourceClaims[i].ClaimEntries[j];
                        if (entry.Id == claimID && entry.Type == valueType)
                        {
                            //found claim with same ID and value type, need to check values
                            switch (valueType)
                            {
                            case CLAIM_TYPE.CLAIM_TYPE_BOOLEAN:
                            {
                                if (entry.Values.Struct4.BooleanValues.Length != values.Length)
                                {
                                    return(false);
                                }

                                for (int k = 0; k < entry.Values.Struct4.BooleanValues.Length; k++)
                                {
                                    if ((bool)values[k] != entry.Values.Struct4.BooleanValues[k])
                                    {
                                        return(false);
                                    }
                                }
                                return(true);
                            }

                            case CLAIM_TYPE.CLAIM_TYPE_INT64:
                            {
                                if (entry.Values.Struct1.Int64Values.Length != values.Length)
                                {
                                    return(false);
                                }

                                for (int k = 0; k < entry.Values.Struct1.Int64Values.Length; k++)
                                {
                                    if ((int)values[k] != entry.Values.Struct1.Int64Values[k])
                                    {
                                        return(false);
                                    }
                                }
                                return(true);
                            }

                            case CLAIM_TYPE.CLAIM_TYPE_STRING:
                            {
                                if (entry.Values.Struct3.StringValues.Length != values.Length)
                                {
                                    return(false);
                                }

                                for (int k = 0; k < entry.Values.Struct3.StringValues.Length; k++)
                                {
                                    if ((string)values[k] != entry.Values.Struct3.StringValues[k])
                                    {
                                        return(false);
                                    }
                                }
                                return(true);
                            }

                            case CLAIM_TYPE.CLAIM_TYPE_UINT64:
                            {
                                if (entry.Values.Struct2.Uint64Values.Length != values.Length)
                                {
                                    return(false);
                                }

                                for (int k = 0; k < entry.Values.Struct2.Uint64Values.Length; k++)
                                {
                                    if ((uint)values[k] != entry.Values.Struct2.Uint64Values[k])
                                    {
                                        return(false);
                                    }
                                }
                                return(true);
                            }
                            }
                        }
                    }
                }
            }
            #endregion
            return(false);
        }