BaseAPIResourceView.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
 
using AnalyzeRe.APITypes;
using AnalyzeRe.Attributes;
using AnalyzeRe.Metrics;
using AnalyzeRe.Rest;
using AnalyzeRe.Utilities;
 
// Disable warnings about snake_case function names in this method. While it goes against
// C# best-practice, it's done intentionally to follow the API conventions closely.
#pragma warning disable IDE1006
 
namespace AnalyzeRe.APIResourceView
{
    public abstract class BaseAPIResourceView : APIResource, IAPIResourceView
    {
        #region Private Fields
        private YLTSimulationResult _ylt;
 
        private YELTSimulationResult _yelt;
        #endregion Private Fields
 
        #region Public Properties
        [DataMember(Order = 11)]
        [NotNull]
        public IReference<AnalysisProfile> analysis_profile { get; set; }
 
        [DataMember(Order = 12)]
        [ServerGenerated]
        public string ylt_id { get; set; }
 
        [DataMember(Order = 13)]
        [TargetCurrencyDefault]
        public string target_currency { get; set; }
 
        [IgnoreDataMember]
        public YLTSimulationResult ylt => _ylt ?? (_ylt = new YLTSimulationResult(this));
 
        [IgnoreDataMember]
        public YELTSimulationResult yelt => _yelt ?? (_yelt = new YELTSimulationResult(this));
        #endregion Public Properties
 
        #region Public Metrics Requests
        #region Tail Metrics
        public TailMetrics tail_metrics(double probability,
            MetricsOptions options = null, int? timeout = null)
        {
            options = options ?? MetricsOptions.Default;
            return this.GetSubResource<TailMetrics>(new WindowMetricsRequest(
                    ProbabilityWindow.Tail(probability)), options.GetParameters(), timeout);
        }
 
        public List<TailMetrics> tail_metrics(IEnumerable<double> probabilities,
            MetricsOptions options = null, int? timeout = null)
        {
            IList<ProbabilityWindow> converted = probabilities.Select(ProbabilityWindow.Tail).ToList();
            options = options ?? MetricsOptions.Default;
            return VectorizedRequest<TailMetrics>(converted,
                new WindowMetricsRequest(converted), options.GetParameters(), timeout);
        }
        #endregion Tail Metrics
 
        #region Window Metrics
        public WindowMetrics window_metrics(ProbabilityWindow range,
            MetricsOptions options = null, int? timeout = null)
        {
            options = options ?? MetricsOptions.Default;
            return this.GetSubResource<WindowMetrics>(new WindowMetricsRequest(range),
                options.GetParameters(), timeout);
        }
 
        public List<WindowMetrics> window_metrics(IEnumerable<ProbabilityWindow> ranges,
            MetricsOptions options = null, int? timeout = null)
        {
            IList<ProbabilityWindow> asList = ranges as IList<ProbabilityWindow> ?? ranges.ToList();
            options = options ?? MetricsOptions.Default;
            return VectorizedRequest<WindowMetrics>(asList,
                new WindowMetricsRequest(asList), options.GetParameters(), timeout);
        }
        #endregion Window Metrics
 
        #region Co-Metrics
        public CoMetrics co_metrics<T>(ProbabilityWindow range,
            IReference<T> component, CoMetricsOptions options = null, int? timeout = null)
            where T : IAPIResourceView
        {
            options = options ?? CoMetricsOptions.Default;
            return this.GetSubResource<CoMetrics>(new CoMetricsRequest(range),
                GetCoMetricsParameters(component, options), timeout);
        }
 
        public List<CoMetrics> co_metrics<T>(IEnumerable<ProbabilityWindow> ranges,
            IReference<T> component, CoMetricsOptions options = null, int? timeout = null)
            where T : IAPIResourceView
        {
            options = options ?? CoMetricsOptions.Default;
            IList<ProbabilityWindow> asList = ranges as IList<ProbabilityWindow> ?? ranges.ToList();
            return new List<CoMetrics>(VectorizedRequest<CoMetrics>(asList,
                new CoMetricsRequest(asList), GetCoMetricsParameters(component, options), timeout));
        }
 
        #region Private Helper Methods
        private RequestParameters GetCoMetricsParameters<T>(
            IReference<T> component, CoMetricsOptions options)
            where T : IAPIResourceView
        {
            return options.GetParameters()
                .AddQueryParameter("component_id", component.ref_id)
                .AddQueryParameter("component_type", GetComponentTypeFromReference(component));
        }
 
        private string GetComponentTypeFromReference<T>(IReference<T> component)
            where T : IAPIResourceView
        {
            // Get the most accurate type we can for the referenced component.
            Type referenceType = component.ResourceType;
            // Convert the reference type to the string the server expects.
            string type = typeof(ILayerView).IsAssignableFrom(referenceType) ? "LayerView" :
                typeof(PortfolioView).IsAssignableFrom(referenceType) ? "PortfolioView" : null;
            // Throw an exception if the type could not be resolved.
            if (type == null)
                throw new ArgumentException("The component must be a reference to either a " +
                    "LayerView or PortfolioView type. Supplied reference was of type: " +
                    referenceType.NiceTypeName());
            return type;
        }
        #endregion Private Helper Methods
        #endregion Co-Metrics
 
        #region Exceedance Probability
        public ExceedanceProbability exceedance_probability(double threshold,
            ExceedanceProbabilityOptions options = null, int? timeout = null)
        {
            options = options ?? ExceedanceProbabilityOptions.Default;
            return this.GetSubResource<ExceedanceProbability>(
                new ExceedanceProbRequest(threshold), options.GetParameters(), timeout);
        }
 
        public List<ExceedanceProbability> exceedance_probability(IEnumerable<double> thresholds,
            ExceedanceProbabilityOptions options = null, int? timeout = null)
        {
            IList<double> asList = thresholds as IList<double> ?? thresholds.ToList();
            options = options ?? ExceedanceProbabilityOptions.Default;
            return VectorizedRequest<ExceedanceProbability>(asList,
                new ExceedanceProbRequest(asList), options.GetParameters(), timeout);
        }
        #endregion Exceedance Probability
 
        #region Back Allocation
        [Obsolete("POST a BackAllocatedLayer structure instead.")]
        public BackAllocations back_allocations(string source_id, int? timeout = null)
        {
            // Make the request from the server.
            return this.GetSubResource<BackAllocations>(
                new BackAllocationsRequest(),
                new RequestParameters().AddQueryParameter(nameof(source_id), source_id), timeout);
        }
        #endregion Back Allocation
        #endregion Public Metrics Requests
 
        protected override void AfterMembersCloned(APIType _)
        {
            base.AfterMembersCloned(_);
            _ylt = null;
            _yelt = null;
        }
 
        #region Helper Methods
        private List<T> VectorizedRequest<T>(IList<double> values,
            string resource, RequestParameters parameters, int? timeout)
        {
            if (values == null || values.Count == 0)
                throw new ArgumentException("The list of values cannot be null or empty.");
            // If the user has supplied a list of exactly one probability, the server will
            // return a single value rather than a list, so we must convert the result to a list.
            // Otherwise, submit as a normal vectorized request and expect a list of results back.
            return values.Count == 1 ?
                new List<T> { this.GetSubResource<T>(resource, parameters, timeout) } :
                this.GetSubResource<List<T>>(resource, parameters, timeout);
        }
 
        private List<T> VectorizedRequest<T>(IList<ProbabilityWindow> values,
            string resource, RequestParameters parameters, int? timeout)
        {
            if (values == null || values.Count == 0)
                throw new ArgumentException("The list of values cannot be null or empty.");
            // If the user has supplied a list of exactly one probability, the server will
            // return a single value rather than a list, so we must convert the result to a list.
            // Otherwise, submit as a normal vectorized request and expect a list of results back.
            return values.Count == 1 ?
                new List<T> { this.GetSubResource<T>(resource, parameters, timeout) } :
                this.GetSubResource<List<T>>(resource, parameters, timeout);
        }
        #endregion Helper Methods
 
        #region Request SubResources
        internal class WindowMetricsRequest : ResourcePathBuilder
        {
            private const string SERVER_ENDPOINT_NAME = "window_metrics";
            protected override string base_path => SERVER_ENDPOINT_NAME;
            public WindowMetricsRequest(ProbabilityWindow range) : base(range) { }
            public WindowMetricsRequest(IEnumerable<ProbabilityWindow> ranges) : base(ranges) { }
        }
 
        internal class CoMetricsRequest : ResourcePathBuilder
        {
            private const string SERVER_ENDPOINT_NAME = "window_co_metrics";
            protected override string base_path => SERVER_ENDPOINT_NAME;
            public CoMetricsRequest(ProbabilityWindow range) : base(range) { }
            public CoMetricsRequest(IEnumerable<ProbabilityWindow> ranges) : base(ranges) { }
        }
 
        internal class ExceedanceProbRequest : ResourcePathBuilder
        {
            private const string SERVER_ENDPOINT_NAME = "exceedance_probabilities";
            protected override string base_path => SERVER_ENDPOINT_NAME;
            public ExceedanceProbRequest(double threshold) : base(threshold) { }
            public ExceedanceProbRequest(IEnumerable<double> thresholds) : base(thresholds) { }
        }
 
        internal class BackAllocationsRequest : ResourcePathBuilder
        {
            private const string SERVER_ENDPOINT_NAME = "back_allocations";
            protected override string base_path => SERVER_ENDPOINT_NAME;
        }
        #endregion Request SubResources
 
        // TODO: Delete Deprecated Methods after phase-out period.
        #region Deprecated Public Methods
        [Obsolete("Please provide a ProbabilityWindow rather than a double tail-probability. " +
            "This legacy method was less flexible and only returned the co-tail-metrics.")]
        public CoMetrics co_metrics<T>(
            double probability, IReference<T> component, CoMetricsOptions options)
            where T : IAPIResourceView
        {
            return co_metrics(ProbabilityWindow.Tail(probability), component, options);
        }
 
        [Obsolete("Please provide a list of ProbabilityWindows rather than doubles. " +
            "This legacy method was less flexible and only returned the co-tail-metrics.")]
        public List<CoMetrics> co_metrics<T>(
            List<double> probabilities, IReference<T> component, CoMetricsOptions options)
            where T : IAPIResourceView
        {
            return co_metrics(probabilities.Select(ProbabilityWindow.Tail), component, options);
        }
        #endregion Deprecated Public Methods
    }
}