private void ValidateUpdateProperty(IdentityResourceMetaData identityResourceMetaData, string type, string value)
        {
            if (identityResourceMetaData == null)
            {
                throw new ArgumentNullException(nameof(identityResourceMetaData));
            }

            if (string.IsNullOrWhiteSpace(type))
            {
                ModelState.AddModelError("", Messages.PropertyTypeRequired);
                return;
            }

            var prop = identityResourceMetaData.UpdateProperties.SingleOrDefault(x => x.Type == type);

            if (prop == null)
            {
                ModelState.AddModelError("", string.Format(Messages.PropertyInvalid, type));
            }
            else
            {
                var error = prop.Validate(value);
                if (error != null)
                {
                    ModelState.AddModelError("", error);
                }
            }
        }
        private IEnumerable <string> ValidateCreateProperties(IdentityResourceMetaData identityResourceMetaData, IEnumerable <PropertyValue> properties)
        {
            if (identityResourceMetaData == null)
            {
                throw new ArgumentNullException(nameof(identityResourceMetaData));
            }
            properties = properties ?? Enumerable.Empty <PropertyValue>();

            var meta = identityResourceMetaData.CreateProperties;

            return(meta.Validate(properties));
        }
        async Task <IdentityResourceMetaData> GetCoreMetaDataAsync()
        {
            if (_metadata == null)
            {
                _metadata = await _service.GetMetadataAsync();

                if (_metadata == null)
                {
                    throw new InvalidOperationException("IdentityResourceMetaData returned null");
                }
                _metadata.Validate();

                return(_metadata);
            }

            return(_metadata);
        }
        internal void Validate()
        {
            if (ClientMetaData == null)
            {
                throw new InvalidOperationException("ClientMetaData not assigned.");
            }
            ClientMetaData.Validate();

            if (IdentityResourceMetaData == null)
            {
                throw new InvalidOperationException("IdentityResourceMetaData not assigned.");
            }
            IdentityResourceMetaData.Validate();

            if (ApiResourceMetaData == null)
            {
                throw new InvalidOperationException("ApiResourceMetaData not assigned.");
            }
            ApiResourceMetaData.Validate();
        }
        private IdentityResourceMetaData GetMetadata()
        {
            if (_metadata == null)
            {
                var updateIdentityResource = new List <PropertyMetadata>();
                updateIdentityResource.AddRange(PropertyMetadata.FromType <InMemoryIdentityResource>());

                var createIdentityResource = new List <PropertyMetadata>
                {
                    PropertyMetadata.FromProperty <InMemoryIdentityResource>(x => x.Name, "IdentityResourceName", required: true),
                };

                _metadata = new IdentityResourceMetaData
                {
                    SupportsCreate   = true,
                    SupportsDelete   = true,
                    CreateProperties = createIdentityResource,
                    UpdateProperties = updateIdentityResource
                };
            }
            return(_metadata);
        }
Exemplo n.º 6
0
 public CreateIdentityResourceLink(IUrlHelper url, IdentityResourceMetaData identityResourceMetaData)
 {
     this["href"] = url.RelativeLink(Constants.RouteNames.CreateIdentityResource);
     this["meta"] = identityResourceMetaData.CreateProperties;
 }
Exemplo n.º 7
0
        public IdentityResourceDetailResource(IdentityResourceDetail identityResource, IUrlHelper url, IdentityResourceMetaData metaData)
        {
            if (identityResource == null)
            {
                throw new ArgumentNullException(nameof(identityResource));
            }
            if (url == null)
            {
                throw new ArgumentNullException(nameof(url));
            }
            if (metaData == null)
            {
                throw new ArgumentNullException(nameof(metaData));
            }

            Data = new IdentityResourceDetailDataResource(identityResource, url, metaData);

            var links = new Dictionary <string, string>();

            if (metaData.SupportsDelete)
            {
                links["Delete"] = url.RelativeLink(Constants.RouteNames.DeleteIdentityResource, new { subject = identityResource.Subject });
            }
            Links = links;
        }
        public IdentityResourceDetailDataResource(IdentityResourceDetail identityResource, IUrlHelper url, IdentityResourceMetaData metaData)
        {
            if (identityResource == null)
            {
                throw new ArgumentNullException(nameof(identityResource));
            }
            if (url == null)
            {
                throw new ArgumentNullException(nameof(url));
            }
            if (metaData == null)
            {
                throw new ArgumentNullException(nameof(metaData));
            }

            this["Name"]        = identityResource.Name;
            this["Description"] = identityResource.Description;
            this["Subject"]     = identityResource.Subject;

            if (identityResource.Properties != null)
            {
                var props = (from p in identityResource.Properties
                             let m = (from m in metaData.UpdateProperties where m.Type == p.Type select m).SingleOrDefault()
                                     where m != null
                                     select new
                {
                    Data = m.Convert(p.Value),
                    Meta = m,
                    Links = new
                    {
                        update = url.RelativeLink(Constants.RouteNames.UpdateIdentityResourceProperty,
                                                  new
                        {
                            subject = identityResource.Subject,
                            type = p.Type.ToBase64UrlEncoded()
                        }
                                                  )
                    }
                }).ToList();

                if (props.Any())
                {
                    this["Properties"] = props.ToArray();
                }
            }

            if (identityResource.IdentityResourceClaims != null)
            {
                var identityResourceClaims = from c in identityResource.IdentityResourceClaims.ToArray()
                                             select new
                {
                    Data  = c,
                    Links = new
                    {
                        delete = url.RelativeLink(Constants.RouteNames.RemoveIdentityResourceClaim, new
                        {
                            subject = identityResource.Subject,
                            id      = c.Id
                        })
                    }
                };
                this["Claims"] = new
                {
                    Data  = identityResourceClaims.ToArray(),
                    Links = new
                    {
                        create = url.RelativeLink(Constants.RouteNames.AddIdentityResourceClaim, new { subject = identityResource.Subject })
                    }
                };
            }
        }
        public IdentityResourceQueryResultResourceData(QueryResult <IdentityResourceSummary> result, IUrlHelper url, IdentityResourceMetaData meta)
        {
            if (result == null)
            {
                throw new ArgumentNullException(nameof(result));
            }
            if (url == null)
            {
                throw new ArgumentNullException(nameof(url));
            }
            if (meta == null)
            {
                throw new ArgumentNullException(nameof(meta));
            }

            Mapper.Map(result, this);

            foreach (var identityResource in this.Items)
            {
                var links = new Dictionary <string, string>
                {
                    { "detail", url.RelativeLink(Constants.RouteNames.GetIdentityResource, new { subject = identityResource.Data.Subject }) }
                };
                if (meta.SupportsDelete)
                {
                    links.Add("delete", url.RelativeLink(Constants.RouteNames.DeleteIdentityResource, new { subject = identityResource.Data.Subject }));
                }
                identityResource.Links = links;
            }
        }
        public IdentityResourceQueryResultResource(QueryResult <IdentityResourceSummary> result, IUrlHelper url, IdentityResourceMetaData meta)
        {
            if (result == null)
            {
                throw new ArgumentNullException(nameof(result));
            }
            if (url == null)
            {
                throw new ArgumentNullException(nameof(url));
            }
            if (meta == null)
            {
                throw new ArgumentNullException(nameof(meta));
            }

            Data = new IdentityResourceQueryResultResourceData(result, url, meta);

            var links = new Dictionary <string, object>();

            if (meta.SupportsCreate)
            {
                links["create"] = new CreateIdentityResourceLink(url, meta);
            }
            ;
            Links = links;
        }