Пример #1
0
        public static bool TryParse(
            Uri identifier,
            IReadOnlyCollection <IExtension> extensions,
            out IUniformResourceIdentifier parsedIdentifier)
        {
            parsedIdentifier = null;

            if (null == identifier)
            {
                throw new ArgumentNullException(UniformResourceIdentifier.ArgumentNameIdentifier);
            }

            IReadOnlyCollection <IExtension> effectiveExtensions =
                extensions ?? Array.Empty <IExtension>();

            IResourceQuery query = new ResourceQuery(identifier);

            IReadOnlyCollection <string> alternatePathCollection =
                effectiveExtensions
                .Select(
                    (IExtension item) =>
                    string.Format(CultureInfo.InvariantCulture, UniformResourceIdentifier.AlternatePathTemplate, item.Path))
                .ToArray();
            string alternatePaths = string.Join(string.Empty, alternatePathCollection);

            string retrievalPattern =
                string.Format(CultureInfo.InvariantCulture, UniformResourceIdentifier.RetrievalPatternTemplate, alternatePaths);
            Regex retrievalExpression = new Regex(retrievalPattern, RegexOptions.IgnoreCase);
            Match expressionMatch     = retrievalExpression.Match(identifier.AbsoluteUri);

            if (!expressionMatch.Success)
            {
                return(false);
            }

            string type = expressionMatch.Groups[UniformResourceIdentifier.ExpressionGroupNameType].Value;

            if (string.IsNullOrWhiteSpace(type))
            {
                return(false);
            }

            string schemaIdentifier;

            switch (type)
            {
            case ProtocolConstants.PathGroups:
                schemaIdentifier = SchemaIdentifiers.Core2Group;
                break;

            case ProtocolConstants.PathUsers:
                schemaIdentifier = SchemaIdentifiers.Core2EnterpriseUser;
                break;

            default:
                if (null == extensions)
                {
                    return(false);
                }

                schemaIdentifier =
                    effectiveExtensions
                    .Where(
                        (IExtension item) =>
                        string.Equals(item.Path, type, StringComparison.OrdinalIgnoreCase))
                    .Select(
                        (IExtension item) =>
                        item.SchemaIdentifier)
                    .SingleOrDefault();
                if (string.IsNullOrWhiteSpace(schemaIdentifier))
                {
                    return(false);
                }
                break;
            }

            IResourceIdentifier resourceIdentifier = new ResourceIdentifier();

            resourceIdentifier.SchemaIdentifier = schemaIdentifier;

            string resourceIdentifierValue = expressionMatch.Groups[UniformResourceIdentifier.ExpressionGroupNameIdentifier].Value;

            if (!string.IsNullOrWhiteSpace(resourceIdentifierValue))
            {
                string unescapedIdentifier = Uri.UnescapeDataString(resourceIdentifierValue);
                resourceIdentifier.Identifier = unescapedIdentifier;
            }

            parsedIdentifier = new UniformResourceIdentifier(resourceIdentifier, query);
            return(true);
        }
Пример #2
0
        public ResourceQuery(Uri resource)
        {
            if (null == resource)
            {
                throw new ArgumentNullException(nameof(resource));
            }

            string query = resource.Query;

            if (!string.IsNullOrWhiteSpace(query))
            {
                NameValueCollection  keyedValues = HttpUtility.ParseQueryString(query);
                IEnumerable <string> keys        = keyedValues.AllKeys;
                foreach (string key in keys)
                {
                    if (string.Equals(key, QueryKeys.Attributes, StringComparison.OrdinalIgnoreCase))
                    {
                        string attributeExpression = keyedValues[key];
                        if (!string.IsNullOrWhiteSpace(attributeExpression))
                        {
                            this.Attributes = ResourceQuery.ParseAttributes(attributeExpression);
                        }
                    }

                    if (string.Equals(key, QueryKeys.Count, StringComparison.OrdinalIgnoreCase))
                    {
                        Action <IPaginationParameters, int> action =
                            new Action <IPaginationParameters, int>(
                                (IPaginationParameters pagination, int paginationValue) =>
                                pagination.Count = paginationValue);
                        this.ApplyPaginationParameter(keyedValues[key], action);
                    }

                    if (string.Equals(key, QueryKeys.ExcludedAttributes, StringComparison.OrdinalIgnoreCase))
                    {
                        string attributeExpression = keyedValues[key];
                        if (!string.IsNullOrWhiteSpace(attributeExpression))
                        {
                            this.ExcludedAttributes = ResourceQuery.ParseAttributes(attributeExpression);
                        }
                    }

                    if (string.Equals(key, QueryKeys.Filter, StringComparison.OrdinalIgnoreCase))
                    {
                        string filterExpression = keyedValues[key];
                        if (!string.IsNullOrWhiteSpace(filterExpression))
                        {
                            this.Filters = ResourceQuery.ParseFilters(filterExpression);
                        }
                    }

                    if (string.Equals(key, QueryKeys.StartIndex, StringComparison.OrdinalIgnoreCase))
                    {
                        Action <IPaginationParameters, int> action =
                            new Action <IPaginationParameters, int>(
                                (IPaginationParameters pagination, int paginationValue) =>
                                pagination.StartIndex = paginationValue);
                        this.ApplyPaginationParameter(keyedValues[key], action);
                    }
                }
            }

            if (null == this.Filters)
            {
                this.Filters = Array.Empty <Filter>();
            }

            if (null == this.Attributes)
            {
                this.Attributes = Array.Empty <string>();
            }

            if (null == this.ExcludedAttributes)
            {
                this.ExcludedAttributes = Array.Empty <string>();
            }
        }