Nephila RiskStore

GetAnalysisRequest

General

**Requires Authentication**
Requires any of the roles:	Riskstore.Write, Riskstore.Admin

The following routes are available for this service:
GET	/api/riskstore/analysis/results	Get the analysis by id, this will return results if the analysis is completed

using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization;
using ServiceStack;
using ServiceStack.DataAnnotations;
using Nephila.RiskStore.ServiceModel.Requests;
using Nephila.RiskStore.ServiceModel.Types;
using Nephila.RiskStore.ServiceModel;

namespace Nephila.RiskStore.ServiceModel.Requests
{
    public partial class GetAnalysisRequest
        : IGet
    {
        ///<summary>
        ///The analysis id
        ///</summary>
        [ApiMember(DataType="integer", Description="The analysis id", Format="int64")]
        public virtual long? Id { get; set; }

        ///<summary>
        ///The legacy analysis id
        ///</summary>
        [ApiMember(DataType="integer", Description="The legacy analysis id", Format="int64")]
        public virtual long? LegacyId { get; set; }

        ///<summary>
        ///True to not load all deal allocations, analysis runs etc...
        ///</summary>
        [ApiMember(DataType="boolean", Description="True to not load all deal allocations, analysis runs etc...")]
        public virtual bool? OnlyCoreData { get; set; }
    }

    public partial class RollupResponse
    {
        public virtual Analysis Analysis { get; set; }
        public virtual List<AnalysisPortfolioMetric> PortfolioMetrics { get; set; }
        public virtual List<AnalysisResult> Results { get; set; }
        public virtual ResponseStatus ResponseStatus { get; set; }
        public virtual List<string> UnresolvedDealIds { get; set; }
        public virtual List<ValueTuple<String,String>> UnlinkedDealIds { get; set; }
        public virtual string Message { get; set; }
    }

}

namespace Nephila.RiskStore.ServiceModel.Types
{
    [DataContract]
    public partial class Analysis
        : IObjectWithId
    {
        [DataMember(Order=1)]
        public virtual long Id { get; set; }

        [DataMember(Order=2)]
        public virtual string Name { get; set; }

        [DataMember(Order=3)]
        public virtual DateTime? ModelAsOfDate { get; set; }

        [DataMember(Order=4)]
        public virtual int PerspectiveId { get; set; }

        [DataMember(Order=5)]
        public virtual List<AnalysisConfiguration> Configurations { get; set; }

        [DataMember(Order=6)]
        public virtual List<AnalysisDeal> Deals { get; set; }

        [DataMember(Order=7)]
        public virtual List<AnalysisEventIdFilter> EventIdFilters { get; set; }

        [DataMember(Order=8)]
        public virtual string CreatedBy { get; set; }

        [DataMember(Order=9)]
        public virtual DateTime CreatedDateUtc { get; set; }

        [DataMember(Order=10)]
        public virtual DateTime? CompletedDateUtc { get; set; }

        [DataMember(Order=11)]
        public virtual long? LegacyAnalysisId { get; set; }

        [DataMember(Order=12)]
        public virtual List<MessageTracking> ResultPersistenceTracking { get; set; }

        [DataMember(Order=13)]
        public virtual ProcessingStatus ProcessingStatus { get; set; }

        [DataMember(Order=14)]
        public virtual bool SaveResults { get; set; }

        [DataMember(Order=15)]
        public virtual string EventSourceSystem { get; set; }

        [DataMember(Order=16)]
        public virtual DateTime UpdatedDateUtc { get; set; }

        [DataMember(Order=17)]
        public virtual bool IsExpired { get; set; }

        [DataMember(Order=18)]
        public virtual Guid RowIdentifier { get; set; }

        [DataMember(Order=19)]
        public virtual string ErrorMessage { get; set; }

        ///<summary>
        ///Take the minimum simulation count when we have different simulations between event sets
        ///</summary>
        [DataMember(Order=20)]
        [ApiMember(DataType="boolean", Description="Take the minimum simulation count when we have different simulations between event sets")]
        public virtual bool IgnoreSimulationCountMismatch { get; set; }

        [DataMember(Order=21)]
        [Ignore]
        public virtual ProcessingStatus FinalStatus { get; set; }
    }

    [DataContract]
    public partial class AnalysisConfiguration
        : IObjectWithId, IHasAnalysisId
    {
        [DataMember(Order=1)]
        public virtual long Id { get; set; }

        [DataMember(Order=2)]
        public virtual long AnalysisId { get; set; }

        [DataMember(Order=3)]
        public virtual DateTime? WindowStartDate { get; set; }

        [DataMember(Order=4)]
        public virtual DateTime? WindowEndDate { get; set; }

        [DataMember(Order=5)]
        public virtual bool StandardEnabled { get; set; }

        [DataMember(Order=6)]
        public virtual bool RunOffEnabled { get; set; }

        [DataMember(Order=7)]
        public virtual bool AggregateEnabled { get; set; }

        [DataMember(Order=8)]
        public virtual bool OccurrenceEnabled { get; set; }

        [DataMember(Order=9)]
        public virtual bool NettEnabled { get; set; }

        [DataMember(Order=10)]
        public virtual bool GrossEnabled { get; set; }

        [DataMember(Order=11)]
        public virtual decimal? TailIntensityPercentageStart { get; set; }

        [DataMember(Order=12)]
        public virtual decimal? TailIntensityPercentageEnd { get; set; }

        [DataMember(Order=13)]
        public virtual int MetaRiskId { get; set; }

        [DataMember(Order=14)]
        public virtual ResultOutputLevel OutputLevel { get; set; }

        [DataMember(Order=15)]
        public virtual ProcessingStatus ProcessingStatus { get; set; }

        [DataMember(Order=16)]
        public virtual decimal? EventLossFloorStartRange { get; set; }

        [DataMember(Order=17)]
        public virtual decimal? EventLossFloorEndRange { get; set; }

        [DataMember(Order=18)]
        public virtual List<AnalysisPortfolioEventSetConfiguration> AnalysisPortfolioEventSetConfigurations { get; set; }

        [DataMember(Order=19)]
        public virtual Guid RowIdentifier { get; set; }
    }

    [DataContract]
    public partial class AnalysisDeal
        : IObjectWithId, IHasAnalysisId
    {
        [DataMember(Order=1)]
        public virtual long Id { get; set; }

        [DataMember(Order=2)]
        public virtual long AnalysisId { get; set; }

        [DataMember(Order=3)]
        public virtual string SourceDealId { get; set; }

        [DataMember(Order=4)]
        public virtual string DealRef { get; set; }

        [DataMember(Order=5)]
        public virtual string SourceDealSystem { get; set; }

        [DataMember(Order=6)]
        public virtual long EventSetId { get; set; }

        [DataMember(Order=7)]
        public virtual double ROL { get; set; }

        [DataMember(Order=8)]
        public virtual double Limit { get; set; }

        [DataMember(Order=9)]
        public virtual DateTime InceptionDate { get; set; }

        [DataMember(Order=10)]
        public virtual DateTime ExpiryDate { get; set; }

        [DataMember(Order=11)]
        public virtual TransactionType TransactionType { get; set; }

        [DataMember(Order=12)]
        public virtual List<AnalysisPortfolioAllocation> Allocations { get; set; }

        [DataMember(Order=13)]
        public virtual int? PerspectiveIdOverride { get; set; }

        [DataMember(Order=14)]
        public virtual long? EventSetIdOverride { get; set; }

        [DataMember(Order=15)]
        public virtual DateTime? ModelAsOfDateOverride { get; set; }

        [DataMember(Order=16)]
        public virtual string SourceModelSystemOverride { get; set; }

        [DataMember(Order=17)]
        public virtual string SourceModelIdOverride { get; set; }

        [DataMember(Order=18)]
        public virtual string SourceEventSetIdOverride { get; set; }

        [DataMember(Order=19)]
        public virtual string EventSourceSystemOverride { get; set; }

        [DataMember(Order=20)]
        public virtual Guid RowIdentifier { get; set; }
    }

    [DataContract]
    public partial class AnalysisEventIdFilter
        : IObjectWithId, IHasAnalysisId
    {
        [DataMember(Order=1)]
        public virtual long Id { get; set; }

        [DataMember(Order=2)]
        public virtual long AnalysisId { get; set; }

        [DataMember(Order=3)]
        public virtual int EventSourceId { get; set; }

        [DataMember(Order=4)]
        public virtual long EventId { get; set; }

        [DataMember(Order=5)]
        public virtual Guid RowIdentifier { get; set; }
    }

    [DataContract]
    public partial class AnalysisPortfolioAllocation
        : IObjectWithId
    {
        [DataMember(Order=1)]
        public virtual long Id { get; set; }

        [DataMember(Order=2)]
        public virtual long AnalysisDealId { get; set; }

        [DataMember(Order=3)]
        [Validate("NotEmpty", Message="PortfolioName is mandatory")]
        public virtual string PortfolioName { get; set; }

        [DataMember(Order=4)]
        public virtual double AllocationPercentage { get; set; }

        [DataMember(Order=5)]
        public virtual Guid RowIdentifier { get; set; }
    }

    public partial class AnalysisPortfolioEventSetConfiguration
        : IObjectWithId, IHasAnalysisId
    {
        [DataMember(Order=1)]
        public virtual long Id { get; set; }

        [DataMember(Order=2)]
        public virtual long AnalysisId { get; set; }

        [DataMember(Order=3)]
        public virtual long AnalysisConfigurationId { get; set; }

        [DataMember(Order=4)]
        public virtual string PortfolioName { get; set; }

        [DataMember(Order=5)]
        public virtual string ModelId { get; set; }

        [DataMember(Order=6)]
        public virtual Guid RowIdentifier { get; set; }
    }

    public partial class AnalysisPortfolioEventSetResult
        : IObjectWithId, IHasAnalysisId
    {
        [DataMember(Order=1)]
        public virtual long Id { get; set; }

        [DataMember(Order=2)]
        public virtual long AnalysisId { get; set; }

        [DataMember(Order=3)]
        public virtual long AnalysisPortfolioEventSetConfigurationId { get; set; }

        [DataMember(Order=4)]
        public virtual long AnalysisResultId { get; set; }

        [DataMember(Order=5)]
        public virtual string PortfolioName { get; set; }

        [DataMember(Order=6)]
        public virtual Guid RowIdentifier { get; set; }
    }

    public partial class AnalysisPortfolioMetric
        : IHasAnalysisResultId
    {
        public virtual AnalysisType AnalysisType { get; set; }
        public virtual SimulationLossPerspective SimulationLossPerspective { get; set; }
        public virtual ReinsurancePremiumLossType ReinsurancePremiumLossType { get; set; }
        public virtual string MetricDescription { get; set; }
        public virtual string PortfolioName { get; set; }
        public virtual double Metric { get; set; }
        public virtual int MetaRiskId { get; set; }
        public virtual int? Simulation { get; set; }
        public virtual long AnalysisResultId { get; set; }
    }

    [DataContract]
    public partial class AnalysisResult
        : IObjectWithId
    {
        [DataMember(Order=1)]
        public virtual long Id { get; set; }

        [DataMember(Order=2)]
        public virtual long AnalysisId { get; set; }

        [DataMember(Order=3)]
        public virtual long AnalysisConfigurationId { get; set; }

        [DataMember(Order=4)]
        public virtual string Container { get; set; }

        [DataMember(Order=5)]
        public virtual string BlobName { get; set; }

        [DataMember(Order=6)]
        public virtual string ResultTableName { get; set; }

        [DataMember(Order=7)]
        public virtual AnalysisType AnalysisType { get; set; }

        [DataMember(Order=8)]
        public virtual SimulationLossPerspective SimulationLossPerspective { get; set; }

        [DataMember(Order=9)]
        public virtual ReinsurancePremiumLossType ReinsurancePremiumLossType { get; set; }

        [DataMember(Order=10)]
        public virtual ResultOutputLevel OutputLevel { get; set; }

        [DataMember(Order=11)]
        public virtual int MetaRiskId { get; set; }

        [DataMember(Order=12)]
        public virtual List<AnalysisPortfolioEventSetResult> AnalysisPortfolioEventSetResults { get; set; }

        [DataMember(Order=13)]
        public virtual Guid RowIdentifier { get; set; }
    }

    [DataContract]
    public partial class MessageTracking
    {
        [DataMember(Order=1)]
        public virtual Guid Id { get; set; }

        [DataMember(Order=2)]
        public virtual long? AnalysisId { get; set; }

        [DataMember(Order=3)]
        public virtual ProcessingStatus ProcessingStatus { get; set; }

        [DataMember(Order=4)]
        public virtual MessageType MessageType { get; set; }

        [DataMember(Order=5)]
        public virtual DateTime CreatedDateUtc { get; set; }

        [DataMember(Order=6)]
        public virtual DateTime UpdatedDateUtc { get; set; }
    }

}

C# GetAnalysisRequest DTOs

To override the Content-type in your clients, use the HTTP Accept Header, append the .jsv suffix or ?format=jsv

HTTP + JSV

The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.

GET /api/riskstore/analysis/results HTTP/1.1 
Host: riskstoreng-dev.nephila.com 
Accept: text/jsv

HTTP/1.1 200 OK
Content-Type: text/jsv
Content-Length: length

{
	analysis: 
	{
		id: 0,
		name: String,
		modelAsOfDate: 0001-01-01,
		perspectiveId: 0,
		configurations: 
		[
			{
				id: 0,
				analysisId: 0,
				windowStartDate: 0001-01-01,
				windowEndDate: 0001-01-01,
				standardEnabled: False,
				runOffEnabled: False,
				aggregateEnabled: False,
				occurrenceEnabled: False,
				nettEnabled: False,
				grossEnabled: False,
				tailIntensityPercentageStart: 0,
				tailIntensityPercentageEnd: 0,
				metaRiskId: 0,
				outputLevel: NotSet,
				processingStatus: New,
				eventLossFloorStartRange: 0,
				eventLossFloorEndRange: 0,
				analysisPortfolioEventSetConfigurations: 
				[
					{
						id: 0,
						analysisId: 0,
						analysisConfigurationId: 0,
						portfolioName: String,
						modelId: String,
						rowIdentifier: 00000000000000000000000000000000
					}
				],
				rowIdentifier: 00000000000000000000000000000000
			}
		],
		deals: 
		[
			{
				id: 0,
				analysisId: 0,
				sourceDealId: String,
				dealRef: String,
				sourceDealSystem: String,
				eventSetId: 0,
				rol: 0,
				limit: 0,
				inceptionDate: 0001-01-01,
				expiryDate: 0001-01-01,
				transactionType: NotSet,
				allocations: 
				[
					{
						id: 0,
						analysisDealId: 0,
						portfolioName: String,
						allocationPercentage: 0,
						rowIdentifier: 00000000000000000000000000000000
					}
				],
				perspectiveIdOverride: 0,
				eventSetIdOverride: 0,
				modelAsOfDateOverride: 0001-01-01,
				sourceModelSystemOverride: String,
				sourceModelIdOverride: String,
				sourceEventSetIdOverride: String,
				eventSourceSystemOverride: String,
				rowIdentifier: 00000000000000000000000000000000
			}
		],
		eventIdFilters: 
		[
			{
				id: 0,
				analysisId: 0,
				eventSourceId: 0,
				eventId: 0,
				rowIdentifier: 00000000000000000000000000000000
			}
		],
		createdBy: String,
		createdDateUtc: 0001-01-01,
		completedDateUtc: 0001-01-01,
		legacyAnalysisId: 0,
		resultPersistenceTracking: 
		[
			{
				id: 00000000000000000000000000000000,
				analysisId: 0,
				processingStatus: New,
				messageType: NotSet,
				createdDateUtc: 0001-01-01,
				updatedDateUtc: 0001-01-01
			}
		],
		processingStatus: New,
		saveResults: False,
		eventSourceSystem: String,
		updatedDateUtc: 0001-01-01,
		isExpired: False,
		rowIdentifier: 00000000000000000000000000000000,
		errorMessage: String,
		ignoreSimulationCountMismatch: False,
		finalStatus: New
	},
	portfolioMetrics: 
	[
		{
			analysisType: NotSet,
			simulationLossPerspective: NotSet,
			reinsurancePremiumLossType: NotSet,
			metricDescription: String,
			portfolioName: String,
			metric: 0,
			metaRiskId: 0,
			simulation: 0,
			analysisResultId: 0
		}
	],
	results: 
	[
		{
			id: 0,
			analysisId: 0,
			analysisConfigurationId: 0,
			container: String,
			blobName: String,
			resultTableName: String,
			analysisType: NotSet,
			simulationLossPerspective: NotSet,
			reinsurancePremiumLossType: NotSet,
			outputLevel: NotSet,
			metaRiskId: 0,
			analysisPortfolioEventSetResults: 
			[
				{
					id: 0,
					analysisId: 0,
					analysisPortfolioEventSetConfigurationId: 0,
					analysisResultId: 0,
					portfolioName: String,
					rowIdentifier: 00000000000000000000000000000000
				}
			],
			rowIdentifier: 00000000000000000000000000000000
		}
	],
	responseStatus: 
	{
		errorCode: String,
		message: String,
		stackTrace: String,
		errors: 
		[
			{
				errorCode: String,
				fieldName: String,
				message: String,
				meta: 
				{
					String: String
				}
			}
		],
		meta: 
		{
			String: String
		}
	},
	unresolvedDealIds: 
	[
		String
	],
	unlinkedDealIds: 
	[
		"(, )"
	],
	message: String
}