public void Test_Create_Child_ActivityDetail()
{
ChildActivityDetail cg = new ChildActivityDetail()
{
EventDate = DateTime.Today,
StartTime = DateTime.Now,
Child = new ChildDetail()
{
Key = 1
},
Activity = new ChildActivityType()
{
Key = 3
}
};
NHibernateRepository ds = new NHibernateRepository(_sessionFactory);
using (ctx = ctx.Start())
{
ctx.BeginTransaction();
ds.Add(cg);
ctx.Commit();
Console.WriteLine(cg.Key);
Assert.That(cg.Key > 0);
}
}
public SettingsViewModel(IDBContext context) : base(null)
{
_context = context;
AssumedInterestRate = Properties.Settings.Default.assumedInterestRate;
StatementSaveLocation = Properties.Settings.Default.statementSaveLocation;
LogLocation = Properties.Settings.Default.logLocation;
FlexID = Properties.Settings.Default.flexID;
FlexToken = Properties.Settings.Default.flexToken;
PreventDuplicateImports = Properties.Settings.Default.preventDuplicateImports;
OptionsCapitalUsageMultiplier = Properties.Settings.Default.optionsCapitalUsageMultiplier;
TotalCapitalAlwaysUsesAllAccounts = Properties.Settings.Default.totalCapitalAlwaysUsesAllAccounts;
//QDMS stuff
QdmsAllowFreshData = Properties.Settings.Default.qdmsAllowFreshData;
QdmsHost = Properties.Settings.Default.qdmsHost;
QdmsRealTimeRequestPort = Properties.Settings.Default.qdmsRealTimeRequestPort;
QdmsRealTimePublishPort = Properties.Settings.Default.qdmsRealTimePublishPort;
QdmsInstrumentServerPort = Properties.Settings.Default.qdmsInstrumentServerPort;
QdmsHistoricalDataPort = Properties.Settings.Default.qdmsHistoricalDataPort;
AllowExternalDataSource = Properties.Settings.Default.allowExternalDataSource;
//MySQL
MySqlHost = Properties.Settings.Default.mySqlHost;
MySqlUsername = Properties.Settings.Default.mySqlUsername;
//SQL Server
SqlServerUseWindowsAuthentication = Properties.Settings.Default.sqlServerUseWindowsAuthentication;
SqlServerUsername = Properties.Settings.Default.sqlServerUsername;
SqlServerHost = Properties.Settings.Default.sqlServerHost;
//db selection
if(Properties.Settings.Default.databaseType == "MySql")
{
MySqlSelected = true;
}
else if (Properties.Settings.Default.databaseType == "SqlServer")
{
SqlServerSelected = true;
}
DatasourcePreferences = new ObservableCollection<DatasourcePreference>(
context
.DatasourcePreferences
.ToList()
.OrderBy(x => (int)x.AssetClass)
.Select(x => new DatasourcePreference { AssetClass = x.AssetClass, Datasource = x.Datasource })
);
Datasources = new ObservableCollection<string>(
new[] {
"Yahoo",
"Interactive Brokers",
"Quandl",
"FRED",
"Google"
});
}
/// <summary>
/// Returns all trades that have any of the tags provided
/// </summary>
/// <param name="tags"></param>
/// <param name="context"></param>
/// <returns></returns>
public static List<int> FilterByTags(List<Tag> tags, IDBContext context)
{
if (tags == null) throw new ArgumentNullException("tags");
if (context == null) throw new ArgumentNullException("context");
var trades = context.Trades.Include(x => x.Tags).ToList();
return trades.Where(x => x.Tags.Intersect(tags).Any()).Select(x => x.ID).ToList();
}
public static List<int> FilterByStrategies(List<Strategy> strategies, IDBContext context)
{
if (strategies == null) throw new ArgumentNullException("strategies");
if (context == null) throw new ArgumentNullException("context");
var trades = context.Trades.Include(x => x.Strategy).ToList();
return trades.Where(x => strategies.Contains(x.Strategy)).Select(x => x.ID).ToList();
}
public void Setup()
{
_sessionFactory = Fluently.Configure()
.Database(MySQLConfiguration.Standard.ConnectionString(ConfigurationManager.ConnectionStrings["PrimaryDB"].ConnectionString).ShowSql())
.Mappings(m => m.FluentMappings.AddFromAssemblyOf<ChildGroupMap>())
.ExposeConfiguration(c => c.SetProperty("current_session_context_class", "thread_static"))
.BuildSessionFactory();
ctx = new NHibernateContext(_sessionFactory);
}
public TradeFilterSettings(IDBContext context)
{
//set dates
var firstES = context.EquitySummaries.OrderBy(x => x.Date).FirstOrDefault();
From = firstES == null ? new DateTime(1, 1, 1) : firstES.Date;
var lastES = context.EquitySummaries.OrderByDescending(x => x.Date).FirstOrDefault();
To = lastES == null ? DateTime.Now : lastES.Date;
}
public StrategiesPageViewModel(IDBContext context, IDialogCoordinator dialogService, MainViewModel parent)
: base(dialogService)
{
Context = context;
Parent = parent;
StrategiesSource = new CollectionViewSource();
StrategiesSource.Source = Context.Strategies.Local;
CreateCommands();
}
public TagsPageViewModel(IDBContext context, IDialogCoordinator dialogService, MainViewModel parent)
: base(dialogService)
{
Context = context;
Parent = parent;
TagsSource = new CollectionViewSource();
TagsSource.Source = Context.Tags.Local;
TagsSource.View.SortDescriptions.Add(new SortDescription("Name", ListSortDirection.Ascending));
CreateCommands();
}
public StatementHandler(IDBContext context, IDialogCoordinator dialogService, IDataSourcer dataSourcer, ITradesRepository repository, IMainViewModel mainVm)
{
_dialogService = dialogService;
AssembleComponents();
DownloaderNames = StatementDownloaders.Select(x => x.Metadata.Name).ToList();
ParserNames = StatementParsers.Select(x => x.Metadata.Name).ToList();
_tradeRepository = repository;
_mainVm = mainVm;
}
public DataSourcer(IDBContext context, IExternalDataSource externalDataSource, bool allowExternalDataSource = false)
{
_useExternalDataSource = allowExternalDataSource && externalDataSource != null;
if (_useExternalDataSource)
{
ExternalDataSource = externalDataSource;
}
_dataCache = new Dictionary<int, List<OHLCBar>>();
Context = context;
}
public FXTransactionsPageViewModel(IDBContext context, IDataSourcer datasourcer, IDialogCoordinator dialogService, IMainViewModel mainVm)
: base(dialogService)
{
Context = context;
_mainVm = mainVm;
TradesRepository = mainVm.TradesRepository;
FXTransactions = new CollectionViewSource();
FXTransactions.Source = Context.FXTransactions.Local;
FXTransactions.View.SortDescriptions.Add(new SortDescription("DateTime", ListSortDirection.Descending));
CreateCommands();
}
public OpenPositionsPageViewModel(IDBContext context, IDialogCoordinator dialogService)
: base(dialogService)
{
UnrealizedPnL = new ObservableCollection<Tuple<string, decimal>>();
OpenPositions = new ObservableCollection<OpenPosition>();
FXPositions = new ObservableCollection<FXPosition>();
Accounts = new ObservableCollection<Account>();
Accounts.Add(new Account { ID = -1, AccountId = "All" });
CreatePlotModel();
SelectedAccount = Accounts.First();
}
public BenchmarksPageViewModel(IDBContext context, IDialogCoordinator dialogService, IDataSourcer datasourcer, IMainViewModel mainVm)
: base(dialogService)
{
Context = context;
Datasourcer = datasourcer;
_mainVm = mainVm;
ExternalInstruments = new ObservableCollection<KeyValuePair<string, int?>>();
BenchmarksSource = new CollectionViewSource();
BenchmarksSource.Source = Context.Benchmarks.Local;
Context.Tags.Load();
CreateCommands();
}
public TradesPageViewModel(IDBContext context, IDialogCoordinator dialogService, IDataSourcer datasourcer, MainViewModel parent)
: base(dialogService)
{
Context = context;
Parent = parent;
Datasourcer = datasourcer;
TradesRepository = parent.TradesRepository;
TradesSource = new CollectionViewSource();
TradesSource.Source = Context.Trades.Local;
TradesSource.View.SortDescriptions.Add(new SortDescription("DateOpened", ListSortDirection.Descending));
Strategies = new ObservableCollection<Strategy>();
CreateCommands();
}
public OrdersPageViewModel(IDBContext context, IDialogCoordinator dialogService, IDataSourcer datasourcer, IMainViewModel parent)
: base(dialogService)
{
Context = context;
Parent = parent;
Datasourcer = datasourcer;
TradesRepository = parent.TradesRepository;
OrdersSource = new CollectionViewSource();
OrdersSource.Source = Context.Orders.Local;
OrdersSource.SortDescriptions.Add(new SortDescription("TradeDate", ListSortDirection.Descending));
ExecutionStatsGenerator = new ExecutionStatsGenerator(datasourcer);
CreateCommands();
}
public TradeWindow(Trade trade, IDBContext context, IDataSourcer dataSourcer)
{
Trade = trade;
_context = context;
InitializeComponent();
ViewModel = new TradeViewModel(trade, dataSourcer, context);
DataContext = ViewModel;
InitializeFontSizes();
FontFamilyComboBox.ItemsSource = Fonts.SystemFontFamilies;
FontSizeComboBox.ItemsSource = FontSizes;
//load the notes
LoadNotes();
}
public SettingsWindow(IDBContext context)
{
_context = context;
InitializeComponent();
ViewModel = new SettingsViewModel(context);
DataContext = ViewModel;
//have to load the passwords here
//because binding securely is basically impossible
MySqlPasswordBox.Password = DBUtils.Unprotect(Properties.Settings.Default.mySqlPassword);
SqlitePasswordBox.Password = DBUtils.Unprotect(Properties.Settings.Default.sqlitePassword);
SqlServerPassword.Password = DBUtils.Unprotect(Properties.Settings.Default.sqlServerPassword);
//hiding the tab headers
Style s = new Style();
s.Setters.Add(new Setter(VisibilityProperty, Visibility.Collapsed));
DbSettingsTabCtrl.ItemContainerStyle = s;
}
public TradeViewModel(Trade trade, IDataSourcer dataSourcer, IDBContext context) : base(null)
{
context.Trades
.Where(x => x.ID == trade.ID)
.Include(x => x.Strategy)
.Include(x => x.Orders)
.Include("Orders.Instrument")
.Include("Orders.Currency")
.Include(x => x.CashTransactions)
.Include("CashTransactions.Instrument")
.Include("CashTransactions.Currency")
.Include(x => x.FXTransactions)
.Include("FXTransactions.FunctionalCurrency")
.Include("FXTransactions.FXCurrency")
.Load();
Trade = trade;
Tracker = TradeSim.SimulateTrade(trade, context, dataSourcer, Properties.Settings.Default.optionsCapitalUsageMultiplier);
}
public void RunTradeScripts(List<Trade> trades, List<Strategy> strategies, List<Tag> tags, IDBContext context)
{
var scripts = ScriptLoader.LoadTradeScripts(_repository, strategies, tags);
if (scripts == null) return;
foreach (TradeScriptBase script in scripts)
{
try
{
script.ProcessTrades(trades);
}
catch (Exception ex)
{
_logger.Log(LogLevel.Error, "User script {0} generated an exception: ", script.GetType().Name);
_logger.Log(LogLevel.Error, ex);
}
}
context.SaveChanges();
}
public void RunOrderScripts(List<Order> orders, IDBContext context)
{
var scripts = ScriptLoader.LoadOrderScripts(_repository);
if (scripts == null) return;
foreach(OrderScriptBase script in scripts)
{
try
{
script.ProcessOrders(orders);
}
catch (Exception ex)
{
_logger.Log(LogLevel.Error, "User script {0} generated an exception: ", script.GetType().Name);
_logger.Log(LogLevel.Error, ex);
}
}
context.SaveChanges();
}
public MainViewModel(IDBContext context, IDataSourcer datasourcer, IDialogCoordinator dialogService)
: base(dialogService)
{
Context = context;
Datasourcer = datasourcer;
TradesRepository = new TradesRepository(context, datasourcer, Properties.Settings.Default.optionsCapitalUsageMultiplier);
StatementHandler = new StatementHandler(
context,
dialogService,
datasourcer,
TradesRepository,
this);
CreateSubViewModels();
SelectedPageViewModel = OpenPositionsPageViewModel;
CreateCommands();
ScriptRunner = new ScriptRunner(TradesRepository);
}
internal ProcedureContainer(IDBContext context)
{
Context = context;
}
private static void ParseCFDCharges(XContainer xml, IDBContext context, bool skipLastDateCheck, DateTime lastDate, Account account)
{
var cfdTransactionsMapper = new Mapper<CashTransaction>(xml.Descendants("CFDCharge"));
cfdTransactionsMapper.SetAttributeMap("total", "Amount");
cfdTransactionsMapper.SetAttributeMap("date", "TransactionDate", "yyyy-MM-dd");
List<CashTransaction> cfdCharges = cfdTransactionsMapper.ParseAll();
var instruments = context.Instruments.ToList();
var currencies = context.Currencies.ToList();
foreach (CashTransaction i in cfdCharges)
{
i.Type = "CFD Charge";
if (skipLastDateCheck || i.TransactionDate > lastDate)
{
i.Account = account;
i.Currency = currencies.FirstOrDefault(x => x.Name == i.CurrencyString);
i.Instrument = instruments.FirstOrDefault(x => x.ConID == i.ConID);
context.CashTransactions.Add(i);
}
}
context.SaveChanges();
//<CFDCharge accountId="U1066712F" currency="USD" assetCategory="CFD" fxRateToBase="1"
//symbol="--" description="--" conid="--" securityID="--" securityIDType="--" cusip="--"
//isin="--" underlyingConid="--" underlyingSymbol="--" issuer="--" date="2013-01-03" received="0"
//paid="-1.27" total="-1.27" transactionID="3283049378" />
}
private static void ParseOrders(XContainer xml, IDBContext context, bool skipLastDateCheck, Account account)
{
if (!xml.Descendants("Trades").Any()) return;
var ordersMapper = new Mapper<Order>(xml.Descendants("Trades").First().Descendants("Order"));
List<Order> orders = ordersMapper.ParseAll();
DateTime lastDate = context.Orders.Any(x => x.AccountID == account.ID)
? context.Orders.Where(x => x.AccountID == account.ID).Max(x => x.TradeDate)
: new DateTime(1, 1, 1);
var instruments = context.Instruments.ToList();
var currencies = context.Currencies.ToList();
//then add the new ones
foreach (Order order in orders)
{
if (order.TradeDate > lastDate || skipLastDateCheck)
{
order.IsReal = true;
if(order.AssetCategory == AssetClass.Cash)
{
//These are currency trades. But currencies aren't provided in the SecuritiesInfos
//So we have to hack around it and add the currency as an instrument "manually" if it's not in yet
order.Instrument = TryAddAndGetCurrencyInstrument(order, context);
}
else
{
order.Instrument = instruments.FirstOrDefault(x => x.ConID == order.ConID);
}
order.Account = account;
order.Currency = currencies.FirstOrDefault(x => x.Name == order.CurrencyString);
order.CommissionCurrency = currencies.FirstOrDefault(x => x.Name == order.CommissionCurrencyString);
context.Orders.Add(order);
}
}
context.SaveChanges();
//<Order accountId="U1066712" currency="USD" assetCategory="STK" fxRateToBase="1" symbol="AAPL"
//description="APPLE INC" conid="265598" securityID="" securityIDType="" cusip="" isin=""
//underlyingConid="" underlyingSymbol="" issuer="" tradeID="--" reportDate="20140325" tradeDate="20140325"
//tradeTime="093002" settleDateTarget="20140328" transactionType="--" exchange="--" quantity="-48"
//tradePrice="541.37" multiplier="1" tradeMoney="-25985.76" proceeds="25985.76" taxes="0" ibCommission="-1.574285"
//ibCommissionCurrency="USD" closePrice="544.99" openCloseIndicator="C" notes="C" cost="-25877.8" fifoPnlRealized="106.385715"
//mtmPnl="-173.76" origTradePrice="--" origTradeDate="--" origTradeID="--" origOrderID="--" strike="" expiry="" putCall=""
//buySell="SELL" ibOrderID="537171278" ibExecID="--" brokerageOrderID="--" orderReference="--" volatilityOrderLink="--"
//orderPlacementTime="--" clearingFirmID="--" exchOrderId="--" extExecID="--" orderTime="20140325;093002" openDateTime="--"
//holdingPeriodDateTime="--" whenRealized="--" whenReopened="--" levelOfDetail="ORDER" changeInPrice="--" changeInQuantity="--"
//netCash="25984.185715" orderType="LMT" />
}
public VipProductFacade(IDBContext dbContext)
{
_db = dbContext;
_vipProductService = new VipProductService(this._db);
}
public UserRepository(IDBContext dbContext) : base(dbContext)
{
}
public PlayerTest(DbFixture fixture)
{
serviceProvider = fixture.ServiceProvider;
playerService = serviceProvider.GetService <IPlayerService>();
dbContext = serviceProvider.GetService <IDBContext>();
}
public WishlistRepository(IDBContext dBContext, IBooksRepository booksRepository)
{
_dbContext = dBContext;
_booksRepository = booksRepository;
}
public SettingsViewModel(IDBContext context) : base(null)
{
_context = context;
AssumedInterestRate = Properties.Settings.Default.assumedInterestRate;
StatementSaveLocation = Properties.Settings.Default.statementSaveLocation;
LogLocation = Properties.Settings.Default.logLocation;
FlexID = Properties.Settings.Default.flexID;
FlexToken = Properties.Settings.Default.flexToken;
PreventDuplicateImports = Properties.Settings.Default.preventDuplicateImports;
OptionsCapitalUsageMultiplier = Properties.Settings.Default.optionsCapitalUsageMultiplier;
TotalCapitalAlwaysUsesAllAccounts = Properties.Settings.Default.totalCapitalAlwaysUsesAllAccounts;
//QDMS stuff
QdmsAllowFreshData = Properties.Settings.Default.qdmsAllowFreshData;
QdmsHost = Properties.Settings.Default.qdmsHost;
QdmsRealTimeRequestPort = Properties.Settings.Default.qdmsRealTimeRequestPort;
QdmsRealTimePublishPort = Properties.Settings.Default.qdmsRealTimePublishPort;
QdmsInstrumentServerPort = Properties.Settings.Default.qdmsInstrumentServerPort;
QdmsHistoricalDataPort = Properties.Settings.Default.qdmsHistoricalDataPort;
AllowExternalDataSource = Properties.Settings.Default.allowExternalDataSource;
//MySQL
MySqlHost = Properties.Settings.Default.mySqlHost;
MySqlUsername = Properties.Settings.Default.mySqlUsername;
//SQL Server
SqlServerUseWindowsAuthentication = Properties.Settings.Default.sqlServerUseWindowsAuthentication;
SqlServerUsername = Properties.Settings.Default.sqlServerUsername;
SqlServerHost = Properties.Settings.Default.sqlServerHost;
//db selection
if (Properties.Settings.Default.databaseType == "MySql")
{
MySqlSelected = true;
}
else if (Properties.Settings.Default.databaseType == "SqlServer")
{
SqlServerSelected = true;
}
DatasourcePreferences = new ObservableCollection <DatasourcePreference>(
context
.DatasourcePreferences
.ToList()
.OrderBy(x => (int)x.AssetClass)
.Select(x => new DatasourcePreference {
AssetClass = x.AssetClass, Datasource = x.Datasource
})
);
Datasources = new ObservableCollection <string>(
new[] {
"Yahoo",
"Interactive Brokers",
"Quandl",
"FRED",
"Google"
});
}
public Service(IDBContext context)
{
Context = context;
}
public WorkshopService(IDBContext dbContext)
{
_dbContext = dbContext;
}
public EmployeeGroup_SystemFunctionRepository(IDBContext dbContext) : base(dbContext)
{
}
public AgentUtility(IDBContext eddsDbContext, ServiceFactory serviceFactory)
{
_eddsDbContext = eddsDbContext;
_serviceFactory = serviceFactory;
}
public MatchService(ILogger loger, IDBContext dBContext)
{
_loger = loger;
_dBContext = dBContext;
}
public DeliveryController(IDBContext icontext)
{
db = icontext;
}
public PriceDataRepository(IDBContext <Price> dbContext) : base(dbContext)
{
}
public MongoPlayerService(IDBContext context)
{
this.context = context;
}
public CustomerContext(IDBContext dB)
{
_db = dB;
}
public UserStatsRepository(IDBContext context) : base(context)
{
}
public override void Execute()
{
int contador = 0;
//Get the current Agent artifactID
Int32 agentArtifactID = this.AgentID;
//Get a dbContext for the EDDS database
IDBContext eddsDBContext = this.Helper.GetDBContext(-1);
List<int> worksapcesID = new List<int>();
Comment comment = new Comment();
try
{
using (IRSAPIClient proxy =
Helper.GetServicesManager().CreateProxy<IRSAPIClient>(ExecutionIdentity.System))
{
RelativityAppCore.BLL.Service.RSAPIService.CommentRSAPIService commentRSAPIService = new CORE.BLL.Service.RSAPIService.CommentRSAPIService(proxy);
IDBContext DBContext = this.Helper.GetDBContext(-1);
DataRowCollection data = DBContext.ExecuteSqlStatementAsDataTable(Queries.GetWorkspacesWithApp).Rows;
RaiseMessage("Find for the workspaces with the application", 1);
foreach (var item in data[0].ItemArray)
{
worksapcesID.Add((int)item);
}
foreach (var item in worksapcesID)
{
proxy.APIOptions.WorkspaceID = item;
DTOs.Query<DTOs.RDO> query = new DTOs.Query<DTOs.RDO>();
DTOs.QueryResultSet<DTOs.RDO> results = new DTOs.QueryResultSet<DTOs.RDO>();
query.ArtifactTypeGuid = new Guid(comment.ARTIFACT_TYPE);
query.Fields = DTOs.FieldValue.AllFields;
// query.Condition = new BooleanCondition(new Guid(guidSet), BooleanConditionEnum.EqualTo, false);
try
{
results = proxy.Repositories.RDO.Query(query);
foreach (var c in results.Results)
{
RaiseMessage($"verifying if the comment: {c.Artifact.ArtifactID} already has the thumnails", 1);
DTOs.RDO commentDto = new DTOs.RDO(c.Artifact.ArtifactID);
commentDto.ArtifactTypeGuids.Add(new Guid(comment.ARTIFACT_TYPE));
commentDto.Fields = DTOs.FieldValue.AllFields;
commentDto.Fields.Add(new DTOs.FieldValue(new Guid(guidSet)));
commentDto = proxy.Repositories.RDO.ReadSingle(c.Artifact.ArtifactID);
//bool fieldValue = (bool)commentDto[new Guid(guidSet)].Value;
string image = (string)commentDto[new Guid(Image_guid_field)].Value;
if (!string.IsNullOrEmpty(image))
{
RaiseMessage($"Creating Thumbnails for the comment {c.Artifact.ArtifactID}", 1);
string thumbnail = getImage(c.Artifact.ArtifactID, this.Helper.GetDBContext(proxy.APIOptions.WorkspaceID));
commentDto.Fields.Add(new DTOs.FieldValue(new Guid(thumbnailsImage), thumbnail));
commentDto.Fields.Add(new DTOs.FieldValue(new Guid(guidSet), true));
proxy.Repositories.RDO.UpdateSingle(commentDto);
}
else
{
contador = contador + 1;
commentDto.Fields.Add(new DTOs.FieldValue(new Guid(guidSet), false));
proxy.Repositories.RDO.UpdateSingle(commentDto);
}
}
}
catch (Exception)
{
throw;
}
}
}
RaiseMessage($"There are {contador} comments without thumbnail", 1);
}
catch (System.Exception ex)
{
//Your Agent caught an exception
this.RaiseError(ex.Message, ex.Message);
}
}
public ReportProblemRepository(IDBContext dbContext)
: base(dbContext)
{
}
public RawMaterialPurchaseHistoryModel(IDBContext db) : base(db)
{
InventorySums = new Dictionary <RawMaterialItem, double>();
}
public UnitOfWork(IDBContext context)
{
Context = context;
_objects = new HashSet <BaseModel>();
_operations = new List <IOperation>();
}
private static void ParseSecuritiesInfo(XContainer xml, IDBContext context)
{
var instrumentMapper = new Mapper<Instrument>(xml.Descendants("SecurityInfo"));
List<Instrument> instruments = instrumentMapper.ParseAll();
foreach (Instrument i in instruments)
{
if (context.Instruments.Count(x => x.ConID == i.ConID) == 0)
{
context.Instruments.Add(i);
context.SaveChanges();
}
}
//<SecurityInfo @assetCategoryassetCategory="STK" symbol="AAPL" description="APPLE INC"
//conid="265598" securityID="" securityIDType="" cusip="" isin="" underlyingConid=""
//underlyingSymbol="" issuer="" multiplier="1" expiry="" strike="" maturity="-" issueDate="" />
}
private static Instrument TryAddAndGetCurrencyInstrument(Order order, IDBContext context)
{
var instrument =
context
.Instruments
.FirstOrDefault(x => x.AssetCategory == AssetClass.Cash && x.Symbol == order.SymbolString);
if (instrument != null) return instrument; //it's already in the DB, no need to add it
//otherwise construct a new instrument, add it, and return it.
instrument = new Instrument
{
Symbol = order.SymbolString,
UnderlyingSymbol = order.SymbolString,
Description = order.SymbolString,
ConID = order.ConID,
AssetCategory = AssetClass.Cash,
Multiplier = 1
};
context.Instruments.Add(instrument);
context.SaveChanges();
return instrument;
}
public ChildController(IDBContext ctx, IChildRepository cgDataService)
{
this.ctx = ctx;
this.cgDataService = cgDataService;
}
private static void ParseCashTransactions(XContainer xml, IDBContext context, bool skipLastDateCheck, DateTime lastDate, Account account)
{
var cashTransactionsMapper = new Mapper<CashTransaction>(xml.Descendants("CashTransaction"));
List<CashTransaction> cashTransactions = cashTransactionsMapper.ParseAll();
var instruments = context.Instruments.ToList();
var currencies = context.Currencies.ToList();
foreach (CashTransaction i in cashTransactions)
{
if (skipLastDateCheck || i.TransactionDate > lastDate)
{
i.Account = account;
i.Currency = currencies.FirstOrDefault(x => x.Name == i.CurrencyString);
i.Instrument = instruments.FirstOrDefault(x => x.ConID == i.ConID);
context.CashTransactions.Add(i);
}
}
context.SaveChanges();
//<CashTransaction accountId="U1066712" currency="CAD" assetCategory="STK" fxRateToBase="0.99717"
//symbol="XRE" description="XRE() DIVIDEND .0615 CAD PER SHARE - CA TAX" conid="74580643" securityID=""
//securityIDType="" cusip="" isin="" underlyingConid="" underlyingSymbol="" issuer="" dateTime="2012-07-31"
//amount="-6.92" type="Withholding Tax" tradeID="" code="" />
}
public async Task RunTradeScripts(List <Trade> trades, List <Strategy> strategies, List <Tag> tags, IDBContext context)
{
var scripts = ScriptLoader.LoadTradeScripts(_repository, strategies, tags);
if (scripts == null)
{
return;
}
foreach (TradeScriptBase script in scripts)
{
try
{
script.ProcessTrades(trades);
}
catch (Exception ex)
{
_logger.Log(LogLevel.Error, "User script {0} generated an exception: ", script.GetType().Name);
_logger.Log(LogLevel.Error, ex);
}
}
await context.SaveChangesAsync().ConfigureAwait(true);
}
public LeavingMsgService(IDBContext dbContext, IDataRepository dataRepository, ISysOperLogService sysOperLogService)
{
_dbContext = dbContext;
_dataRepository = dataRepository;
_sysOperLogService = sysOperLogService;
}
public void CopyTo(IDBContext myDBContext)
{
var realContext = (DBContext)myDBContext;
realContext._DBIndexManager = _DBIndexManager;
realContext._DBObjectCache = _DBObjectCache;
realContext._DBObjectManager = _DBObjectManager;
realContext._DBPluginManager = _DBPluginManager;
realContext._DBSettingsManager = _DBSettingsManager;
realContext._DBTypeManager = _DBTypeManager;
realContext._SessionSettings = _SessionSettings;
}
public Repository(IDBContext context)
{
_context = context;
}
public EmployeeGroupRepository(IDBContext dbContext) : base(dbContext)
{
}
public ScriptingViewModel(IDBContext context, IDialogCoordinator dialogService)
{
Scripts = new ObservableCollection<UserScript>(context.UserScripts.ToList());
_dialogService = dialogService;
_dbContext = context;
Compile = new RelayCommand(RunCompile);
Open = new RelayCommand<UserScript>(OpenScript);
NewScript = new RelayCommand(CreateNewScript);
DeleteScript = new RelayCommand(DeleteSelectedScript);
Save = new RelayCommand(SaveScripts);
AddReference = new RelayCommand(AddReferencedAssembly);
RemoveReference = new RelayCommand<string>(RemoveReferencedAssembly);
LaunchHelp = new RelayCommand(() => System.Diagnostics.Process.Start("http://qusma.com/qpasdocs/index.php/Scripting"));
}
public ILogDBSession CreateSession(string userId, int moduleId, int functionId, IDBContext dbContext)
{
return(new LogDBSession(userId, moduleId, functionId, dbContext));
}
public UserController(IDBContext _sqlDBContext)
{
sqlDBContext = _sqlDBContext;
}
public HorseDataRepository(IDBContext <Horse> dbContext) : base(dbContext)
{
}
public static List<Trade> Filter(List<Tag> selectedTags, List<Strategy> selectedStrategies, List<Instrument> selectedInstruments, IDBContext context, TradeFilterSettings settings)
{
if (context == null) throw new ArgumentNullException("context");
//filter dates
var trades = context
.Trades
.Include(x => x.Tags)
.Include(x => x.Strategy)
.Include(x => x.Orders)
.Include(x => x.CashTransactions)
.Where(x => x.DateClosed == null || x.DateClosed > settings.From)
.Where(x => x.DateOpened < settings.To)
.ToList();
//filter open if required
if (settings.ClosedTradesOnly)
{
trades = trades.Where(x => !x.Open).ToList();
}
//filter by strategy
switch (settings.StrategyFilterMethod)
{
case FilterMethod.Any:
trades = trades.Where(x => selectedStrategies.Contains(x.Strategy)).ToList();
break;
case FilterMethod.Exclude:
trades = trades.Where(x => !selectedStrategies.Contains(x.Strategy)).ToList();
break;
}
//filter by tags
switch (settings.TagFilterMethod)
{
case FilterMethod.Any:
trades = trades.Where(x => selectedTags.Intersect(x.Tags).Any()).ToList();
break;
case FilterMethod.All:
trades = trades.Where(x => selectedTags.Intersect(x.Tags).Count() == selectedTags.Count).ToList();
break;
case FilterMethod.Exclude:
trades = trades.Where(x => !selectedTags.Intersect(x.Tags).Any()).ToList();
break;
}
List<int> selectedInstrumentIDs = selectedInstruments.Select(x => x.ID).ToList();
//filter by instrument
switch (settings.InstrumentFilterMethod)
{
case FilterMethod.Any:
trades = trades.Where(x =>
x.Orders.Select(y => y.InstrumentID).Intersect(selectedInstrumentIDs).Any() ||
x.CashTransactions.Where(y => y.InstrumentID.HasValue).Select(y => y.InstrumentID.Value).Intersect(selectedInstrumentIDs).Any())
.ToList();
break;
case FilterMethod.All:
trades = trades.Where(x =>
x.Orders.Select(y => y.InstrumentID).Intersect(selectedInstrumentIDs).Union(
x.CashTransactions.Where(y => y.InstrumentID.HasValue).Select(y => y.InstrumentID.Value)).Count()
== selectedInstrumentIDs.Count)
.ToList();
break;
case FilterMethod.Exclude:
trades = trades.Where(x =>
!x.Orders.Select(y => y.InstrumentID).Intersect(selectedInstrumentIDs).Any() &&
!x.CashTransactions.Where(y => y.InstrumentID.HasValue).Select(y => y.InstrumentID.Value).Intersect(selectedInstrumentIDs).Any())
.ToList();
break;
}
return trades.ToList();
}
public static async Task <TradeTracker> SimulateTrade(Trade trade, IDBContext context, IDataSourcer dataSourcer, decimal optionsCapitalUsageMultiplier)
{
var tracker = new TradeTracker(trade, optionsCapitalUsageMultiplier);
//starting and ending dates
DateTime startDate = trade.DateOpened;
DateTime endDate;
if (!trade.Open && trade.DateClosed != null)
{
endDate = trade.DateClosed.Value.Date;
}
else
{
var lastSummary = context.EquitySummaries.OrderByDescending(x => x.Date).First();
endDate = lastSummary.Date.Date;
}
var orders = trade.Orders == null
? new List <Order>()
: trade.Orders.OrderBy(x => x.TradeDate).ToList();
var cashTransactions = trade.CashTransactions == null
? new List <CashTransaction>()
: trade.CashTransactions.OrderBy(x => x.TransactionDate).ToList();
var fxTransactions = trade.FXTransactions == null
? new List <FXTransaction>()
: trade.FXTransactions.OrderBy(x => x.DateTime).ToList();
//Grab the data
Dictionary <int, TimeSeries> data = await GetInstrumentData(trade, dataSourcer, startDate, endDate).ConfigureAwait(true);
Dictionary <int, TimeSeries> fxData = GetFXData(trade, context);
DateTime currentDate = startDate.Date;
//Loop through the dates
while (currentDate <= endDate)
{
//Progress time series to current date
foreach (TimeSeries ts in data.Values)
{
ts.ProgressTo(currentDate);
}
foreach (TimeSeries ts in fxData.Values)
{
ts.ProgressTo(currentDate);
}
//Add orders
while (orders.Count > 0 && orders[0].TradeDate.Date <= currentDate)
{
tracker.AddOrder(orders[0]);
orders.RemoveAt(0);
}
//Add cash transactions
while (cashTransactions.Count > 0 && cashTransactions[0].TransactionDate.Date <= currentDate)
{
tracker.AddCashTransaction(cashTransactions[0]);
cashTransactions.RemoveAt(0);
}
//add fx transactions
while (fxTransactions.Count > 0 && fxTransactions[0].DateTime.Date <= currentDate)
{
tracker.AddFXTransaction(fxTransactions[0]);
fxTransactions.RemoveAt(0);
}
tracker.Update(currentDate, data, fxData);
if (orders.Count == 0 && cashTransactions.Count == 0 && fxTransactions.Count == 0 && !tracker.Open)
{
break;
}
currentDate = currentDate.AddDays(1);
}
return(tracker);
}
public OrderItemRepository(IDBContext dbContext) : base(dbContext)
{
}
public WarehouseTypeRepository(IDBContext dbContext) : base(dbContext)
{
}
