public bool Evaluate(EvaluationContext evaluationContext, ref object state)
        {
                
                // get claims from authorized issuer
                ClaimSet issuedClaims = null;
                foreach (ClaimSet cs in evaluationContext.ClaimSets)
                {
                    // If the issuer of the ClaimSet is this STS...
                    if ( cs.Issuer.ContainsClaim ( Claim.CreateDnsClaim("IPKey")))
                    {
                        issuedClaims = cs;
                    }
                }

                if (issuedClaims == null)
                {
                    throw new SecurityException("Unable to authenticate caller. Invalid claimset provided.");
                }

                CustomIdentity identity = new CustomIdentity("Claims");
                CustomPrincipal newPrincipal = new CustomPrincipal(identity, issuedClaims);

                evaluationContext.Properties["Principal"] = newPrincipal;

            return true;

        }

 // called after the authentication stage
 public bool Evaluate(EvaluationContext evaluationContext, ref object state)
 {
     IList<IIdentity> idents;
     object identsObject;
     if (evaluationContext.Properties.TryGetValue(
         "Identities", out identsObject) && (idents =
         identsObject as IList<IIdentity>) != null)
     {
         foreach (IIdentity ident in idents)
         {
             if (ident.IsAuthenticated &&
                 ident.AuthenticationType == "BiometricValidator")
             {
                 StringReader reader = new StringReader(ident.Name);
                 System.Xml.Serialization.XmlSerializer deserializer = new System.Xml.Serialization.XmlSerializer(typeof(SecureContextCredentials));
                 SecureContextCredentials credentials = (SecureContextCredentials)deserializer.Deserialize(reader);
                 IdsIdentity i = new IdsIdentity(ident.IsAuthenticated, AuthenticationType.Bioemtrics, credentials.IdentityUid);
                 IdsPrincipal p = new IdsPrincipal(i, new List<string> { "LoggedIn" });
                 evaluationContext.Properties["Principal"] = p;
                 return true;
             }
             else
             {
                 string userId = OperationContext.Current.IncomingMessageHeaders.GetHeader<string>("userId", "http://www.identitystream.com");
                 IdsIdentity i = new IdsIdentity(ident.IsAuthenticated, AuthenticationType.Certificate, userId);
                 IdsPrincipal p = new IdsPrincipal(i, new List<string> { "LoggedIn" });
                 evaluationContext.Properties["Principal"] = p;
                 return true;
             }
         }
     }
     return false;
 }

 // called after the authentication stage
 public bool Evaluate(EvaluationContext evaluationContext, ref object state)
 {
     IList<IIdentity> idents;
     object identsObject;
     if (evaluationContext.Properties.TryGetValue(
         "Identities", out identsObject) && (idents =
         identsObject as IList<IIdentity>) != null)
     {
         foreach (IIdentity ident in idents)
         {
             if (ident.IsAuthenticated &&
                 ident.AuthenticationType == "BioUsernamePasswordVerifier")
             {
                 //evaluationContext.Properties["Principal"]
                 //    = new IdsPrincipal();
                 return true;
             }
             else
             {
                 string userId = OperationContext.Current.IncomingMessageHeaders.GetHeader<string>("userId", "http://www.identitystream.com");
             }
         }
     }
     if (!evaluationContext.Properties.ContainsKey("Principal"))
     {
         //evaluationContext.Properties["Principal"] = new IdsPrincipal();
     }
     return false;
 }

        public bool Evaluate(EvaluationContext evaluationContext, ref object state)
        {
            var success = false;

            var identity = GetClientIdentity(evaluationContext);
            if (identity != null)
            {
                if (Roles.Enabled)
                {
                    var provider = Roles.Provider;
                    var roles = provider.GetRolesForUser(identity.Name);

                    if (provider is AzManRoleProvider)
                    {
                        var azman = (AzManRoleProvider)provider;
                        var operations = azman.GetOperationsForUser(identity.Name);

                        evaluationContext.Properties["Principal"] = new AzManPrincipal(identity, roles, operations);
                    }
                    else
                    {
                        evaluationContext.Properties["Principal"] = new GenericPrincipal(identity, roles);
                    }
                }
                else
                {
                    evaluationContext.Properties["Principal"] = new GenericPrincipal(identity, null);
                }

                success = true;
            }

            return success;
        }

        /**
        This method receives the claim sets evaluated so far by other authorization policies.
        For example, it may include a claim set for each token passed in the request message,
         * thus contain a WindowsClaimSet or UserNameClaimSet or x509 cliams set and so on.
         *
         * Responsible for inspecting claims based on the credentials provided,
         * mapping those claims to normalized claims,
         * and constructing a security principal for the request thread.
         *
         * The method should return false if this authorization policy was not able to complete its authorization.
         *
         * If false, the service model will invoke other authorization policies and then call this one once more, passing the updated claim sets.
         * This gives the authorization policy another chance to authorize calls.
         *
        **/
        public bool Evaluate(EvaluationContext evaluationContext, ref object state)
        {
            object obj;
            if (!evaluationContext.Properties.TryGetValue("Identities", out obj))
                return false;

            IList<IIdentity> identities = obj as IList<IIdentity>;
            if (obj == null || identities.Count <= 0)
                return false;

            IIdentity identity = identities[0];

            //This is claims conversion
            ClaimSet claims = MapClaims(identity);

            if (claims == null)
                return false;

            GenericPrincipal newPrincipal = new GenericPrincipal(identity, null);

            evaluationContext.Properties["Principal"] = newPrincipal;

            evaluationContext.AddClaimSet(this, claims);

            return true;
        }

        public bool Evaluate(EvaluationContext evaluationContext, ref object state)
        {
            var client = GetClientIdentity(evaluationContext);
            evaluationContext.Properties["Principal"] = PrincipalFactory.Create(client);

            return true;
        }

        private ClaimSet MapClaims(EvaluationContext evaluationContext, out IIdentity identity)
        {

            List<IIdentity> identities = evaluationContext.Properties["Identities"] as List<IIdentity>;
            
            if (identities.Count == 0)
                throw new SecurityException("Authorization failed, identity missing from evaluation context.");

            identity = new CustomIdentity(identities[0].Name);
            
            // TODO: check identity against credential store and 
            // determine the appropriate claims to allocate
            
            // NOTE: in this sample, only partner certificates are provided,
            // and at this point have passed authorization, so we will grant
            // all custom claims 
            
            List<Claim> listClaims = new List<Claim>();

            listClaims.Add(new Claim(CustomClaimTypes.Create, "Application", Rights.PossessProperty));
            listClaims.Add(new Claim(CustomClaimTypes.Delete, "Application", Rights.PossessProperty));
            listClaims.Add(new Claim(CustomClaimTypes.Read, "Application", Rights.PossessProperty));
            listClaims.Add(new Claim(CustomClaimTypes.Update, "Application", Rights.PossessProperty));

            return new DefaultClaimSet(this.m_issuer, listClaims);
        }

        public bool Evaluate(EvaluationContext evaluationContext, ref object state)
        {
            IPrincipal principal = null;
            if (HttpContext.Current != null)
            {
                principal = HttpContext.Current.User;
            }

            if (principal != null)
            {
                // set the identity (for PrimaryIdentity)
                evaluationContext.Properties["Identities"] =
                    new List<IIdentity>() { principal.Identity };

                evaluationContext.Properties["Principal"] = principal;

                var nameClaim = Claim.CreateNameClaim(principal.Identity.Name);
                ClaimSet set;

                if (HttpContext.Current != null)
                {
                    set = new DefaultClaimSet(
                        nameClaim,
                        new Claim(ClaimTypes.Authentication, HttpContext.Current.User.Identity, Rights.Identity));
                }
                else
                {
                    set = new DefaultClaimSet(nameClaim);
                }

                evaluationContext.AddClaimSet(this, set);
            }

            return true;
        }

        public bool Evaluate(EvaluationContext evaluationContext, ref object state)
        {
            var client = GetClientIdentity(evaluationContext);

            evaluationContext.Properties["Principal"] = Thread.CurrentPrincipal;
            return true;
        }

        // this method gets called after the authentication stage
        public bool Evaluate(EvaluationContext evaluationContext, ref object state)
        {
            WebOperationContext ctx = WebOperationContext.Current;
            string authHeader = ctx.IncomingRequest.Headers[HttpRequestHeader.Authorization];

            if(!string.IsNullOrEmpty(authHeader))
            {
                string decryptedAuth = Common.Utils.Decrypt(authHeader.Substring(5).Trim());

                if (!string.IsNullOrEmpty(decryptedAuth) && decryptedAuth.Split('|').Length == 2 && decryptedAuth.Split('|')[0] == "mitko" && decryptedAuth.Split('|')[1] == "[email protected]#mitko123")
                {
                    evaluationContext.Properties["Principal"] = new CustomPrincipal(new CredentialsValidator.CustomIdeintity("Basic", true, "decryptedAuth[0]"));

                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;

            }
        }

 public bool Evaluate(EvaluationContext evaluationContext, ref object state)
 {
   evaluationContext.AddClaimSet(this, new DefaultClaimSet(Claim.CreateNameClaim(_principal.Identity.Name)));
   evaluationContext.Properties["Identities"] = new List<IIdentity>(new[] {_principal.Identity});
   evaluationContext.Properties["Principal"] = _principal;
   return true;
 }

        bool IAuthorizationPolicy.Evaluate( EvaluationContext evaluationContext, ref object state )
        {
            foreach ( ClaimSet issuance in _issuedClaimSets )
                evaluationContext.AddClaimSet( this, issuance );

            return true;
        }

 // this method gets called after the authentication stage
 public bool Evaluate(EvaluationContext evaluationContext, ref object state)
 {
     // get the authenticated client identity
     IIdentity client = GetClientIdentity(evaluationContext);
     // set the custom principal
     evaluationContext.Properties["Principal"] = new CustomPrincipal(client);
     return true;
 }

        public bool Evaluate(EvaluationContext evaluationContext, ref object state)
        {
            IPrincipal user = OperationContext.Current.IncomingMessageProperties["Principal"] as IPrincipal;
            evaluationContext.Properties["Principal"] = user;
            evaluationContext.Properties["Identities"] = new List<IIdentity> { user.Identity };

            return true;
        }

        public bool Evaluate(EvaluationContext evaluationContext, ref object state)
        {
            IIdentity identity = GetIdentityFromClient(evaluationContext);
            CustomIdentity Identity = new CustomIdentity(identity.AuthenticationType, identity.Name);

            evaluationContext.Properties["Principal"] = new CustomPrincipal(Identity, SecurityHelper.GetRolesByUserName(Identity.Name), SecurityHelper.GetPermissions());
            return true;
        }

        public bool Evaluate(EvaluationContext evaluationContext, ref object state)
        {
            IIdentity client = GetClientIdentity(evaluationContext);

            evaluationContext.Properties["Principal"] = new CustomPrincipal(client);

            return true;
        }

        public bool Evaluate(EvaluationContext evaluationContext, ref object state)
        {
            // set a new principal holding the combined roles
            // this could be your own IPrincipal implementation
            var currentIdentity = GetClientIdentity(evaluationContext);
            evaluationContext.Properties["Principal"] = new GenericPrincipal(new GenericIdentity(currentIdentity.Name + "_Modified"), new string[]{});

            return true;
        }

        public bool Evaluate(EvaluationContext context, ref object state)
        {
            foreach (ClaimSet issuance in this.issuedClaimSets)
            {
                context.AddClaimSet(this, issuance);
            }

            return true;
        }

        public bool Evaluate(EvaluationContext evaluationContext, ref object state)
        {
            var client = GetClientIdentity(evaluationContext);

            evaluationContext.Properties["Principal"] = new GenericPrincipal(client, new[] { client.Name });
            Id = Guid.NewGuid().ToString();

            return true;
        }

 bool IAuthorizationPolicy.Evaluate( EvaluationContext evaluationContext, ref object state )
 {
     if ( evaluationContext == null )
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( "evaluationContext" );
     }
     evaluationContext.AddClaimSet( this, _issuer );
     return true;
 }