API.Parameters.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.Serialization;
 
using AnalyzeRe.Rest;
using AnalyzeRe.Utilities;
using RestSharp;
 
namespace AnalyzeRe
{
    public static partial class API
    {
        public static class Parameters
        {
            public const string PATCHContentType = "application/offset+octet-stream";
 
            public static RequestParameters Search(string searchTerms)
            {
                return new RequestParameters().AddQueryParameter("search", searchTerms);
            }
 
            public static RequestParameters AdvancedSearch(string advancedSearchTerms)
            {
                return new RequestParameters().AddQueryParameter("metaquery", advancedSearchTerms);
            }
 
            public static RequestParameters Type(string apiTypeName) =>
                new RequestParameters().AddQueryParameter("type", apiTypeName);
 
            public static RequestParameters Type(Type resourceType) =>
                Type(TypeResolver.GetTypeNameForAPIType(resourceType));
 
            public static RequestParameters Order(string ordering)
            {
                return new RequestParameters().AddQueryParameter("ordering", ordering);
            }
 
            public static RequestParameters Order<T>(Expression<Func<T, object>> propertyExpression,
                bool ascending = true)
            {
                MemberInfo prop = ReflectionUtilities.GetMemberInfo(propertyExpression);
                // The server-side property name for ordering comes from the DataMember attribute
                // or the property if it has one, else it's the lower_case of the property name.
                string name = prop.GetCustomAttributeFast<DataMemberAttribute>()?.Name ??
                    prop.Name.ToLower();
                return Order((ascending ? "" : "-") + name);
            }
 
            public static RequestParameters ExpandReferences()
            {
                return new RequestParameters().AddHeader("References", "expand");
            }
 
            public static RequestParameters Fields(IEnumerable<string> fieldNames)
            {
                if (fieldNames == null || !fieldNames.Any())
                    return null;
                return new RequestParameters().AddQueryParameter("fields", String.Join(",", fieldNames));
            }
 
            public static RequestParameters Omit(IEnumerable<string> fieldNames)
            {
                if (fieldNames == null || !fieldNames.Any())
                    return null;
                return new RequestParameters().AddQueryParameter("omit", String.Join(",", fieldNames));
            }
 
            public static RequestParameters Ids(IEnumerable<string> ids)
            {
                if (ids == null || !ids.Any())
                    return null;
                return new RequestParameters().AddQueryParameter("ids", String.Join(",", ids));
            }
 
            #region Pagination
            public static RequestParameters Page(long offset, long limit)
            {
                return new RequestParameters()
                    .AddQueryParameter("offset", offset.ToString("0"))
                    .AddQueryParameter("limit", limit.ToString("0"));
            }
 
            public static RequestParameters PageNumber(long pageNumber, long resultsPerPage)
            {
                if (pageNumber < 1)
                    throw new ArgumentException("Page number must be 1 or greater.");
                return Page((pageNumber - 1) * resultsPerPage, resultsPerPage);
            }
            #endregion Pagination
 
            #region Large File Upload
            public static RequestParameters DataEntityLength(long totalBytes)
            {
                return new RequestParameters()
                    .AddHeader("Entity-Length", totalBytes.ToString("0"));
            }
 
            public static RequestParameters DataPatchChunk(
                long offsetBytes, byte[] chunkData, int count)
            {
                // HACK: RESTSharp is dumb. It will use the buffer byte array and doesn't
                //       have a way to specify how much of that byte array is usable,
                //       so if it's not all usable we need to copy just the usable bit
                //       to a new, smaller byte array and use that instead.
                if (chunkData.Length > count)
                {
                    byte[] temp = new byte[count];
                    Array.Copy(chunkData, 0, temp, 0, count);
                    chunkData = temp;
                }
                return DataPatchChunk_Object(offsetBytes, chunkData, count);
            }
 
            public static RequestParameters DataPatchChunk(
                long offsetBytes, string chunkData)
            {
                return DataPatchChunk_Object(offsetBytes, chunkData, chunkData.Length);
            }
 
            public static RequestParameters DataPatchChunk_Object(
                long offsetBytes, object chunkData, int content_length)
            {
                return new RequestParameters()
                    .AddHeader("Content-Type", PATCHContentType)
                    .AddHeader("Content-Length", content_length.ToString("0"))
                    .AddHeader("Offset", offsetBytes.ToString("0"))
                    .AddParameter(new Parameter
                    {
                        Name = PATCHContentType,
                        Value = chunkData,
                        Type = ParameterType.RequestBody
                    });
            }
            #endregion Large File Upload
        }
    }
}