private static List <InstrumentDeltaReport> GetTokensDelta(IReadOnlyCollection <IndexSettings> indicesSettings,
IReadOnlyCollection <IndexPrice> indexPrices, IReadOnlyCollection <Token> tokens)
{
var tokensDelta = new List <InstrumentDeltaReport>();
foreach (IndexSettings indexSettings in indicesSettings)
{
IndexPrice indexPrice = indexPrices.SingleOrDefault(o => o.Name == indexSettings.Name);
Token token = tokens.SingleOrDefault(o => o.AssetId == indexSettings.AssetId)
?? new Token {
AssetId = indexSettings.AssetId
};
IReadOnlyCollection <AssetWeight> weights = indexPrice?.Weights ?? new AssetWeight[0];
decimal volume = -token.OpenVolume;
decimal?volumeInUsd = indexPrice?.Price * volume;
tokensDelta.Add(new InstrumentDeltaReport
{
Name = indexSettings.Name,
AssetId = indexSettings.AssetId,
Price = indexPrice?.Price,
Volume = volume,
VolumeInUsd = volumeInUsd,
IsVirtual = false,
AssetsDelta = volumeInUsd != null
? ComputeAssetsDelta(volumeInUsd.Value, DeltaRate, weights)
: new AssetDelta[0]
});
}
return(tokensDelta);
}
private static List <TokenReport> GetIndexReports(IReadOnlyCollection <IndexSettings> indicesSettings,
IReadOnlyCollection <IndexPrice> indexPrices, IReadOnlyCollection <Token> tokens)
{
var tokenReports = new List <TokenReport>();
foreach (IndexSettings indexSettings in indicesSettings)
{
IndexPrice indexPrice = indexPrices.SingleOrDefault(o => o.Name == indexSettings.Name);
Token token = tokens.SingleOrDefault(o => o.AssetId == indexSettings.AssetId)
?? new Token {
AssetId = indexSettings.AssetId
};
tokenReports.Add(new TokenReport
{
Name = indexSettings.Name,
AssetId = indexSettings.AssetId,
Price = indexPrice?.Price,
OpenVolume = token.OpenVolume,
Weights = indexPrice?.Weights ?? new AssetWeight[0]
});
}
return(tokenReports);
}
private async Task <bool> ValidateIndexPricesAsync()
{
bool valid = true;
IReadOnlyCollection <IndexSettings> indicesSettings = await _indexSettingsService.GetAllAsync();
foreach (IndexSettings indexSettings in indicesSettings)
{
IndexPrice indexPrice = await _indexPriceService.GetByIndexAsync(indexSettings.Name);
if (indexPrice == null)
{
_log.WarningWithDetails("Index price not found", indexSettings.Name);
valid = false;
}
else if (!indexPrice.ValidateValue())
{
_log.WarningWithDetails("Invalid index price", indexPrice);
valid = false;
}
else if (!indexPrice.ValidateWeights())
{
_log.WarningWithDetails("Invalid index price weights", indexPrice);
valid = false;
}
}
return(valid);
}
public async Task RecalculateAsync(string settlementId, string userId)
{
Settlement settlement = await GetByIdAsync(settlementId);
if (settlement.Status != SettlementStatus.New)
{
throw new InvalidOperationException("Only new settlement can be recalculated");
}
IndexPrice indexPrice = await _indexPriceService.GetByIndexAsync(settlement.IndexName);
if (indexPrice == null)
{
throw new InvalidOperationException("Index price not found");
}
settlement.Price = indexPrice.Price;
await CalculateAssetSettlementsAsync(settlement, indexPrice.Weights);
await ValidateBalanceAsync(settlement);
await _settlementRepository.ReplaceAsync(settlement);
_log.InfoWithDetails("Settlement recalculated", new { settlement, userId });
}
private static void Complete(IReadOnlyCollection <AssetInvestment> assetInvestments,
IReadOnlyDictionary <string, Quote> assetPrice, IReadOnlyCollection <IndexSettings> indexSettings,
IReadOnlyCollection <IndexPrice> indexPrices, IReadOnlyCollection <Token> tokens)
{
foreach (AssetInvestment assetInvestment in assetInvestments)
{
assetInvestment.Quote = assetPrice[assetInvestment.AssetId];
foreach (AssetIndexInvestment assetIndexInvestment in assetInvestment.Indices)
{
IndexPrice indexPrice = indexPrices.Single(o => o.Name == assetIndexInvestment.Name);
IndexSettings settings = indexSettings.Single(p => p.Name == assetIndexInvestment.Name);
Token token = tokens.SingleOrDefault(t => t.AssetId == settings.AssetId);
assetIndexInvestment.Value = indexPrice.Value;
assetIndexInvestment.Price = indexPrice.Price;
assetIndexInvestment.OpenVolume = token?.OpenVolume ?? 0;
assetIndexInvestment.OppositeVolume = token?.OppositeVolume ?? 0;
assetIndexInvestment.Weight = indexPrice.Weights
.SingleOrDefault(o => o.AssetId == assetInvestment.AssetId)
?.Weight ?? 0;
}
}
}
public async Task InsertAsync(IndexPrice indexPrice)
{
var entity = new IndexPriceEntity(GetPartitionKey(), GetRowKey(indexPrice.Name));
Mapper.Map(indexPrice, entity);
await _storage.InsertAsync(entity);
}
public async Task UpdateAsync(IndexPrice indexPrice)
{
await _storage.MergeAsync(GetPartitionKey(), GetRowKey(indexPrice.Name), entity =>
{
Mapper.Map(indexPrice, entity);
return(entity);
});
}
public async Task UpdateAsync(Index index)
{
if (!index.ValidateValue())
{
throw new InvalidOperationException("Invalid index value");
}
if (!index.ValidateWeights())
{
throw new InvalidOperationException("Invalid index weights");
}
IndexSettings indexSettings = await _indexSettingsService.GetByIndexAsync(index.Name);
if (indexSettings == null)
{
throw new InvalidOperationException("Index settings not found");
}
IndexPrice indexPrice = await GetByIndexAsync(index.Name);
if (indexPrice == null)
{
indexPrice = IndexPrice.Init(index.Name, index.Value, index.Timestamp, index.Weights);
await _indexPriceRepository.InsertAsync(indexPrice);
_log.InfoWithDetails("The index price initialized", indexPrice);
}
else
{
IndexSettlementPrice indexSettlementPrice = IndexSettlementPriceCalculator.Calculate(
index.Value, indexPrice.Value, indexSettings.Alpha, indexPrice.K, indexPrice.Price,
index.Timestamp, indexPrice.Timestamp, indexSettings.TrackingFee, indexSettings.PerformanceFee,
indexSettings.IsShort);
indexPrice.Update(index.Value, index.Timestamp, indexSettlementPrice.Price, indexSettlementPrice.K,
indexSettlementPrice.R, indexSettlementPrice.Delta, index.Weights);
await _indexPriceRepository.UpdateAsync(indexPrice);
_log.InfoWithDetails("The index price calculated", new
{
indexPrice,
indexSettings
});
}
_cache.Set(indexPrice);
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
hashCode = hashCode * 59 + Direction.GetHashCode();
hashCode = hashCode * 59 + TickDirection.GetHashCode();
if (Timestamp != null)
{
hashCode = hashCode * 59 + Timestamp.GetHashCode();
}
if (Price != null)
{
hashCode = hashCode * 59 + Price.GetHashCode();
}
if (TradeSeq != null)
{
hashCode = hashCode * 59 + TradeSeq.GetHashCode();
}
if (TradeId != null)
{
hashCode = hashCode * 59 + TradeId.GetHashCode();
}
if (Iv != null)
{
hashCode = hashCode * 59 + Iv.GetHashCode();
}
if (IndexPrice != null)
{
hashCode = hashCode * 59 + IndexPrice.GetHashCode();
}
if (Amount != null)
{
hashCode = hashCode * 59 + Amount.GetHashCode();
}
if (InstrumentName != null)
{
hashCode = hashCode * 59 + InstrumentName.GetHashCode();
}
return(hashCode);
}
}
public async Task CreateAsync(string indexName, decimal amount, string comment, string walletId,
string clientId, string userId, bool isDirect)
{
IndexPrice indexPrice = await _indexPriceService.GetByIndexAsync(indexName);
if (indexPrice == null)
{
throw new InvalidOperationException("Index price not found");
}
Settlement settlement = await CreateSettlementAsync(indexName, amount, comment, walletId, clientId, userId,
isDirect, indexPrice);
await ValidateBalanceAsync(settlement);
await _settlementRepository.InsertAsync(settlement);
_log.InfoWithDetails("Settlement created", settlement);
}
private async Task <IReadOnlyCollection <string> > GetAssetsAsync()
{
IReadOnlyCollection <IndexSettings> indicesSettings = await _indexSettingsService.GetAllAsync();
IReadOnlyCollection <Position> positions = await _positionService.GetAllAsync();
List <string> assets = positions.Select(o => o.AssetId).ToList();
foreach (IndexSettings indexSettings in indicesSettings)
{
IndexPrice indexPrice = await _indexPriceService.GetByIndexAsync(indexSettings.Name);
if (indexPrice != null)
{
assets.AddRange(indexPrice.Weights.Select(o => o.AssetId));
}
}
return(assets.Distinct().ToList());
}
public async Task <IReadOnlyCollection <IndexReport> > GetAsync()
{
IReadOnlyCollection <IndexSettings> indicesSettings = await _indexSettingsService.GetAllAsync();
var indexReports = new List <IndexReport>();
foreach (IndexSettings indexSettings in indicesSettings)
{
IndexPrice indexPrice = await _indexPriceService.GetByIndexAsync(indexSettings.Name);
Token token = await _tokenService.GetAsync(indexSettings.AssetId);
Balance balance = _balanceService.GetByAssetId(ExchangeNames.Lykke, indexSettings.AssetId);
indexReports.Add(new IndexReport
{
Name = indexSettings.Name,
AssetId = indexSettings.AssetId,
AssetPairId = indexSettings.AssetPairId,
Value = indexPrice?.Value,
Price = indexPrice?.Price,
Timestamp = indexPrice?.Timestamp,
K = indexPrice?.K,
Amount = token.Amount,
OpenVolume = token.OpenVolume,
OppositeVolume = token.OppositeVolume,
Balance = balance.Amount,
Alpha = indexSettings.Alpha,
TrackingFee = indexSettings.TrackingFee,
PerformanceFee = indexSettings.PerformanceFee,
SellMarkup = indexSettings.SellMarkup,
SellVolume = indexSettings.SellVolume,
BuyVolume = indexSettings.BuyVolume,
Weights = indexPrice?.Weights ?? new AssetWeight[0]
});
}
return(indexReports);
}
public async Task <ProfitLossReport> GetAsync()
{
IReadOnlyCollection <Position> positions = await _positionService.GetAllAsync();
decimal positionsVolumeInUsd = 0;
decimal positionsOppositeVolume = 0;
foreach (Position position in positions.Where(position => position.Exchange != ExchangeNames.Virtual))
{
positionsOppositeVolume += position.OppositeVolume;
if (_rateService.TryConvertToUsd(position.AssetId, position.Exchange, position.Volume,
out decimal amountInUsd))
{
positionsVolumeInUsd += amountInUsd;
}
}
decimal investments = 0;
decimal openTokensAmountInUsd = 0;
IReadOnlyCollection <IndexSettings> indicesSettings = await _indexSettingsService.GetAllAsync();
foreach (IndexSettings indexSettings in indicesSettings)
{
IndexPrice indexPrice = await _indexPriceService.GetByIndexAsync(indexSettings.Name);
Token token = await _tokenService.GetAsync(indexSettings.AssetId);
investments += token?.OppositeVolume ?? 0;
openTokensAmountInUsd += token?.OpenVolume * indexPrice?.Price ?? 0;
}
decimal balance = positionsVolumeInUsd + (investments - Math.Abs(positionsOppositeVolume));
decimal pnl = openTokensAmountInUsd - balance;
return(new ProfitLossReport(balance, pnl));
}
private async Task <Settlement> CreateSettlementAsync(string indexName, decimal amount, string comment,
string walletId, string clientId, string userId, bool isDirect, IndexPrice indexPrice)
{
var settlement = new Settlement
{
Id = Guid.NewGuid().ToString("D"),
IndexName = indexName,
Amount = amount,
Price = indexPrice.Price,
WalletId = walletId,
ClientId = clientId,
Comment = comment,
IsDirect = isDirect,
Status = SettlementStatus.New,
CreatedBy = userId,
CreatedDate = DateTime.UtcNow
};
await CalculateAssetSettlementsAsync(settlement, indexPrice.Weights);
return(settlement);
}
public static IReadOnlyCollection <AssetInvestment> Calculate(
IEnumerable <string> assets,
IReadOnlyCollection <IndexSettings> indicesSettings,
IReadOnlyCollection <Token> tokens,
IReadOnlyCollection <IndexPrice> indexPrices,
IReadOnlyCollection <Position> positions,
IReadOnlyDictionary <string, Quote> assetPrices)
{
var assetsInvestments = new List <AssetInvestment>();
foreach (string assetId in assets)
{
var indexInvestments = new List <AssetIndexInvestment>();
bool isDisabled = false;
foreach (IndexSettings indexSettings in indicesSettings)
{
Token token = tokens.SingleOrDefault(o => o.AssetId == indexSettings.AssetId);
IndexPrice indexPrice = indexPrices.Single(o => o.Name == indexSettings.Name);
AssetWeight assetWeight = indexPrice.Weights.SingleOrDefault(o => o.AssetId == assetId);
decimal weight = assetWeight?.Weight ?? 0;
decimal openVolume = token?.OpenVolume ?? 0;
decimal amount = openVolume * indexPrice.Price * weight;
isDisabled = isDisabled || (assetWeight?.IsDisabled ?? false);
indexInvestments.Add(new AssetIndexInvestment
{
Name = indexSettings.Name,
Value = indexPrice.Value,
Price = indexPrice.Price,
OpenVolume = token?.OpenVolume ?? 0,
OppositeVolume = token?.OppositeVolume ?? 0,
Amount = amount,
Weight = weight
});
}
Position position = positions.SingleOrDefault(o => o.AssetId == assetId);
decimal assetVolume = position?.Volume ?? 0;
assetPrices.TryGetValue(assetId, out Quote quote);
decimal assetPrice = quote?.Mid ?? 0;
decimal totalAmount = indexInvestments.Sum(o => o.Amount);
decimal remainingAmount = assetVolume * assetPrice - totalAmount;
assetsInvestments.Add(new AssetInvestment
{
AssetId = assetId,
Volume = assetVolume,
Quote = quote,
TotalAmount = totalAmount,
RemainingAmount = remainingAmount,
IsDisabled = isDisabled,
Indices = indexInvestments
});
}
return(assetsInvestments);
}
/// <summary>
/// Returns true if PublicTrade instances are equal
/// </summary>
/// <param name="other">Instance of PublicTrade to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(PublicTrade other)
{
if (other is null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
Direction == other.Direction ||
Direction.Equals(other.Direction)
) &&
(
TickDirection == other.TickDirection ||
TickDirection.Equals(other.TickDirection)
) &&
(
Timestamp == other.Timestamp ||
Timestamp != null &&
Timestamp.Equals(other.Timestamp)
) &&
(
Price == other.Price ||
Price != null &&
Price.Equals(other.Price)
) &&
(
TradeSeq == other.TradeSeq ||
TradeSeq != null &&
TradeSeq.Equals(other.TradeSeq)
) &&
(
TradeId == other.TradeId ||
TradeId != null &&
TradeId.Equals(other.TradeId)
) &&
(
Iv == other.Iv ||
Iv != null &&
Iv.Equals(other.Iv)
) &&
(
IndexPrice == other.IndexPrice ||
IndexPrice != null &&
IndexPrice.Equals(other.IndexPrice)
) &&
(
Amount == other.Amount ||
Amount != null &&
Amount.Equals(other.Amount)
) &&
(
InstrumentName == other.InstrumentName ||
InstrumentName != null &&
InstrumentName.Equals(other.InstrumentName)
));
}
public async Task UpdateLimitOrdersAsync(string indexName)
{
IndexPrice indexPrice = await _indexPriceService.GetByIndexAsync(indexName);
if (indexPrice == null)
{
throw new InvalidOperationException("Index price not found");
}
IndexSettings indexSettings = await _indexSettingsService.GetByIndexAsync(indexName);
if (indexSettings == null)
{
throw new InvalidOperationException("Index settings not found");
}
AssetPairSettings assetPairSettings =
await _instrumentService.GetAssetPairAsync(indexSettings.AssetPairId, Exchange);
if (assetPairSettings == null)
{
throw new InvalidOperationException("Asset pair settings not found");
}
AssetSettings baseAssetSettings =
await _instrumentService.GetAssetAsync(assetPairSettings.BaseAsset, ExchangeNames.Lykke);
if (baseAssetSettings == null)
{
throw new InvalidOperationException("Base asset settings not found");
}
AssetSettings quoteAssetSettings =
await _instrumentService.GetAssetAsync(assetPairSettings.QuoteAsset, ExchangeNames.Lykke);
if (quoteAssetSettings == null)
{
throw new InvalidOperationException("Quote asset settings not found");
}
decimal sellPrice = (indexPrice.Price + indexSettings.SellMarkup)
.TruncateDecimalPlaces(assetPairSettings.PriceAccuracy, true);
decimal buyPrice = indexPrice.Price.TruncateDecimalPlaces(assetPairSettings.PriceAccuracy);
IReadOnlyCollection <LimitOrder> limitOrders =
CreateLimitOrders(indexSettings, assetPairSettings, sellPrice, buyPrice);
ValidateBalance(limitOrders, baseAssetSettings, quoteAssetSettings);
ValidateMinVolume(limitOrders, assetPairSettings.MinVolume);
LimitOrder[] allowedLimitOrders = limitOrders
.Where(o => o.Error == LimitOrderError.None)
.ToArray();
_log.InfoWithDetails("Limit orders created", limitOrders);
_limitOrderService.Update(indexSettings.AssetPairId, limitOrders);
await _lykkeExchangeService.ApplyAsync(indexSettings.AssetPairId, allowedLimitOrders);
_traceWriter.LimitOrders(indexSettings.AssetPairId, limitOrders);
}
/// <summary>
/// Returns true if Settlement instances are equal
/// </summary>
/// <param name="other">Instance of Settlement to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(Settlement other)
{
if (other is null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
SessionProfitLoss == other.SessionProfitLoss ||
SessionProfitLoss != null &&
SessionProfitLoss.Equals(other.SessionProfitLoss)
) &&
(
MarkPrice == other.MarkPrice ||
MarkPrice != null &&
MarkPrice.Equals(other.MarkPrice)
) &&
(
Funding == other.Funding ||
Funding != null &&
Funding.Equals(other.Funding)
) &&
(
Socialized == other.Socialized ||
Socialized != null &&
Socialized.Equals(other.Socialized)
) &&
(
SessionBankrupcy == other.SessionBankrupcy ||
SessionBankrupcy != null &&
SessionBankrupcy.Equals(other.SessionBankrupcy)
) &&
(
Timestamp == other.Timestamp ||
Timestamp != null &&
Timestamp.Equals(other.Timestamp)
) &&
(
ProfitLoss == other.ProfitLoss ||
ProfitLoss != null &&
ProfitLoss.Equals(other.ProfitLoss)
) &&
(
Funded == other.Funded ||
Funded != null &&
Funded.Equals(other.Funded)
) &&
(
IndexPrice == other.IndexPrice ||
IndexPrice != null &&
IndexPrice.Equals(other.IndexPrice)
) &&
(
SessionTax == other.SessionTax ||
SessionTax != null &&
SessionTax.Equals(other.SessionTax)
) &&
(
SessionTaxRate == other.SessionTaxRate ||
SessionTaxRate != null &&
SessionTaxRate.Equals(other.SessionTaxRate)
) &&
(
InstrumentName == other.InstrumentName ||
InstrumentName != null &&
InstrumentName.Equals(other.InstrumentName)
) &&
(
Position == other.Position ||
Position != null &&
Position.Equals(other.Position)
) &&
(
Type == other.Type ||
Type.Equals(other.Type)
));
}
public async Task <SimulationReport> GetReportAsync(string indexName)
{
SimulationParameters simulationParameters =
await _simulationParametersRepository.GetByIndexNameAsync(indexName);
if (simulationParameters == null)
{
simulationParameters = SimulationParameters.Create(indexName);
}
IndexSettings indexSettings = await _indexSettingsService.GetByIndexAsync(indexName);
if (indexSettings == null)
{
return(null);
}
IndexPrice indexPrice = await _indexPriceService.GetByIndexAsync(indexSettings.Name);
var simulationReport = new SimulationReport
{
IndexName = indexName,
AssetId = indexSettings.AssetId,
AssetPairId = indexSettings.AssetPairId,
Value = indexPrice?.Value,
Price = indexPrice?.Price,
Timestamp = indexPrice?.Timestamp,
K = indexPrice?.K,
OpenTokens = simulationParameters.OpenTokens,
AmountInUsd = simulationParameters.OpenTokens * indexPrice?.Price ?? 0,
Investments = simulationParameters.Investments,
Alpha = indexSettings.Alpha,
TrackingFee = indexSettings.TrackingFee,
PerformanceFee = indexSettings.PerformanceFee,
SellMarkup = indexSettings.SellMarkup,
SellVolume = indexSettings.SellVolume,
BuyVolume = indexSettings.BuyVolume,
PnL = simulationParameters.OpenTokens * indexPrice?.Price - simulationParameters.Investments ?? 0
};
var assets = new List <AssetDistribution>();
if (indexPrice != null)
{
foreach (AssetWeight assetWeight in indexPrice.Weights)
{
decimal amountInUsd = simulationReport.AmountInUsd * assetWeight.Weight;
decimal amount = amountInUsd / assetWeight.Price;
assets.Add(new AssetDistribution
{
Asset = assetWeight.AssetId,
Weight = assetWeight.Weight,
IsHedged = simulationParameters.Assets.Contains(assetWeight.AssetId),
Amount = amount,
AmountInUsd = amountInUsd,
Price = assetWeight.Price
});
}
}
simulationReport.Assets = assets;
return(simulationReport);
}
/// <summary>
/// Returns true if UserTrade instances are equal
/// </summary>
/// <param name="other">Instance of UserTrade to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(UserTrade other)
{
if (other is null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
Direction == other.Direction ||
Direction.Equals(other.Direction)
) &&
(
FeeCurrency == other.FeeCurrency ||
FeeCurrency.Equals(other.FeeCurrency)
) &&
(
OrderId == other.OrderId ||
OrderId != null &&
OrderId.Equals(other.OrderId)
) &&
(
Timestamp == other.Timestamp ||
Timestamp != null &&
Timestamp.Equals(other.Timestamp)
) &&
(
Price == other.Price ||
Price != null &&
Price.Equals(other.Price)
) &&
(
Iv == other.Iv ||
Iv != null &&
Iv.Equals(other.Iv)
) &&
(
TradeId == other.TradeId ||
TradeId != null &&
TradeId.Equals(other.TradeId)
) &&
(
Fee == other.Fee ||
Fee != null &&
Fee.Equals(other.Fee)
) &&
(
OrderType == other.OrderType ||
OrderType.Equals(other.OrderType)
) &&
(
TradeSeq == other.TradeSeq ||
TradeSeq != null &&
TradeSeq.Equals(other.TradeSeq)
) &&
(
SelfTrade == other.SelfTrade ||
SelfTrade != null &&
SelfTrade.Equals(other.SelfTrade)
) &&
(
State == other.State ||
State.Equals(other.State)
) &&
(
Label == other.Label ||
Label != null &&
Label.Equals(other.Label)
) &&
(
IndexPrice == other.IndexPrice ||
IndexPrice != null &&
IndexPrice.Equals(other.IndexPrice)
) &&
(
Amount == other.Amount ||
Amount != null &&
Amount.Equals(other.Amount)
) &&
(
InstrumentName == other.InstrumentName ||
InstrumentName != null &&
InstrumentName.Equals(other.InstrumentName)
) &&
(
TickDirection == other.TickDirection ||
TickDirection.Equals(other.TickDirection)
) &&
(
MatchingId == other.MatchingId ||
MatchingId != null &&
MatchingId.Equals(other.MatchingId)
) &&
(
Liquidity == other.Liquidity ||
Liquidity.Equals(other.Liquidity)
));
}
private static string GetKey(IndexPrice indexPrice) => GetKey(indexPrice.Name);
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
hashCode = hashCode * 59 + Direction.GetHashCode();
if (AveragePriceUsd != null)
{
hashCode = hashCode * 59 + AveragePriceUsd.GetHashCode();
}
if (EstimatedLiquidationPrice != null)
{
hashCode = hashCode * 59 + EstimatedLiquidationPrice.GetHashCode();
}
if (FloatingProfitLoss != null)
{
hashCode = hashCode * 59 + FloatingProfitLoss.GetHashCode();
}
if (FloatingProfitLossUsd != null)
{
hashCode = hashCode * 59 + FloatingProfitLossUsd.GetHashCode();
}
if (OpenOrdersMargin != null)
{
hashCode = hashCode * 59 + OpenOrdersMargin.GetHashCode();
}
if (TotalProfitLoss != null)
{
hashCode = hashCode * 59 + TotalProfitLoss.GetHashCode();
}
if (RealizedProfitLoss != null)
{
hashCode = hashCode * 59 + RealizedProfitLoss.GetHashCode();
}
if (Delta != null)
{
hashCode = hashCode * 59 + Delta.GetHashCode();
}
if (InitialMargin != null)
{
hashCode = hashCode * 59 + InitialMargin.GetHashCode();
}
if (Size != null)
{
hashCode = hashCode * 59 + Size.GetHashCode();
}
if (MaintenanceMargin != null)
{
hashCode = hashCode * 59 + MaintenanceMargin.GetHashCode();
}
hashCode = hashCode * 59 + Kind.GetHashCode();
if (MarkPrice != null)
{
hashCode = hashCode * 59 + MarkPrice.GetHashCode();
}
if (AveragePrice != null)
{
hashCode = hashCode * 59 + AveragePrice.GetHashCode();
}
if (SettlementPrice != null)
{
hashCode = hashCode * 59 + SettlementPrice.GetHashCode();
}
if (IndexPrice != null)
{
hashCode = hashCode * 59 + IndexPrice.GetHashCode();
}
if (InstrumentName != null)
{
hashCode = hashCode * 59 + InstrumentName.GetHashCode();
}
if (SizeCurrency != null)
{
hashCode = hashCode * 59 + SizeCurrency.GetHashCode();
}
return(hashCode);
}
}
/// <summary>
/// Returns true if Position instances are equal
/// </summary>
/// <param name="other">Instance of Position to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(Position other)
{
if (other is null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
Direction == other.Direction ||
Direction.Equals(other.Direction)
) &&
(
AveragePriceUsd == other.AveragePriceUsd ||
AveragePriceUsd != null &&
AveragePriceUsd.Equals(other.AveragePriceUsd)
) &&
(
EstimatedLiquidationPrice == other.EstimatedLiquidationPrice ||
EstimatedLiquidationPrice != null &&
EstimatedLiquidationPrice.Equals(other.EstimatedLiquidationPrice)
) &&
(
FloatingProfitLoss == other.FloatingProfitLoss ||
FloatingProfitLoss != null &&
FloatingProfitLoss.Equals(other.FloatingProfitLoss)
) &&
(
FloatingProfitLossUsd == other.FloatingProfitLossUsd ||
FloatingProfitLossUsd != null &&
FloatingProfitLossUsd.Equals(other.FloatingProfitLossUsd)
) &&
(
OpenOrdersMargin == other.OpenOrdersMargin ||
OpenOrdersMargin != null &&
OpenOrdersMargin.Equals(other.OpenOrdersMargin)
) &&
(
TotalProfitLoss == other.TotalProfitLoss ||
TotalProfitLoss != null &&
TotalProfitLoss.Equals(other.TotalProfitLoss)
) &&
(
RealizedProfitLoss == other.RealizedProfitLoss ||
RealizedProfitLoss != null &&
RealizedProfitLoss.Equals(other.RealizedProfitLoss)
) &&
(
Delta == other.Delta ||
Delta != null &&
Delta.Equals(other.Delta)
) &&
(
InitialMargin == other.InitialMargin ||
InitialMargin != null &&
InitialMargin.Equals(other.InitialMargin)
) &&
(
Size == other.Size ||
Size != null &&
Size.Equals(other.Size)
) &&
(
MaintenanceMargin == other.MaintenanceMargin ||
MaintenanceMargin != null &&
MaintenanceMargin.Equals(other.MaintenanceMargin)
) &&
(
Kind == other.Kind ||
Kind.Equals(other.Kind)
) &&
(
MarkPrice == other.MarkPrice ||
MarkPrice != null &&
MarkPrice.Equals(other.MarkPrice)
) &&
(
AveragePrice == other.AveragePrice ||
AveragePrice != null &&
AveragePrice.Equals(other.AveragePrice)
) &&
(
SettlementPrice == other.SettlementPrice ||
SettlementPrice != null &&
SettlementPrice.Equals(other.SettlementPrice)
) &&
(
IndexPrice == other.IndexPrice ||
IndexPrice != null &&
IndexPrice.Equals(other.IndexPrice)
) &&
(
InstrumentName == other.InstrumentName ||
InstrumentName != null &&
InstrumentName.Equals(other.InstrumentName)
) &&
(
SizeCurrency == other.SizeCurrency ||
SizeCurrency != null &&
SizeCurrency.Equals(other.SizeCurrency)
));
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
if (SessionProfitLoss != null)
{
hashCode = hashCode * 59 + SessionProfitLoss.GetHashCode();
}
if (MarkPrice != null)
{
hashCode = hashCode * 59 + MarkPrice.GetHashCode();
}
if (Funding != null)
{
hashCode = hashCode * 59 + Funding.GetHashCode();
}
if (Socialized != null)
{
hashCode = hashCode * 59 + Socialized.GetHashCode();
}
if (SessionBankrupcy != null)
{
hashCode = hashCode * 59 + SessionBankrupcy.GetHashCode();
}
if (Timestamp != null)
{
hashCode = hashCode * 59 + Timestamp.GetHashCode();
}
if (ProfitLoss != null)
{
hashCode = hashCode * 59 + ProfitLoss.GetHashCode();
}
if (Funded != null)
{
hashCode = hashCode * 59 + Funded.GetHashCode();
}
if (IndexPrice != null)
{
hashCode = hashCode * 59 + IndexPrice.GetHashCode();
}
if (SessionTax != null)
{
hashCode = hashCode * 59 + SessionTax.GetHashCode();
}
if (SessionTaxRate != null)
{
hashCode = hashCode * 59 + SessionTaxRate.GetHashCode();
}
if (InstrumentName != null)
{
hashCode = hashCode * 59 + InstrumentName.GetHashCode();
}
if (Position != null)
{
hashCode = hashCode * 59 + Position.GetHashCode();
}
hashCode = hashCode * 59 + Type.GetHashCode();
return(hashCode);
}
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
hashCode = hashCode * 59 + Direction.GetHashCode();
hashCode = hashCode * 59 + FeeCurrency.GetHashCode();
if (OrderId != null)
{
hashCode = hashCode * 59 + OrderId.GetHashCode();
}
if (Timestamp != null)
{
hashCode = hashCode * 59 + Timestamp.GetHashCode();
}
if (Price != null)
{
hashCode = hashCode * 59 + Price.GetHashCode();
}
if (Iv != null)
{
hashCode = hashCode * 59 + Iv.GetHashCode();
}
if (TradeId != null)
{
hashCode = hashCode * 59 + TradeId.GetHashCode();
}
if (Fee != null)
{
hashCode = hashCode * 59 + Fee.GetHashCode();
}
hashCode = hashCode * 59 + OrderType.GetHashCode();
if (TradeSeq != null)
{
hashCode = hashCode * 59 + TradeSeq.GetHashCode();
}
if (SelfTrade != null)
{
hashCode = hashCode * 59 + SelfTrade.GetHashCode();
}
hashCode = hashCode * 59 + State.GetHashCode();
if (Label != null)
{
hashCode = hashCode * 59 + Label.GetHashCode();
}
if (IndexPrice != null)
{
hashCode = hashCode * 59 + IndexPrice.GetHashCode();
}
if (Amount != null)
{
hashCode = hashCode * 59 + Amount.GetHashCode();
}
if (InstrumentName != null)
{
hashCode = hashCode * 59 + InstrumentName.GetHashCode();
}
hashCode = hashCode * 59 + TickDirection.GetHashCode();
if (MatchingId != null)
{
hashCode = hashCode * 59 + MatchingId.GetHashCode();
}
hashCode = hashCode * 59 + Liquidity.GetHashCode();
return(hashCode);
}
}
public async Task <IndexPriceModel> GetByIndexAsync(string indexName)
{
IndexPrice indexPrice = await _indexPriceService.GetByIndexAsync(indexName);
return(Mapper.Map <IndexPriceModel>(indexPrice));
}
