Six4Win.WebApi

<back to all web services

GetDrawDignostics

The following routes are available for this service:
All Verbs/qry/rounds/draw/diagnostics
#![allow(
    dead_code,
    non_camel_case_types,
    non_snake_case,
    clippy::upper_case_acronyms
)]

use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::HashMap;

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct Initialization {
    #[serde(rename = "dataLoadDuration")]
    pub data_load_duration: i64,
    #[serde(rename = "betsCollectionsCreationDuration")]
    pub bets_collections_creation_duration: i64,
    #[serde(rename = "combinationsOccuranceLookupInitializationDuration")]
    pub combinations_occurance_lookup_initialization_duration: i64,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct SequenceGeneration {
    #[serde(rename = "nrOfThreads")]
    pub nr_of_threads: i32,
    #[serde(rename = "nrOfResultsProbed")]
    pub nr_of_results_probed: i32,
    pub duration: i64,
    #[serde(rename = "avgSinglePassDuration")]
    pub avg_single_pass_duration: i64,
}

#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[repr(i32)]
pub enum SortingOrder {
    #[default]
    None = 0,
    Ascending = 1,
    Descending = 2,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct BestFitFinder {
    #[serde(rename = "targetAmount")]
    pub target_amount: f64,
    #[serde(rename = "awardedAmount")]
    pub awarded_amount: f64,
    pub deviation: f64,
    #[serde(rename = "deviationPct")]
    pub deviation_pct: f64,
    #[serde(rename = "sequenceResultType")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sequence_result_type: Option<String>,
    #[serde(rename = "isJackPot5Drawn")]
    pub is_jack_pot5_drawn: bool,
    #[serde(rename = "filteringPeriod")]
    pub filtering_period: i64,
    #[serde(rename = "winCountOrder")]
    pub win_count_order: SortingOrder,
    #[serde(rename = "minAmount")]
    pub min_amount: f64,
    #[serde(rename = "maxAmount")]
    pub max_amount: f64,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct Bet {
    #[serde(rename = "isFound")]
    pub is_found: bool,
    #[serde(rename = "betId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bet_id: Option<String>,
    #[serde(rename = "slipId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub slip_id: Option<String>,
    #[serde(rename = "combStake")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comb_stake: Option<Value>,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct QualifiedPool {
    pub id: i32,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    pub coefficient: f64,
    #[serde(rename = "availableAmount")]
    pub available_amount: f64,
    #[serde(rename = "awardedAmount")]
    pub awarded_amount: f64,
    #[serde(rename = "targetBet")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub target_bet: Option<Bet>,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct Purger {
    #[serde(rename = "prevalentStake")]
    pub prevalent_stake: f64,
    #[serde(rename = "poolPurger")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pool_purger: Option<String>,
    #[serde(rename = "qualifiedPools")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub qualified_pools: Option<Vec<QualifiedPool>>,
}

#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[repr(i32)]
pub enum ResponseStatus {
    #[default]
    Failure = 0,
    Success = 1,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct StimulationResponse {
    #[serde(rename = "stimulationId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stimulation_id: Option<String>,
    pub status: ResponseStatus,
    #[serde(rename = "failureReason")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub failure_reason: Option<String>,
    #[serde(rename = "slipId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub slip_id: Option<String>,
    #[serde(rename = "betId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bet_id: Option<String>,
    #[serde(rename = "amountAwarded")]
    pub amount_awarded: f64,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct CurrentRoundInfo {
    #[serde(rename = "roundId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub round_id: Option<String>,
    pub amount: f64,
    #[serde(rename = "inertCode")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub inert_code: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct BettingApp {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct Ref {
    pub id: String,
    pub val: String,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct RefEx {
    #[serde(flatten)]
    pub r#ref: Ref,
    pub data: RecordDictionary,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct Origin {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub application: Option<BettingApp>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ip: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub organization: Option<RefEx>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub region: Option<Ref>,
    #[serde(rename = "locationGroup")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location_group: Option<Ref>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<RefEx>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub device: Option<RefEx>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub clerk: Option<Ref>,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct WinnerByCode {
    #[serde(rename = "roundId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub round_id: Option<String>,
    #[serde(rename = "drawnAtUtc")]
    pub drawn_at_utc: String,
    #[serde(rename = "slipId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub slip_id: Option<String>,
    #[serde(rename = "betId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bet_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub code: Option<String>,
    pub amount: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub origin: Option<Origin>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bettor: Option<Ref>,
    #[serde(rename = "locationAddressOrBettorInfo")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location_address_or_bettor_info: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct LocalCodePotInfo {
    #[serde(rename = "isActive")]
    pub is_active: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub current: Option<CurrentRoundInfo>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub winners: Option<Vec<WinnerByCode>>,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct SuperWinInfo {
    #[serde(rename = "durationInMs")]
    pub duration_in_ms: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reasoning: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct HappyHourInfo {
    #[serde(rename = "isHappyHour")]
    pub is_happy_hour: bool,
    #[serde(rename = "oddsModifier")]
    pub odds_modifier: f64,
    #[serde(rename = "roundPoolBonusPct")]
    pub round_pool_bonus_pct: f64,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct AccumulatorConfiguration {
    #[serde(flatten)]
    pub accumulator_configuration: AccumulatorConfiguration,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(rename = "updatedAt")]
    pub updated_at: String,
}

#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[repr(i32)]
pub enum SyphonType {
    #[default]
    Location = 0,
    Bettor = 1,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct Syphon {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    pub r#type: SyphonType,
    #[serde(rename = "nrOfCombinations")]
    pub nr_of_combinations: i32,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct SyphonInfo {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bettors: Option<HashMap<String, Syphon>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub locations: Option<HashMap<String, Syphon>>,
    #[serde(rename = "hasSyphons")]
    pub has_syphons: bool,
    #[serde(rename = "totalSyphonsInRound")]
    pub total_syphons_in_round: i32,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct DrawDiagnostics {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(rename = "initializationInfo")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub initialization_info: Option<Initialization>,
    #[serde(rename = "sequenceGenerationInfo")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sequence_generation_info: Option<SequenceGeneration>,
    #[serde(rename = "bestFitFinderInfo")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub best_fit_finder_info: Option<BestFitFinder>,
    #[serde(rename = "purgerInfo")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub purger_info: Option<Purger>,
    pub duration: i64,
    #[serde(rename = "stimulationResponses")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stimulation_responses: Option<Vec<StimulationResponse>>,
    #[serde(rename = "localCodePot")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub local_code_pot: Option<LocalCodePotInfo>,
    #[serde(rename = "superWin")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub super_win: Option<SuperWinInfo>,
    #[serde(rename = "happyHour")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub happy_hour: Option<HappyHourInfo>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reasoning: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub configuration: Option<AccumulatorConfiguration>,
    #[serde(rename = "syphonInfo")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub syphon_info: Option<SyphonInfo>,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct GetDrawDignostics {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct RecordDictionary(pub HashMap<TKey, TVal>);

Rust GetDrawDignostics 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.

POST /qry/rounds/draw/diagnostics HTTP/1.1 
Host: s4w1.api.bettor.webhop.biz 
Accept: text/jsv
Content-Type: text/jsv
Content-Length: length

{
	id: String
}

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

{
	id: String,
	initializationInfo: 
	{
		dataLoadDuration: 0,
		betsCollectionsCreationDuration: 0,
		combinationsOccuranceLookupInitializationDuration: 0
	},
	sequenceGenerationInfo: 
	{
		nrOfThreads: 0,
		nrOfResultsProbed: 0,
		duration: 0,
		avgSinglePassDuration: 0
	},
	bestFitFinderInfo: 
	{
		targetAmount: 0,
		awardedAmount: 0,
		deviation: 0,
		deviationPct: 0,
		sequenceResultType: String,
		isJackPot5Drawn: False,
		filteringPeriod: 0,
		winCountOrder: 0,
		minAmount: 0,
		maxAmount: 0
	},
	purgerInfo: 
	{
		prevalentStake: 0,
		poolPurger: String,
		qualifiedPools: 
		[
			{
				id: 0,
				name: String,
				coefficient: 0,
				availableAmount: 0,
				awardedAmount: 0,
				targetBet: 
				{
					isFound: False,
					betId: String,
					slipId: String,
					combStake: {}
				}
			}
		]
	},
	duration: 0,
	stimulationResponses: 
	[
		{
			stimulationId: String,
			status: 0,
			failureReason: String,
			slipId: String,
			betId: String,
			amountAwarded: 0
		}
	],
	localCodePot: 
	{
		durationInMs: 0
	},
	superWin: 
	{
		durationInMs: 0,
		reasoning: String
	},
	happyHour: 
	{
		isHappyHour: False,
		oddsModifier: 0,
		roundPoolBonusPct: 0
	},
	reasoning: String,
	configuration: 
	{
		pools: 
		[
			{
				id: 0,
				name: String,
				rtp: 0,
				reserveRTP: 0,
				totalRTP: 0
			}
		],
		prevalentStake: 0,
		purgeThresholdModifier: 0,
		locationOptimizationLevel: 0,
		jackPot5ThresholdInterval: 
		{
			start: 0,
			end: 0
		},
		deviationCategorySpanInPct: 0,
		deviationCategoryThresholdAmount: 0,
		roundPoolCircuitBreakerThreshold: 0,
		lowWinCountAffinityInPct: 0,
		winCountOrderAffinity: 
		[
			{
				order: 0,
				probability: 0
			}
		],
		highRollerSettings: 
		{
			pools: 
			[
				{
					id: 0,
					name: String,
					isActive: False,
					contributionToRoundPoolPct: 0,
					caps: 
					{
						plusCoef: 0,
						minusCoef: 0,
						maxAmountInPrevalentStakes: 0
					}
				}
			],
			categoryThresholds: 
			[
				{
					category: 0,
					threshold: 0
				}
			]
		},
		overflowCoefficientPoolsToRound: False,
		antiSyphonProtectionOverride: False,
		fraudDetectionConfig: 
		{
			antiSyphon: 
			{
				combinationCountPerRoundThresholdPct: 0,
				excludedLocations: 
				[
					{
						id: String,
						val: String
					}
				],
				blacklists: 
				{
					locations: 
					[
						{
							id: String,
							val: String
						}
					],
					players: 
					[
						{
							id: String,
							val: String
						}
					]
				},
				includeRoundPctAsBettorSyphonCriteria: False,
				isActive: False
			}
		},
		debugConfig: 
		{
			logLocationStats: False,
			logBettorStats: False
		},
		jP5WinnerCooldownPolicy: 
		{
			isActive: False,
			cooldownIntervalInDays: 0
		}
	},
	syphonInfo: 
	{
		bettors: 
		{
			String: 
			{
				id: String,
				name: String,
				type: 0,
				nrOfCombinations: 0
			}
		},
		locations: 
		{
			String: 
			{
				id: String,
				name: String,
				type: 0,
				nrOfCombinations: 0
			}
		},
		hasSyphons: True,
		totalSyphonsInRound: 2
	}
}