public void Delete(K2DataObjects.Product p)
{
try
{
using (K2DataObjects.DataContext db = Factory.Instance().GetDSContext())
{
var products =
(from prod in db.Products
where prod.Mnemonic == p.Mnemonic
select prod).SingleOrDefault();
if (products != null)
{
db.Products.DeleteOnSubmit(products);
db.SubmitChanges();
}
}
}
catch (Exception myE)
{
m_Log.Error("Delete", myE);
}
}
public double[,] GenFeatureSet(K2DataObjects.PriceBar[] bars, decimal[][] curveValues, int count, List<string> headers, long generations)
{
// bars
// move access to data out of here and pass in raw data
int numCols = GetNumColumns(headers.Count, (int)generations);
double[,] featureSet = new double[count, numCols];
long index = 0;
long row = 0;
for (index = 0; index < curveValues.GetLength(0); index++)
{
if (generations <= index)
{
CopyBarData(featureSet, bars, index, row);
for (int j = 0; j <= generations; j++)
{
int offset = 10 + (headers.Count * j);
CopyFeatureData(featureSet, curveValues, index - j, row, offset);
}
row++;
if (row >= count)
{
break;
}
}
}
return featureSet;
}
public void Insert(K2DataObjects.Account account, bool allowUpdate)
{
try
{
using (K2DataObjects.DataContext db = Factory.Instance().GetDSContext())
{
var dbAccounts =
(from a in db.Accounts
where a.AccountCode == account.AccountCode
select a).SingleOrDefault();
if (dbAccounts != null)
{
if (allowUpdate)
{
db.Accounts.DeleteOnSubmit(dbAccounts);
db.SubmitChanges();
}
else
{
throw new Exception("account exists");
}
}
db.Accounts.InsertOnSubmit(account);
db.SubmitChanges();
}
}
catch (Exception myE)
{
m_Log.Error("Insert", myE);
}
}
public long CheckAlignment(K2DataObjects.PriceBar[] bars, decimal[][] curveValues, int count)
{
long position = 0;
for (long i = 0; i < count; i++)
{
//if(bars[i].TimeStamp != curveValues[i],
}
return 0;
}
public void AddAccount(K2DataObjects.Account account)
{
try
{
}
catch(Exception myE)
{
}
}
public void InsertUser(K2DataObjects.User user)
{
try
{
K2DS.K2UserDS userDs = new K2DS.K2UserDS();
userDs.InsertUser(user);
}
catch (Exception myE)
{
}
}
/// <summary>
/// Get the trades for some order
/// </summary>
/// <param name="O"></param>
/// <returns></returns>
public List<K2DataObjects.Trade> GetTrade(K2DataObjects.Order order)
{
using (K2DataObjects.DataContext db = Factory.Instance().GetDSContext())
{
var trade =
(from ot in db.OrderTrades
from t in db.Trades
where (ot.OrderIdentity == order.Identity) && (ot.TradeIdentity == t.Identity)
select t );
return (trade.ToList());
}
}
public void Insert(K2DataObjects.Trade t)
{
try
{
t.SystemDate = DateTime.Now;
using (K2DataObjects.DataContext db = Factory.Instance().GetDSContext())
{
db.Trades.InsertOnSubmit(t);
db.SubmitChanges();
}
}
catch (Exception myE)
{
m_Log.Error("Insert", myE);
}
}
/// <summary>
/// Insert the order passed into the databae
/// </summary>
/// <param name="order"></param>
/// <param name="allowUpdate">if true then updates are allowed, if false an excpetion is thrown if order exists</param>
public void InsertOrder(K2DataObjects.Order order, bool allowUpdate)
{
try
{
order.SystemDate = DateTime.Now;
using (K2DataObjects.DataContext db = Factory.Instance().GetDSContext())
{
var dbOrders =
(from o in db.Orders
where o.Identity == order.Identity
select o).SingleOrDefault();
if (dbOrders != null)
{
if (allowUpdate)
{
UpdateOrderFields(dbOrders, order);
//db.Orders.DeleteOnSubmit(dbOrders);
db.SubmitChanges();
//dbOrders = order;
//dbOrders.
}
else
{
throw new Exception("Order already exists");
}
}
else
{
db.Orders.InsertOnSubmit(order as K2DataObjects.Order);
db.SubmitChanges();
}
}
}
catch (Exception myE)
{
m_Log.Error("Insert", myE);
}
}
/// <summary>
/// Inserts a product and creates exchange and venue if needed
/// </summary>
/// <param name="p"></param>
/// <param name="deleteExisting"></param>
public void Insert(K2DataObjects.Product p, bool deleteExisting)
{
try
{
K2DS.K2ProductDS productDS = new K2DS.K2ProductDS();
List<K2DataObjects.Product> products = productDS.GetProducts(p.TradeVenue, p.Mnemonic);
foreach (K2DataObjects.Product x in products)
{
}
if (products.Count() == 0)
{
productDS.Insert(p);
if (productDS.GetExchange(p.Exchange).Count() == 0)
{
K2DataObjects.Exchange e = new K2DataObjects.Exchange();
e.ExchangeCode = p.Exchange;
e.Name = p.Exchange;
productDS.Insert(e);
}
if (productDS.GetVenue(p.TradeVenue).Count() == 0)
{
K2DataObjects.TradeVenue v = new K2DataObjects.TradeVenue();
v.Code = p.TradeVenue;
v.Name = p.TradeVenue;
productDS.Insert(v);
}
}
else
{
if (deleteExisting)
{
productDS.Delete(p);
productDS.Insert(p);
}
}
}
catch (Exception myE)
{
}
}
public void Insert(K2DataObjects.PriceBar inBar, bool allowUpdate)
{
try
{
using (K2DataObjects.DataContext db = new K2DataObjects.DataContext(_connectString))
{
var dbPriceBars =
(from bar in db.PriceBars
where bar.Mnemonic == inBar.Mnemonic &&
bar.ItemType == inBar.ItemType &&
bar.ItemSize == inBar.ItemSize &&
bar.TimeStamp == inBar.TimeStamp &&
bar.RequestID == inBar.RequestID
select bar).SingleOrDefault();
if (dbPriceBars != null)
{
if (allowUpdate)
{
db.PriceBars.DeleteOnSubmit(dbPriceBars);
db.SubmitChanges();
}
else
{
throw new Exception("bar exists");
}
}
db.PriceBars.InsertOnSubmit(inBar);
db.SubmitChanges();
}
}
catch (Exception myE)
{
m_Log.Error("Insert", myE);
}
}
public void Insert(K2DataObjects.TradeSignal signal, bool allowUpdate)
{
try
{
using (K2DataObjects.DataContext db = Factory.Instance().GetDSContext())
{
var dbSignals =
(from s in db.TradeSignals
where s.Identity == signal.Identity
select s).SingleOrDefault();
if (dbSignals != null)
{
if (allowUpdate)
{
db.TradeSignals.DeleteOnSubmit(dbSignals);
db.SubmitChanges();
}
else
{
throw new Exception("trade signal exists");
}
}
db.TradeSignals.InsertOnSubmit(signal);
db.SubmitChanges();
}
}
catch (Exception myE)
{
m_Log.Error("Insert", myE);
}
}
/// <summary>
/// Finds the missing bars in some set of price bars given the interval of
/// each bar
/// </summary>
/// <returns>
/// The gaps in the data as BarRange objects
/// </returns>
/// <param name='priceBars'>
/// Price bars.
/// </param>
/// <param name='startTicks'>
/// Start ticks.
/// </param>
/// <param name='intervalTicks'>
/// Interval ticks.
/// </param>
public static List<BarRange> FindMissingBars(K2DataObjects.PriceBar[] priceBars, long startTicks, long intervalTicks)
{
List<BarRange> missingRanges = new List<BarRange>();
try
{
for(long index =0; index < priceBars.Length; index++)
{
if(priceBars[index].TimeStamp < startTicks)
continue;
if (index > 0)
{
long diffTicks = priceBars[index].TimeStamp - priceBars[index - 1].TimeStamp;
if(diffTicks > intervalTicks)
{
DateTime start = new DateTime(priceBars[index - 1].TimeStamp);
DateTime end = new DateTime(priceBars[index].TimeStamp);
if ((start.Hour == 15) && (start.Minute == 14))
continue;
if ((start.Hour == 16) && (start.Minute == 14))
continue;
if ((start.Day <10) || (start.Month!=1))
continue;
BarRange barRange = new BarRange(priceBars[index - 1].Mnemonic, intervalTicks, priceBars[index - 1].TimeStamp, priceBars[index].TimeStamp);
missingRanges.Add(barRange);
}
}
}
}
catch (Exception e)
{
}
return missingRanges;
}
public void InsertFill(K2DataObjects.Fill f, bool allowUpdate)
{
try
{
using (K2DataObjects.DataContext db = Factory.Instance().GetDSContext())
{
var dbFills =
(from fill in db.Fills
where fill.Identity == f.Identity
select fill).SingleOrDefault();
if (dbFills != null)
{
if (allowUpdate)
{
db.Fills.DeleteOnSubmit(f);
db.SubmitChanges();
//dbOrders = order;
//dbOrders.
}
else
{
throw new Exception("Order already exists");
}
}
db.Fills.InsertOnSubmit(f);
db.SubmitChanges();
}
}
catch (Exception myE)
{
m_Log.Error("InsertFill", myE);
}
}
/// <summary>
/// Add product to the product manager - no events are raised
/// </summary>
/// <param name="productdata"></param>
/// <returns></returns>
public string AddProductDirect(K2DataObjects.Product productdata)
{
string productId = "";
try
{
productId = AppFacade.Instance().GetProductManager().AddProduct(productdata);
}
catch (Exception myE)
{
}
return productId;
}
public void Insert(K2DataObjects.Exchange e)
{
try
{
using (K2DataObjects.DataContext db = Factory.Instance().GetDSContext())
{
db.Exchanges.InsertOnSubmit(e);
db.SubmitChanges();
}
}
catch (Exception myE)
{
m_Log.Error("Insert", myE);
}
}
private void UpdateOrderFields(K2DataObjects.Order targetOrder, K2DataObjects.Order sourceOrder)
{
try
{
targetOrder.ClOrdID = sourceOrder.ClOrdID;
targetOrder.AvgPx = sourceOrder.AvgPx;
targetOrder.CumQty = sourceOrder.CumQty;
targetOrder.LastPx = sourceOrder.LastPx;
targetOrder.LastQty = sourceOrder.LastQty;
targetOrder.LeavesQty = sourceOrder.LeavesQty;
targetOrder.OrderQty = sourceOrder.OrderQty;
targetOrder.OrdStatus = sourceOrder.OrdStatus;
targetOrder.OrigClOrdID = sourceOrder.OrigClOrdID;
targetOrder.OrdType = sourceOrder.OrdType;
targetOrder.Side = sourceOrder.Side;
targetOrder.Price = sourceOrder.Price;
targetOrder.StopPx = sourceOrder.StopPx;
targetOrder.Text = sourceOrder.Text;
targetOrder.Tag = sourceOrder.Tag;
targetOrder.TransactTime = sourceOrder.TransactTime;
targetOrder.Account = sourceOrder.Account;
}
catch (Exception myE)
{
m_Log.Error("Insert", myE);
}
}
public void Update(string Identity, K2DataObjects.Trade t)
{
try
{
using (K2DataObjects.DataContext db = Factory.Instance().GetDSContext())
{
// get the product
var existingTrade =
(from trades in db.Trades
where trades.Identity == Identity
select trades).SingleOrDefault();
// update the product
if (existingTrade != null)
{
existingTrade = t;
}
// replace the product
db.SubmitChanges();
}
}
catch (Exception myE)
{
}
}
public void UpdateFill(string exchID, K2DataObjects.Fill f)
{
try
{
using (K2DataObjects.DataContext db = Factory.Instance().GetDSContext())
{
// get the product
var existingFill =
(from fills in db.Fills
where fills.Identity == exchID
select fills).SingleOrDefault();
// update the product
if (existingFill != null)
{
existingFill = f;
}
// replace the product
db.SubmitChanges();
}
}
catch (Exception myE)
{
m_Log.Error("UpdateFill", myE);
}
}
/// <summary>
/// Add a user to the database
/// </summary>
/// <param name="user">user data object</param>
public void InsertUser(K2DataObjects.User user)
{
try
{
using (K2DataObjects.DataContext db = Factory.Instance().GetDSContext())
{
user.LastSignIn = DateTime.Now;
user.IsSignedIn = false;
db.Users.InsertOnSubmit(user);
db.SubmitChanges();
}
}
catch (Exception myE)
{
m_Log.Error("Add User", myE);
throw myE;
}
}
public void UpdateUser(K2DataObjects.User userUpdate)
{
try
{
using (K2DataObjects.DataContext db = Factory.Instance().GetDSContext())
{
var user =
(from c in db.Users
where c.ID == userUpdate.ID
select c).SingleOrDefault();
if (user != null)
{
user = userUpdate;
}
db.SubmitChanges();
}
}
catch (Exception myE)
{
m_Log.Error("Update User", myE);
throw myE;
}
}
public void Update(string Identity, K2DataObjects.Product p)
{
try
{
using (K2DataObjects.DataContext context = Factory.Instance().GetDSContext())
{
// get the product
var existingProduct =
(from products in context.Products
where products.Identity == Identity
select products).SingleOrDefault();
// update the product
if (existingProduct != null)
{
existingProduct = p;
}
// replace the product
context.SubmitChanges();
}
}
catch (Exception myE)
{
}
}
public void Update(string venueCode, K2DataObjects.TradeVenue v)
{
try
{
using (K2DataObjects.DataContext context = Factory.Instance().GetDSContext())
{
// get the product
var existingVenue =
(from venues in context.Venues
where venues.Code == venueCode
select venues).SingleOrDefault();
// update the product
if (existingVenue != null)
{
existingVenue = v;
}
// replace the product
context.SubmitChanges();
}
}
catch (Exception myE)
{
}
}
public void Update(string exchCode, K2DataObjects.Exchange e)
{
try
{
using (K2DataObjects.DataContext context = Factory.Instance().GetDSContext())
{
// get the product
var existingExch =
(from exchs in context.Exchanges
where exchs.ExchangeCode == exchCode
select exchs).SingleOrDefault();
// update the product
if (existingExch != null)
{
existingExch = e;
}
// replace the product
context.SubmitChanges();
}
}
catch (Exception myE)
{
}
}
public void Insert(K2DataObjects.CurveValue inCurveValue, bool allowUpdate)
{
try
{
using (K2DataObjects.DataContext db = new K2DataObjects.DataContext(_connectString))
{
var dbCurveVals =
(from cv in db.CurveValues
where cv.Mnemonic == inCurveValue.Mnemonic &&
cv.ItemType == inCurveValue.ItemType &&
cv.ItemSize == inCurveValue.ItemSize &&
cv.TimeStamp == inCurveValue.TimeStamp &&
cv.RequestID == inCurveValue.RequestID &&
cv.HeaderID == inCurveValue.HeaderID
select cv).SingleOrDefault();
if (dbCurveVals != null)
{
if (allowUpdate)
{
db.CurveValues.DeleteOnSubmit(dbCurveVals);
db.SubmitChanges();
}
else
{
throw new Exception("bar exists");
}
}
db.CurveValues.InsertOnSubmit(inCurveValue);
db.SubmitChanges();
}
}
catch (Exception myE)
{
m_Log.Error("Insert", myE);
}
}
/// <summary>
/// Walks through a set of bars, looks back at a previous bar and
/// and determines if it was an opportunity to buy or sell based on the
/// current evidance
/// </summary>
/// <param name="priceBars">Set of price bars to analyse</param>
/// <param name="scanSize">how many bars are scanned at a time</param>
/// <param name="stops">max stops out of profit before potential buy/sell is rejected</param>
/// <returns></returns>
public static long[] GetWinners(K2DataObjects.PriceBar[] priceBars, int offset, int count, int scanSize, decimal stops, decimal profitTarget)
{
ProfitSide ps = ProfitSide.none;
long[] winners = new long[count];
//int outRow = 0;
for (int i = offset; i < priceBars.Length; i++)
{
// need at least more bars than the scan size
if (i >= scanSize)
{
// check preceeding bars
ps = ProfitSide.none;
// right now its neither a buy or sell so look if
// there is some direction
if (priceBars[i - scanSize].High < priceBars[i].Low)
{
// rising so its a buy opportunity
ps = ProfitSide.Buy;
}
else if (priceBars[i - scanSize].Low > priceBars[i].High)
{
// fallins so a sell opportunity
ps = ProfitSide.Sell;
}
for (int j = i - scanSize; j < i; j++)
{
// if profit side has been set to ignore dont analyse any more
if (ps != ProfitSide.Ignore)
{
// check still moving in the right direction
decimal diff = 0.0m;
if (ps == ProfitSide.Buy)
{
diff = priceBars[i - scanSize].High - priceBars[j].Low;
if (diff > stops)
{
// Stopped out so ignore this bar as a buy opportunity
ps = ProfitSide.Ignore;
continue;
}
}
else if (ps == ProfitSide.Sell)
{
diff = priceBars[j].High - priceBars[i - scanSize].Low;
if (diff > stops)
{
// Stopped out so ignore this bar as a sell opportunity
ps = ProfitSide.Ignore;
continue;
}
}
}
}
// Finished scanning the bars can now see if there was
// a buy or sell opportunity
decimal profit = 0.0m;
int row = i - scanSize;
if (row >= offset)
{
row -= offset;
if (row < count)
{
winners[row] = 1;
if (ps == ProfitSide.Buy)
{
profit = priceBars[i].Low - priceBars[i - scanSize].High;
if (profit >= profitTarget)
{
winners[row] = 3;
}
}
else if (ps == ProfitSide.Sell)
{
profit = priceBars[i - scanSize].Low - priceBars[i].High;
if (profit >= profitTarget)
{
winners[row] = 2;
}
}
}
else
{
break;
}
}
}
}
for (int i = 0; i < winners.Length; i++)
{
if (winners[i] == 0)
{
winners[i] = 1;
}
}
return winners.ToArray();
}
/// <summary>
/// Takes a set of real time curve values and collapses them into
/// discrete time bars using the last value
/// </summary>
/// <param name='curveValues'>
/// Curve values.
/// </param>
/// <param name='inValues'>
/// In values.
/// </param>
/// <param name='timeGranularity'>
/// Time granularity/interval of bar
/// </param>
public static void TimeBaseCollapse(Dictionary<long, Dictionary<string, K2DataObjects.CurveValue>> curveValues, K2DataObjects.CurveValue[] inValues, long timeGranularity)
{
try
{
foreach (var cv in inValues)
{
if (cv.Value >= 0m)
{
long roundedTIme = RoundTimeStamp(cv.TimeStamp, timeGranularity);
if (!curveValues.ContainsKey(roundedTIme))
{
curveValues.Add(roundedTIme, new Dictionary<string, K2DataObjects.CurveValue>());
}
if (curveValues[roundedTIme].ContainsKey(cv.HeaderID))
{
curveValues[roundedTIme][cv.HeaderID] = cv;
}
else
{
curveValues[roundedTIme].Add(cv.HeaderID, cv);
}
}
}
}
catch (Exception ex)
{
}
}
private void CopyBarDataDelta(double[,] featureSet, K2DataObjects.PriceBar[] bars, long srcIndex, long targetIndex)
{
featureSet[targetIndex, 0] = (double)bars[srcIndex].TimeStamp;
featureSet[targetIndex, 1] = (double)bars[srcIndex].ItemSize;
if (srcIndex > 0)
{
featureSet[targetIndex, 2] = (double)bars[srcIndex].High - (double)bars[srcIndex - 1].High;
featureSet[targetIndex, 3] = (double)bars[srcIndex].Low - (double)bars[srcIndex - 1].Low;
featureSet[targetIndex, 4] = (double)bars[srcIndex].Open - (double)bars[srcIndex - 1].Open;
featureSet[targetIndex, 5] = (double)bars[srcIndex].Close - (double)bars[srcIndex - 1].Close;
featureSet[targetIndex, 6] = (double)bars[srcIndex].Avg.Value - (double)bars[srcIndex - 1].Avg.Value;
featureSet[targetIndex, 7] = (double)bars[srcIndex].Volume.Value - (double)bars[srcIndex - 1].Volume.Value;
featureSet[targetIndex, 8] = (double)bars[srcIndex].BidVolume.Value - (double)bars[srcIndex - 1].BidVolume.Value;
featureSet[targetIndex, 9] = (double)bars[srcIndex].AskVolume.Value - (double)bars[srcIndex - 1].AskVolume.Value;
}
else
{
featureSet[targetIndex, 2] = 0.0;
featureSet[targetIndex, 3] = 0.0;
featureSet[targetIndex, 4] = 0.0;
featureSet[targetIndex, 5] = 0.0;
featureSet[targetIndex, 6] = 0.0;
featureSet[targetIndex, 7] = 0.0;
featureSet[targetIndex, 8] = 0.0;
featureSet[targetIndex, 9] = 0.0;
}
}
