public SimpleMomentumStrategy(MarketBase market, string security, string baseCurrency, int lookback) : base(market, security, baseCurrency)
{
base.Market = market;
this.lookback = lookback;
priceWindow = new LinkedList <decimal>();
}
protected TradeStrategyBase(MarketBase market, string strategyName = null)
{
Market = market;
ExecutedTrades = new List <Trade>();
IsRunning = false;
StrategyName = strategyName ?? GetType().Name;
}
public async Task <string> SaveMarketBase(int ClientId)
{
AuthController objAuth = new AuthController();
if (objAuth.CheckUserClients(ClientId) == 0)
{
return("");
}
HttpContent requestContent = Request.Content;
var jsonContent = requestContent.ReadAsStringAsync().Result;
Guid Id = Guid.NewGuid();
if (jsonContent.Trim() != string.Empty)
{
var marketBaseDetails = JsonConvert.DeserializeObject <MarketbaseDetails>(jsonContent);
List <DimensionBaseMap> Dimension = marketBaseDetails.Dimension; //to get dimension seperatly.
List <PxR> PxRCollection = marketBaseDetails.PxR; //to get dimension seperatly.
MarketBase marketBase = marketBaseDetails.MarketBase;
marketBase.GuiId = Id.ToString();
marketBase.LastSaved = DateTime.Now;
using (var db = new EverestPortalContext())
{
db.MarketBases.Add(marketBase);
db.SaveChanges();
//to update new marketbase Id
await SaveDimensionBaseMap(marketBase.Id, Dimension);
await SavePxRBaseMap(marketBase.Id, PxRCollection);
}
}
var objClient = _db.MarketBases.Where(u => u.GuiId == Id.ToString()).ToList <MarketBase>();
ClientMarketBases clientMarketBases = new ClientMarketBases();
clientMarketBases.ClientId = ClientId;
clientMarketBases.MarketBaseId = objClient.First().Id;
using (var db = new EverestPortalContext())
{
db.ClientMarketBases.Add(clientMarketBases);
db.SaveChanges();
}
//to create new version
SubmitMarketbaseDetailsInformation(clientMarketBases.MarketBaseId);
var json = JsonConvert.SerializeObject(objClient, Formatting.Indented,
new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
return(json);
}
/// <summary> Handles the command. </summary>
///
/// <remarks> Paul, 26/02/2015. </remarks>
///
/// <param name="l"> The BitsharesLedgerEntry to process. </param>
/// <param name="handler"> The handler. </param>
/// <param name="market"> The market. </param>
///
/// <returns> true if it succeeds, false if it fails. </returns>
public bool HandleCommand(BitsharesLedgerEntry l, MarketBase handler, MarketRow market, string trxid)
{
if (m_adminUsernames.Contains(l.from_account))
{
try
{
string[] parts = l.memo.Split(' ');
if (l.memo.StartsWith(kSetPricesMemoStart))
{
HandlePriceSetting(parts, l, handler, market);
return(true);
}
else if (l.memo.StartsWith(kWithdrawMemo))
{
// process withdrawal
if (parts[0] == kWithdrawMemo)
{
// make sure we didn't already process this transaction!
if (!m_dataAccess.IsWithdrawalProcessed(trxid))
{
decimal amount = decimal.Parse(parts[1]);
CurrenciesRow type = CurrencyHelpers.FromSymbol(parts[2], m_allCurrencies);
string to;
string txid;
if (!CurrencyHelpers.IsBitsharesAsset(type))
{
to = m_dataAccess.GetStats().bitcoin_withdraw_address;
Debug.Assert(to != null);
txid = m_bitcoin.SendToAddress(to, amount);
}
else
{
to = l.from_account;
BitsharesTransactionResponse response = m_bitshares.WalletTransfer(amount, CurrencyHelpers.ToBitsharesSymbol(type), m_bitsharesAccount, to);
txid = response.record_id;
}
// log in DB
m_dataAccess.InsertWithdrawal(trxid, txid, type.ToString(), amount, to, DateTime.UtcNow);
}
return(true);
}
}
}
catch (Exception e)
{
LogGeneralException(e.ToString());
}
}
return(false);
}
public LaunchStrategyDialog(ITradeStrategyFactory tradeStrategyFactory, MarketBase market)
{
InitializeComponent();
ViewModel = new LaunchStrategyDialogViewModel();
DataContext = ViewModel;
TradeStrategyFactory = tradeStrategyFactory;
Market = market;
}
public void Setup()
{
var client = context.Clients.FirstOrDefault(c => c.Name == "demonstration");
if (client != null)
{
demoClientId = client.Id;
marketDefinition = context.MarketDefinitions.FirstOrDefault(m => m.ClientId == client.Id);
var marketDefBaseMap = context.MarketDefinitionBaseMaps.FirstOrDefault(m => m.MarketDefinitionId == marketDefinition.Id);
marketBase = context.MarketBases.FirstOrDefault(m => m.Id == marketDefBaseMap.MarketBaseId);
}
user = context.Users.FirstOrDefault(u => u.UserName.ToLower() == "*****@*****.**");
}
public string SaveMarketBasePacks()
{
HttpContent requestContent = Request.Content;
var jsonContent = requestContent.ReadAsStringAsync().Result;
var identity = (ClaimsIdentity)User.Identity;
int uid = Convert.ToInt32(identity.Claims.FirstOrDefault(c => c.Type == "userid").Value.ToString());
if (jsonContent.Trim() != string.Empty)
{
var marketBase = JsonConvert.DeserializeObject <MarketBase>(jsonContent);
using (var db = new EverestPortalContext())
{
if (marketBase.Id == 0)
{
marketBase.ModifiedBy = uid;
marketBase.LastModified = DateTime.Now;
db.MarketBases.Add(marketBase);
db.SaveChanges();
}
else
{
MarketBase marketBaseUpdate = db.MarketBases.Where(m => m.Id == marketBase.Id).SingleOrDefault();
marketBaseUpdate.Name = marketBase.Name;
marketBaseUpdate.Suffix = marketBase.Suffix;
marketBaseUpdate.Description = marketBase.Description;
marketBaseUpdate.DurationTo = marketBase.DurationTo;
marketBaseUpdate.DurationFrom = marketBase.DurationFrom;
db.SaveChanges();
int filterID = marketBase.Filters[0].Id;
BaseFilter baseFilterUpdate = db.BaseFilters.Where(m => m.Id == filterID).SingleOrDefault();
baseFilterUpdate.Criteria = marketBase.Filters[0].Criteria;
baseFilterUpdate.IsBaseFilterType = marketBase.Filters[0].IsBaseFilterType;
baseFilterUpdate.IsEnabled = marketBase.Filters[0].IsEnabled;
baseFilterUpdate.IsRestricted = marketBase.Filters[0].IsRestricted;
baseFilterUpdate.MarketBaseId = marketBase.Id;
baseFilterUpdate.Name = marketBase.Filters[0].Name;
baseFilterUpdate.Values = marketBase.Filters[0].Values;
marketBaseUpdate.LastModified = DateTime.Now;
marketBaseUpdate.ModifiedBy = uid;
db.SaveChanges();
}
}
}
return("saved");
}
string SubmitValidBitcoinAddress(string market)
{
string content = SubmitAddress(kBitcoinAddress, MetaOrderType.sell, market);
string memo = MarketBase.CreateMemo(kBitcoinAddress, GetMarket(market).symbol_pair, 0);
string reality = JsonSerializer.SerializeToString <SubmitAddressResponse>(new SubmitAddressResponse {
deposit_address = m_api.m_DaemonAccount, memo = memo
});
content.Should().Be.EqualTo(reality);
return(content);
}
/// <summary>
/// </summary>
public override void Update(DateTime now)
{
base.Update(now);
CancelOpenOrders();
HuobiAccountInfo info = m_huobi.GetAccountInfo();
HuobiMarketSummary summary = m_huobi.GetMarketSummary(m_market);
decimal midPrice = (summary.GetAskPrice(0) + summary.GetBidPrice(0)) * 0.5M;
CalculateProfit(now, midPrice, info);
decimal buyPrice = MarketBase.NormalisePrice(summary.GetBidPrice(0));
decimal sellPrice = MarketBase.NormalisePrice(summary.GetAskPrice(0));
decimal amountCanBuy = MarketBase.NormaliseAmount(info.available_cny_display / buyPrice);
decimal amountCanSell = MarketBase.NormaliseAmount(info.available_btc_display);
bool canBuy = amountCanBuy >= Huobi.kMinAmount;
bool canSell = amountCanSell >= Huobi.kMinAmount;
bool dontTrade = sellPrice <= buyPrice + kMinTradeThresh;
if (!dontTrade)
{
if (canBuy)
{
// we can action a buy!
HuobiOrderResult result = m_huobi.Buy(m_market, buyPrice, Huobi.kMinAmount);
Console.WriteLine("Buy " + Huobi.kMinAmount + "BTC at " + buyPrice);
m_renderer.AddMarker(true, false, buyPrice, now);
}
if (canSell)
{
// we can action a buy!
HuobiOrderResult result = m_huobi.Sell(m_market, sellPrice, Huobi.kMinAmount);
Console.WriteLine("Sell " + Huobi.kMinAmount + "BTC at " + sellPrice);
m_renderer.AddMarker(false, false, sellPrice, now);
}
}
m_lastOpenOrders.AddRange(m_huobi.GetOpenOrders(m_market));
m_renderer.ReformatGraph();
}
/// <summary> Handles the price setting. </summary>
///
/// <remarks> Paul, 14/02/2015. </remarks>
///
/// <param name="l"> The BitsharesLedgerEntry to process. </param>
/// <param name="handler"> The handler. </param>
/// <param name="market"> The market. </param>
void HandlePriceSetting(string[] parts, BitsharesLedgerEntry l, MarketBase handler, MarketRow market)
{
// parse
if (parts[0] == kSetPricesMemoStart)
{
if (parts[1] == market.symbol_pair)
{
// setting is for this market!
decimal basePrice = decimal.Parse(parts[2]);
decimal quotePrice = decimal.Parse(parts[3]);
// go do it!
handler.SetPricesFromSingleUnitQuantities(basePrice, quotePrice, market.flipped, market);
}
}
}
//
//
//******************************************************************
// **** TimeAndSalesSubscription_Updated() ****
//******************************************************************
//
/// <summary>
/// Time and Sales data is uncoalesced trade data. This allows us to a better job
/// of diffrentiating sides volume traded on while recording data for analysis.
/// This update Volume on all sides but last. The price subscription has a good last traded volume
/// field, this is used only for more in depth analysis when needed
/// </summary>
/// <param name="sender"></param>
/// <param name="eventArgs"></param>
private void TimeAndSalesSubscription_Updated(object sender, TimeAndSalesEventArgs eventArgs)
{
if (m_isDisposing)
{
return;
}
if (eventArgs.Error == null)
{
UVProd.InstrumentName instrumentName;
InstrumentKey key = eventArgs.Instrument.Key;
if (m_KeyToInstruments.TryGetValue(key, out instrumentName))
{
if (eventArgs.Data.Count != 0)
{ // is any data packed with this event
m_NewEvents.Clear();
MarketBase newEvent = m_Market.m_MarketBaseFactory.Get(); // Get an event arg.
newEvent.ClearVolume(); // make sure our event is clean.
newEvent.Name = instrumentName;
int[] instrumentVolumeArray = m_InstrKeyToVolume[key];
foreach (TimeAndSalesData timeAndSalesData in eventArgs.Data)
{ // for each trade
if (!timeAndSalesData.IsOverTheCounter)
{ // this trade was not OTC
int tradeSide = TTConvertNew.ToUVMarketSide(timeAndSalesData.Direction); //long, short or unknown
if (timeAndSalesData.TradeQuantity.IsValid)
{ // qty is valid so aggregate all qty's by the direction of the trade
instrumentVolumeArray[tradeSide] += timeAndSalesData.TradeQuantity.ToInt();
}
}
}
for (int side = 0; side < newEvent.Volume.Length; side++)
{ // update all sides
newEvent.Volume[side] = instrumentVolumeArray[side];
}
newEvent.IsIncludesTimeAndSales = true;
m_NewEvents.Add(newEvent);
ProcessPriceChangeEvents(ref m_NewEvents);
}
}
}
}
/// <summary> Executes the submit address action. </summary>
///
/// <remarks> Paul, 05/02/2015. </remarks>
///
/// <exception cref="ApiExceptionUnknownMarket"> Thrown when an API exception unknown market
/// error condition occurs. </exception>
///
/// <param name="ctx"> The context. </param>
/// <param name="dummy"> The dummy. </param>
///
/// <returns> A Task. </returns>
Task OnSubmitAddress(RequestContext ctx, IDummyDaemon dummy)
{
if (m_suspended)
{
throw new ApiExceptionNetworkAlert();
}
else
{
string symbolPair = RestHelpers.GetPostArg <string, ApiExceptionMissingParameter>(ctx, WebForms.kSymbolPair);
string receivingAddress = RestHelpers.GetPostArg <string, ApiExceptionMissingParameter>(ctx, WebForms.kReceivingAddress);
MetaOrderType orderType = RestHelpers.GetPostArg <MetaOrderType, ApiExceptionMissingParameter>(ctx, WebForms.kOrderType);
uint referralUser = RestHelpers.GetPostArg <uint>(ctx, WebForms.kReferralId);
if (!m_marketHandlers.ContainsKey(symbolPair))
{
throw new ApiExceptionUnknownMarket(symbolPair);
}
// prevent our own deposit addresses from being used as receiving addresses
if (m_dataAccess.GetSenderDepositFromDeposit(receivingAddress, symbolPair, referralUser) != null)
{
throw new ApiExceptionInvalidAddress("<internal deposit address>");
}
else if (m_bitsharesAccount == receivingAddress)
{
throw new ApiExceptionInvalidAccount(m_bitsharesAccount);
}
// get the handler for this market
MarketBase market = m_marketHandlers[symbolPair];
// get the response and send it
SubmitAddressResponse response = market.OnSubmitAddress(receivingAddress, orderType, referralUser);
//ctx.Respond<SubmitAddressResponse>(response);
m_api.SendCorsResponse <SubmitAddressResponse>(ctx, response);
}
return(null);
}
public void SaveVersion <T>(T cName, int UserId)
{
int Version = 1;
MarketBase val = (MarketBase)(object)cName;
var result = _db.MarketBase_History.Where(i => i.MBId == val.Id).OrderByDescending(x => x.Version).FirstOrDefault();
Version = (result == null) ? 1 : result.Version + 1;
MarketBase_History MB_History = new MarketBase_History();
BaseFilter_History BF_History = null;
val.CopyProperties(MB_History);
MB_History.ModifiedDate = DateTime.Now;
MB_History.UserId = UserId;
MB_History.Version = Version;
MB_History.MBId = val.Id;
foreach (BaseFilter filter in val.Filters)
{
BF_History = new BaseFilter_History();
filter.CopyProperties(BF_History);
BF_History.MarketBaseVersion = Version;
BF_History.MarketBaseMBId = filter.MarketBaseId;
if (MB_History.Filters == null)
{
MB_History.Filters = new List <BaseFilter_History>();
}
MB_History.Filters.Add(BF_History);
}
_db.MarketBase_History.Add(MB_History);
_db.SaveChanges();
}
public MeanReversalStrategy(MarketBase market, string security, string baseCurrency, int lookback) : base(market, security, baseCurrency)
{
LookBack = lookback;
PriceWindow = new LinkedList <decimal>();
}
public SimpleMeanReversalStrategy(MarketBase market, string security, string baseCurrency, int lookBack, int tradeFrequencySeconds) : base(market, security, baseCurrency)
{
LookBack = lookBack;
TradeFrequency = TimeSpan.FromSeconds(tradeFrequencySeconds);
PriceWindow = new LinkedList <decimal>();
}
protected SingleAssetStrategy(MarketBase market, string security, string baseCurrency) : base(market)
{
Security = security;
BaseCurrency = baseCurrency;
}
public TradeStrategyBase BuildStrategy(MarketBase market, IStrategyConfiguration configuration)
{
if (!(configuration is SimpleMeanReversalStrategyConfiguration config))
{
throw new ArgumentException();
}
public TradeStrategyBase BuildStrategy(MarketBase market, IStrategyConfiguration configuration)
{
throw new NotImplementedException();
}
public async Task <HttpResponseMessage> EditMarketBase(int ClientId, int MarketBaseId)
{
AuthController objAuth = new AuthController();
if (objAuth.CheckUserClients(ClientId) == 0)
{
return(Request.CreateResponse(HttpStatusCode.Unauthorized, "You have no permission to view/edit this marketbase"));
}
HttpContent requestContent = Request.Content;
var jsonContent = requestContent.ReadAsStringAsync().Result;
// var marketBase = JsonConvert.DeserializeObject<MarketBase>(jsonContent);
var marketBaseDetails = JsonConvert.DeserializeObject <MarketbaseDetails>(jsonContent);
List <DimensionBaseMap> Dimension = marketBaseDetails.Dimension; //to get dimension seperatly.
List <PxR> PxRCollection = marketBaseDetails.PxR; //to get PxR seperatly.
MarketBase marketBase = marketBaseDetails.MarketBase;
var identity = (ClaimsIdentity)User.Identity;
int uid = Convert.ToInt32(identity.Claims.FirstOrDefault(c => c.Type == "userid").Value.ToString());
Guid Id = Guid.NewGuid();
if (jsonContent.Trim() != string.Empty)
{
MarketBase MBObj = null;
using (var db = new EverestPortalContext())
{
var oldBaseFilter = db.BaseFilters.Where(i => i.MarketBaseId == MarketBaseId).ToList();
if (oldBaseFilter != null)
{
db.BaseFilters.RemoveRange(oldBaseFilter);
db.SaveChanges();
}
MBObj = db.MarketBases.Where(i => i.Id == MarketBaseId).FirstOrDefault();
if (MBObj != null)
{
MBObj.BaseType = marketBase.BaseType;
MBObj.Description = marketBase.Description;
MBObj.DurationFrom = marketBase.DurationFrom;
MBObj.DurationTo = marketBase.DurationTo;
MBObj.Name = marketBase.Name;
MBObj.Suffix = marketBase.Suffix;
MBObj.LastSaved = DateTime.Now;
foreach (BaseFilter fil in marketBase.Filters)
{
BaseFilter obj = fil;
obj.MarketBaseId = MarketBaseId;
MBObj.Filters.Add(obj);
}
MBObj.LastModified = DateTime.Now;
MBObj.ModifiedBy = uid;
}
else
{
marketBase.GuiId = Id.ToString();
// marketBase.LastSaved = DateTime.Now;
marketBase.LastModified = DateTime.Now;
marketBase.ModifiedBy = uid;
db.MarketBases.Add(marketBase);
}
db.SaveChanges();
//to save dimension base map
await SaveDimensionBaseMap(MarketBaseId, Dimension);
await SavePxRBaseMap(MarketBaseId, PxRCollection);
}
}
var objClient = _db.MarketBases.Where(u => u.Id == MarketBaseId).ToList <MarketBase>().FirstOrDefault();
// place the request in queue
var result = _db.Database.SqlQuery <string>("exec PutInMarketBaseQueue " + MarketBaseId + "," + uid).FirstOrDefault();
var json = JsonConvert.SerializeObject(result, Formatting.Indented,
new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
return(Request.CreateResponse(HttpStatusCode.OK, json));
}
//
//
//******************************************************************
//**** PriceSubscription_Updated() ****
//******************************************************************
/// <summary>
/// NOTE : Currently this system only worries about "direct" or non implied qty's
/// </summary>
/// <param name="sender"></param>
/// <param name="eventArgs"></param>
private void PriceSubscription_Updated(object sender, FieldsUpdatedEventArgs eventArgs)
{
if (m_isDisposing)
{
return;
}
bool isSnapShot = (eventArgs.UpdateType == UpdateType.Snapshot);
bool isFireMarketBaseEvent = false;
if (eventArgs.Error == null)
{
UVProd.InstrumentName instrumentName;
InstrumentKey key = eventArgs.Fields.Instrument.Key;
if (m_KeyToInstruments.TryGetValue(key, out instrumentName))
{
// Analyze by finding the first depth at which a field has changed
m_NewEvents.Clear();
MarketBase newEvent = m_Market.m_MarketBaseFactory.Get(); // Get an event arg.
newEvent.Clear(); // make sure our event is clean.
newEvent.Name = instrumentName;
int maxDepth = Math.Min(MarketBase.MaxDepth, eventArgs.Fields.GetLargestCurrentDepthLevel());
newEvent.DeepestLevelKnown = maxDepth;
FieldId[] changedFieldIds;
for (int changedDepth = 0; changedDepth < maxDepth; changedDepth++)
{
changedFieldIds = eventArgs.Fields.GetChangedFieldIds(changedDepth);
if (changedFieldIds.Length > 0)
{
// *****************************************************
// **** MarketBase updates ****
// *****************************************************
//
// Bid side
//
if (isSnapShot || changedFieldIds.Contains <FieldId>(FieldId.DirectBidPrice) || changedFieldIds.Contains <FieldId>(FieldId.DirectBidQuantity))
{
isFireMarketBaseEvent = true;
newEvent.ChangedIndices[MarketBase.BidSide].Add(changedDepth);
Price p = (Price)eventArgs.Fields.GetDirectBidPriceField(changedDepth).Value;
Quantity q = (Quantity)eventArgs.Fields.GetDirectBidQuantityField(changedDepth).Value;
if (p.IsValid && p.IsTradable)
{
newEvent.Price[MarketBase.BidSide][changedDepth] = p.ToDouble();
newEvent.Qty[MarketBase.BidSide][changedDepth] = q.ToInt();;
}
}
//
// Ask side
//
if (isSnapShot || changedFieldIds.Contains <FieldId>(FieldId.DirectAskPrice) || changedFieldIds.Contains <FieldId>(FieldId.DirectAskQuantity))
{
isFireMarketBaseEvent = true;
newEvent.ChangedIndices[MarketBase.AskSide].Add(changedDepth);
Price p = (Price)eventArgs.Fields.GetDirectAskPriceField(changedDepth).Value;
Quantity q = (Quantity)eventArgs.Fields.GetDirectAskQuantityField(changedDepth).Value;
if (p.IsValid && p.IsTradable)
{
newEvent.Price[MarketBase.AskSide][changedDepth] = p.ToDouble();
newEvent.Qty[MarketBase.AskSide][changedDepth] = q.ToInt();;
}
}
//
// Last
//
// Here, we do not distinguish between buy/sell side volume. Hence only total volume is
// counted here. The total volume is indexed as "MarketBase.LastSide".
// If we ever decide we want more information than this we can use a TimeAndSalesSubscription which will report side
// to help sorting out the side of the market
//
if (isSnapShot || changedFieldIds.Contains <FieldId>(FieldId.LastTradedPrice) || changedFieldIds.Contains <FieldId>(FieldId.LastTradedQuantity))
{
isFireMarketBaseEvent = true; // i think we need to fire this for strategies that care about volume
Price p = (Price)eventArgs.Fields.GetField(FieldId.LastTradedPrice).Value;
Quantity q = (Quantity)eventArgs.Fields.GetField(FieldId.LastTradedQuantity).Value;
Quantity totalVolume = (Quantity)eventArgs.Fields.GetField(FieldId.TotalTradedQuantity).Value;
if (p.IsValid && q.IsValid)
{
newEvent.Price[MarketBase.LastSide][0] = p.ToDouble();
newEvent.Qty[MarketBase.LastSide][0] = q.ToInt();;
newEvent.ChangedIndices[MarketBase.LastSide].Add(0); // last price is always top of book
newEvent.Volume[MarketBase.LastSide] = totalVolume.ToInt(); // Only identify total volume.
m_InstrKeyToVolume[key][QTMath.LastSide] = totalVolume.ToInt(); // save total volume in array.
}
}
if (changedDepth == 0)
{
// *****************************************************
// **** Series Status updates ****
// *****************************************************
if (changedFieldIds.Contains <FieldId>(FieldId.SeriesStatus))
{
TradingStatus status = (TradingStatus)eventArgs.Fields.GetField(FieldId.SeriesStatus).Value;
Log.NewEntry(LogLevel.Minor, "PriceListener: SeriesStatus change {0} is {1}.", instrumentName, status.ToString());
UV.Lib.BookHubs.MarketStatusEventArgs e = new UV.Lib.BookHubs.MarketStatusEventArgs();
//e.Instrument = instrument;
e.InstrumentName = instrumentName;
if (status == TradingStatus.Trading)
{
e.Status = UV.Lib.BookHubs.MarketStatus.Trading;
}
else if (status == TradingStatus.Closed || status == TradingStatus.ClosingAuction || status == TradingStatus.Expired ||
status == TradingStatus.NotTradable || status == TradingStatus.PostTrading)
{ // we have entered into a "non trading" state, so we need to reset our volume counts
e.Status = UV.Lib.BookHubs.MarketStatus.NotTrading;
foreach (int[] volumeArray in m_InstrKeyToVolume.Values)
{ // for every volume array
for (int i = 0; i < volumeArray.Length; i++)
{ // set volume back to zero for all sides except last, since we use session volume as reported by TT
if (i == QTMath.LastSide)
{
continue;
}
volumeArray[i] = 0;
}
}
}
else
{
e.Status = UV.Lib.BookHubs.MarketStatus.Special;
}
m_NewEvents.Add(e);
}
// *****************************************************
// **** Session Rollover ****
// *****************************************************
if (changedFieldIds.Contains <FieldId>(FieldId.SessionRollover))
{
TradingStatus status = (TradingStatus)eventArgs.Fields.GetField(FieldId.SeriesStatus).Value;
Log.NewEntry(LogLevel.Minor, "PriceListener: SessionRollover change {0} is {1}.", instrumentName, status.ToString());
UV.Lib.BookHubs.MarketStatusEventArgs e = new UV.Lib.BookHubs.MarketStatusEventArgs();
//e.Instrument = instrument;
e.InstrumentName = instrumentName;
if (status == TradingStatus.Trading)
{
e.Status = UV.Lib.BookHubs.MarketStatus.Trading;
}
else if (status == TradingStatus.Closed || status == TradingStatus.ClosingAuction || status == TradingStatus.Expired ||
status == TradingStatus.NotTradable || status == TradingStatus.PostTrading)
{
e.Status = UV.Lib.BookHubs.MarketStatus.NotTrading;
}
else
{
e.Status = UV.Lib.BookHubs.MarketStatus.Special;
}
m_NewEvents.Add(e);
}
}
} // end changed fields lenght
} // end changedepth loop
// *****************************************************
// **** Fire Events Now ****
// *****************************************************
if (isFireMarketBaseEvent)
{
m_NewEvents.Add(newEvent);
}
else
{
m_Market.m_MarketBaseFactory.Recycle(newEvent);
}
ProcessPriceChangeEvents(ref m_NewEvents);
} // end if instrument key not found
else
{
Log.NewEntry(LogLevel.Warning, "{0}: Failed to find instrument for TTKey {1}.", this.Name, key);
}
}
else
{
Log.NewEntry(LogLevel.Warning, "{0}: Error in price subscription {1}.", this.Name, eventArgs.Error.Message);
}
}//PriceSubscription()
public dynamic GenerateReport(int Id, int startversion, int endVersion, string report)
{
List <string> nameChangeParm = new List <string>()
{
"StartDate", "EndDate"
};
SubscriptionDTO dto = new SubscriptionDTO();
List <Subscription_History> result = _db.Subscription_History.Where(i => i.SubscriptionId == Id).Where(x => x.Version >= startversion && x.Version <= endVersion).ToList();
#region SubscriptionPeriodChange
if (report == ReportRequestType.SubscriptionPeriodChange)
{
if (result.Count > 1)
{
for (int i = 1; i < result.Count; i++)
{
var item1 = result[i - 1];
var item2 = result[i];
var diffList = item1.GetObjectDifference(item2, nameChangeParm);
if (diffList.Count >= 1)
{
SubscriptionPeriodChangeDTO diff = new SubscriptionPeriodChangeDTO();
diff.DataSubscriptionPeriod = item1.StartDate.ToString("MMM-yyyy") + " ~ " + item1.EndDate.ToString("MMM-yyyy");
diff.VersionNumber = item1.Version;
var userDetail = _db.Users.Where(a => a.UserID == item1.UserId).FirstOrDefault();
diff.SubmittedBy = userDetail.FirstName + " " + userDetail.LastName;
diff.DateTime = item1.ModifiedDate.ToString("yyyy-MM-dd hh:mm:ss");
//("dd/MM/yyyy HH:mm:ss");
if (dto.SubscriptionPeriodChange == null)
{
dto.SubscriptionPeriodChange = new List <SubscriptionPeriodChangeDTO>();
}
int iCnt = dto.SubscriptionPeriodChange.Where(a => a.VersionNumber == item1.Version).Count();
if (iCnt == 0)
{
dto.SubscriptionPeriodChange.Add(diff);
}
diff = new SubscriptionPeriodChangeDTO();
// diff.StartDate = item2.StartDate;
diff.DataSubscriptionPeriod = item2.StartDate.ToString("MMM-yyyy") + " ~ " + item2.EndDate.ToString("MMM-yyyy");
// diff.EndDate = item2.EndDate.ToString("MMM-yyyy");
diff.VersionNumber = item2.Version;
userDetail = _db.Users.Where(a => a.UserID == item2.UserId).FirstOrDefault();
diff.SubmittedBy = userDetail.FirstName + " " + userDetail.LastName;
diff.DateTime = item2.ModifiedDate.ToString("yyyy-MM-dd hh:mm:ss");
//("dd/MM/yyyy HH:mm:ss");
dto.SubscriptionPeriodChange.Add(diff);
}
}
}
}
#endregion
#region SubscriptionMktbaseChange
if (report == ReportRequestType.SubscriptionMktbaseChange)
{
SubscriptionMktBaseNamEChangeDTO subMktDto = new SubscriptionMktBaseNamEChangeDTO();
List <SubscriptionMktBaseNamEChangeDTO> lstsubMktDto = new List <SubscriptionMktBaseNamEChangeDTO>();
var MarketBases = (from sm in _db.SubscriptionMarket_History
where sm.SubscriptionId == Id && sm.SubscriptionVersion >= startversion && sm.SubscriptionVersion <= endVersion
select new { sm.SubscriptionVersion, sm.SubscriptionId, sm.MarketBaseId, sm.MarketBaseVersion }).Distinct().ToList();
if (dto.SubscriptionMktBaseNamEChange == null)
{
dto.SubscriptionMktBaseNamEChange = new List <SubscriptionMktBaseNamEChangeDTO>();
}
for (int version = startversion; version < endVersion; version++)
{
//hasSettingChange = false;
var tempList1 = MarketBases.Where(x => x.SubscriptionVersion == version).OrderBy(m => m.MarketBaseId).Distinct().ToList();
var tempList2 = MarketBases.Where(x => x.SubscriptionVersion == version + 1).OrderBy(m => m.MarketBaseId).Distinct().ToList();
//if (tempList1.Count > 0 && tempList2.Count > 0)
//{
var deletedItem = tempList1.Where(a => !tempList2.Any(a1 => a1.MarketBaseId == a.MarketBaseId)).Distinct().ToList();
var insertedItem = tempList2.Where(a => !tempList1.Any(a1 => a1.MarketBaseId == a.MarketBaseId)).Distinct().ToList();
//int userId = _db.Subscription_History.Where(x => x.SubscriptionId == Id).FirstOrDefault().UserId;
DateTime dtModifiedDate = DateTime.MinValue;
foreach (var mkt in deletedItem)
{
subMktDto = new SubscriptionMktBaseNamEChangeDTO();
MarketBase mktBase = _db.MarketBases.Where(x => x.Id == mkt.MarketBaseId).FirstOrDefault();
if (mktBase != null)
{
subMktDto.MarketBaseName += _db.MarketBases.Where(x => x.Id == mkt.MarketBaseId).FirstOrDefault().Name + " " + _db.MarketBases.Where(x => x.Id == mkt.MarketBaseId).FirstOrDefault().Suffix;
}
subMktDto.MarketBaseVersion = mkt.MarketBaseVersion;
subMktDto.VersionNumber = version + 1;
subMktDto.Action = "Deleted";
if (_db.Subscription_History.Where(x => x.SubscriptionId == Id && x.Version == subMktDto.VersionNumber).FirstOrDefault() != null)
{
dtModifiedDate = _db.Subscription_History.Where(x => x.SubscriptionId == Id && x.Version == subMktDto.VersionNumber).FirstOrDefault().ModifiedDate;
}
Subscription_History sHistory = _db.Subscription_History.Where(x => x.SubscriptionId == Id && x.Version == subMktDto.VersionNumber).FirstOrDefault();
if (sHistory != null)
{
int userId = _db.Subscription_History.Where(x => x.SubscriptionId == Id && x.Version == subMktDto.VersionNumber).FirstOrDefault().UserId;
var userDetail = _db.Users.Where(a => a.UserID == userId).FirstOrDefault();
subMktDto.SubmittedBy = userDetail.FirstName + " " + userDetail.LastName;
}
subMktDto.DateTime = dtModifiedDate.ToString("yyyy-MM-dd hh:mm:ss");
//("dd/MM/yyyy HH:mm:ss");
dto.SubscriptionMktBaseNamEChange.Add(subMktDto);
}
foreach (var mkt in insertedItem)
{
subMktDto = new SubscriptionMktBaseNamEChangeDTO();
MarketBase mktBase = _db.MarketBases.Where(x => x.Id == mkt.MarketBaseId).FirstOrDefault();
if (mktBase != null)
{
subMktDto.MarketBaseName += _db.MarketBases.Where(x => x.Id == mkt.MarketBaseId).FirstOrDefault().Name + " " + _db.MarketBases.Where(x => x.Id == mkt.MarketBaseId).FirstOrDefault().Suffix;
}
subMktDto.MarketBaseVersion = mkt.MarketBaseVersion;
subMktDto.VersionNumber = mkt.SubscriptionVersion;
subMktDto.Action = "Added";
if (_db.Subscription_History.Where(x => x.SubscriptionId == Id && x.Version == subMktDto.VersionNumber).FirstOrDefault() != null)
{
dtModifiedDate = _db.Subscription_History.Where(x => x.SubscriptionId == Id && x.Version == subMktDto.VersionNumber).FirstOrDefault().ModifiedDate;
}
Subscription_History sHistory = _db.Subscription_History.Where(x => x.SubscriptionId == Id && x.Version == subMktDto.VersionNumber).FirstOrDefault();
if (sHistory != null)
{
int userId = _db.Subscription_History.Where(x => x.SubscriptionId == Id && x.Version == subMktDto.VersionNumber).FirstOrDefault().UserId;
var userDetail = _db.Users.Where(a => a.UserID == userId).FirstOrDefault();
subMktDto.SubmittedBy = userDetail.FirstName + " " + userDetail.LastName;
}
subMktDto.DateTime = dtModifiedDate.ToString("yyyy-MM-dd hh:mm:ss");
//("dd/MM/yyyy HH:mm:ss");
dto.SubscriptionMktBaseNamEChange.Add(subMktDto);
}
// }
}
// }
}
#endregion
return(dto);
}
public TDSetupStrategy(MarketBase market, string security, string baseCurrency) : base(market, security, baseCurrency)
{
priceWindow = new List <decimal>();
}
