public void ConnectionStringBuilder_GetDatabaseFromDataSourceTest()
{
var builder = new ConnectionStringBuilder();
var connectionString = "Data Source =WarriorDB.db";
var database = builder.GetDatabase(connectionString);
Assert.AreEqual(database, "WarriorDB.db");
connectionString = "Data Source=WarriorDB.db";
database = builder.GetDatabase(connectionString);
Assert.AreEqual(database, "WarriorDB.db");
connectionString = "data source =WarriorDB.db";
database = builder.GetDatabase(connectionString);
Assert.AreEqual(database, "WarriorDB.db");
connectionString = "data source=WarriorDB.db";
database = builder.GetDatabase(connectionString);
Assert.AreEqual(database, "WarriorDB.db");
connectionString = "data source= WarriorDB.db";
database = builder.GetDatabase(connectionString);
Assert.AreEqual(database, "WarriorDB.db");
connectionString = "data source=WarriorDB.db;";
database = builder.GetDatabase(connectionString);
Assert.AreEqual(database, "WarriorDB.db");
connectionString = @"Data Source=c:\WarriorDB.db;Version=3;New=True;";
database = builder.GetDatabase(connectionString);
Assert.AreEqual(database, @"c:\WarriorDB.db");
}
public void ConnectionStringBuilder_FormatConnectionString_LocalDB()
{
var builder = new ConnectionStringBuilder();
var connectionString = @"Data Source=(LocalDB)\mssqllocaldb;AttachDBFileName=c:\Path\To\Database\WickeFlame.mdf;Initial Catalog=WickeFlame;Integrated Security=True;";
Assert.AreEqual(builder.FormatConnectionString(connectionString), connectionString);
}
void CloseOrDeleteOrTradeRecords(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataTrade = new DataTrade(connectionString);
this.dataTrade.Logon += this.OnLogon;
this.dataTrade.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
this.dataTrade.SynchOperationTimeout = 20000;
var count = 0;
for (var records = this.dataTrade.Server.GetTradeRecords(); records.Length > 0; records = this.dataTrade.Server.GetTradeRecords())
{
foreach (var element in records)
{
if (element.IsPendingOrder)
element.Delete();
else
element.Close();
++count;
}
}
Console.WriteLine("{0} trade records have been deleted/closed", count);
}
void SendLimitOrder(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataTrade = new DataTrade(connectionString);
this.dataTrade.Logon += this.OnLogon;
this.dataTrade.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
const double price = 1.1;
var order = this.dataTrade.Server.SendOrderEx("EURUSD", TradeCommand.Limit, TradeRecordSide.Buy, price, 10000, 0, 0, null, "comment", 1000000);
Assert.IsTrue(order.Price == price, "Invalid order price = {0}", order.Price);
this.dataTrade.Logon -= this.OnLogon;
this.dataTrade.Stop();
this.dataTrade.Dispose();
}
public void Initialize(WebHostContext context)
{
ITestDatabase db;
string connectionString;
string prefix = context.TestType.TestTypeInfo.Type.Name;
if (context.HostOptions is IISExpressHostOptions)
{
connectionString = new ConnectionStringBuilder().UseLocalDB().UseRandomDBName(prefix).ToString();
db = new SqlTestDatabase(connectionString);
}
else if (context.HostOptions is IISHostOptions)
{
connectionString = new ConnectionStringBuilder().UseLocalSqlExpress().UseRandomDBName(prefix).ToString();
db = new SqlTestDatabase(connectionString);
}
else if (context.HostOptions is AzureWebsiteHostOptions)
{
connectionString = NuwaGlobalConfiguration.SqlAzureConnectionString;
db = new SqlTestDatabase(connectionString);
}
else
{
throw new NotSupportedException(context.HostOptions.GetType().Name);
}
if (db.Exist())
{
db.Delete();
}
context.Properties.Add(NuwaDBContextKey, db);
context.DeploymentOptions.WebConfigTransformers.Add(new WebConfigTransformer(
config =>
{
config.ClearConnectionStrings();
config.AddConnectionString(ConnectionStringName, connectionString, "System.Data.SqlClient");
}));
}
public void ReturnAnEmptyCollectionIfTheFolderDoesNotExist()
{
Int32 count = 25.GetRandom(10);
String rootPath = $"c:\\{string.Empty.GetRandom()}";
String relativePath = string.Empty.GetRandom();
String folderPath = Path.Combine(rootPath, relativePath);
String fakeFolder = String.Empty.GetRandom();
String fakePath = Path.Combine(rootPath, fakeFolder);
var connectionString = new ConnectionStringBuilder("this")
.AddFilePath(rootPath)
.Build();
var files = new SourceFileCollectionBuilder()
.AddRandomFiles(count, relativePath)
.Build();
var fileService = new MockFileServiceBuilder()
.AddSourceFiles(files)
.Build();
var directoryService = new MockDirectoryServiceBuilder()
.AddSourceFiles(files)
.Build(rootPath);
directoryService.Setup(fs => fs.Exists(fakePath)).Returns(false);
directoryService.Setup(fs => fs.EnumerateFiles(fakeFolder))
.Throws(new System.IO.DirectoryNotFoundException());
var target = new ContentRepositoryBuilder()
.AddFileService(fileService.Object)
.AddDirectoryService(directoryService.Object)
.Build(connectionString);
var actual = target.GetFolderContents(fakePath);
Assert.Empty(actual);
}
void RegularLogout(ConnectionStringBuilder builder)
{
var fixBuilder = builder as FixConnectionStringBuilder;
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnLogon;
this.dataFeed.Logout += this.OnLogout;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
this.dataFeed.Stop();
status = this.logoutEvent.WaitOne(0);
Assert.IsTrue(status, "Timeout of logout event");
this.dataFeed.Logon -= this.OnLogon;
this.dataFeed.Logout -= this.OnLogout;
Assert.IsTrue(LogoutReason.ClientInitiated == this.logoutReason);
}
void Logon(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnLogon;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
var fixBuilder = builder as FixConnectionStringBuilder;
if (fixBuilder != null)
{
var st = this.dataFeed.UsedProtocolVersion.ToString();
Assert.IsTrue(fixBuilder.ProtocolVersion == st, "Server is not supported required protocol version");
}
this.dataFeed.Stop();
this.dataFeed.Logon -= this.OnLogon;
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "CivilApp.API", Version = "v1"
});
});
services.AddScoped(typeof(IAppLogger <>), typeof(LogAdapter <>));
services.AddScoped(typeof(IAsyncRepository <>), typeof(EfRepository <>));
services.AddScoped <IDateTimeService, DateTimeService>();
services.AddScoped <IJacketSequenceService, JacketSequenceService>();
services.AddDbContext <JacketContext>(options =>
{
options.UseSqlServer(ConnectionStringBuilder.BuildSQLConnectionString(
Configuration.GetValue <string>("DATABASE_SERVER"), Configuration.GetValue <string>("DATABASE"),
Configuration.GetValue <string>("CIVILAPP_USERNAME"),
Configuration.GetValue <string>("CIVILAPP_PASSWORD")));
});
}
public void ReturnAllCategories()
{
Int32 categoryCount = 20.GetRandom(5);
string rootPath = $"C:\\{string.Empty.GetRandom()}";
var connectionString = new ConnectionStringBuilder("this")
.AddFilePath(rootPath)
.Build();
var fileSystem = new MockFileServiceBuilder()
.AddRandomCategories(categoryCount)
.Build(rootPath);
var target = new ContentRepositoryBuilder()
.AddFileService(fileSystem.Object)
.UseGenericDirectory()
.Build(connectionString);
var actual = target.GetCategories();
Assert.Equal(categoryCount, actual.Count());
}
private void BuildDataChannel()
{
if (CurrentItem != null)
{
ConnectionStringBuilder csb = new ConnectionStringBuilder(ConnectionStringBuilder.ConnectionType.DataChannel);
if (!string.IsNullOrEmpty(CurrentItem.DataChannel))
{
csb.ConnectionString = CurrentItem.DataChannel;
}
csb.Closed += new EventHandler(delegate(object popupWindow, EventArgs eargs)
{
if ((bool)csb.DialogResult)
{
CurrentItem.DataChannel = csb.ConnectionString;
}
});
csb.Owner = System.Windows.Application.Current.MainWindow;
csb.WindowStartupLocation = WindowStartupLocation.CenterOwner;
csb.ShowDialog();
}
}
public void TestInit(DbEngine dbEngine, bool integratedSecurity, string userName, string password)
{
IDbManager dbManager = DbManagerFactory.Create(dbEngine, _loggerFactory);
Tuple <string, string> hostAndName = _hostAndDatabaseOptions[dbEngine];
IDictionary <string, string> options = new Dictionary <string, string>()
{
{ DbParametersKeys.HostKey, hostAndName.Item1 },
{ DbParametersKeys.DatabaseKey, hostAndName.Item2 },
{ DbParametersKeys.UseIntegratedSecurityKey, integratedSecurity.ToString() },
{ DbParametersKeys.LoginKey, userName },
{ DbParametersKeys.PasswordKey, password }
};
string connectionString = ConnectionStringBuilder.Build(dbEngine, options);
bool result = dbManager.CreateDatabase(connectionString, true);
Assert.True(result);
result = dbManager.Init(connectionString, _scripts);
Assert.True(result);
result = dbManager.DropDatabase(connectionString);
Assert.True(result);
}
public void ShouldThrowIfPatternsNotFound()
{
//Arrange
var builder = new ConnectionStringBuilder(CsPattern);
var tagProvider = new NullCsTagProvider();
//Act
ConnectionStringTagsNotFoundException caught = null;
try
{
builder.Build(tagProvider);
}
catch (ConnectionStringTagsNotFoundException exception)
{
caught = exception;
}
//Assert
Assert.NotNull(caught);
Assert.Equal(new [] { "User", "Password" }, caught.AbsentTags);
}
void SendMarketOrder(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataTrade = new DataTrade(connectionString);
this.dataTrade.Logon += this.OnLogon;
this.dataTrade.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
var order = this.dataTrade.Server.SendOrderEx("EURUSD", TradeCommand.Market, TradeRecordSide.Buy, 1.1, 10000, 0, null, null, 0, null, "comment", null, null, 1000000);
Assert.IsTrue(order.Price > 0, "Invalid order price = {0}", order.Price);
CacheDontHavePositions();
this.dataTrade.Logon -= this.OnLogon;
this.dataTrade.Stop();
this.dataTrade.Dispose();
}
private AuditContext CreateContext(AuditEvent auditEvent)
{
#if NET45
if (DbConnectionBuilder != null)
{
return(new AuditContext(DbConnectionBuilder.Invoke(auditEvent), SetDatabaseInitializerNull, true));
}
else
{
return(new AuditContext(ConnectionStringBuilder?.Invoke(auditEvent), SetDatabaseInitializerNull));
}
#else
if (DbContextOptionsBuilder != null)
{
return(new AuditContext(ConnectionStringBuilder?.Invoke(auditEvent), DbContextOptionsBuilder.Invoke(auditEvent)));
}
else
{
return(new AuditContext(ConnectionStringBuilder?.Invoke(auditEvent)));
}
#endif
}
static void RunOptions(Options options)
{
Console.WriteLine(String.Format("Execution starting on {0} , database {1}, with username {2} and password {3}"
, options.Server, options.Databasename, options.Username, options.Password));
Console.WriteLine(String.Format("SSIS package path {0}", options.SSISPath));
Console.WriteLine(String.Format("Dacpac path {0}", options.DacpacPath));
Console.WriteLine(options.ToString());
ConnectionStringBuilder builder = new ConnectionStringBuilder();
builder.setServer(options.Server)
.setDatabase(options.Databasename)
.setUserName(options.Username)
.setPassword(options.Password);
//Create the database from ssdt project
PackageLoader pacLoader = new PackageLoader();
SSDTExecutor exec = new SSDTExecutor(builder.build());
exec.OnStatusUpdate(progressupdate);
pacLoader.loadDacPac(options.DacpacPath);
exec.publish(pacLoader, options.Databasename);
//migrate AE encrypted data
pacLoader.loadSSISPackage(options.SSISPath);
var ssisrunner = new SSISExecutor(pacLoader);
ssisrunner.SetServer(options.Server);
ssisrunner.SetUser(options.Username);
ssisrunner.SetPassword(options.Password);
ssisrunner.SetDatabase(options.Databasename);
string result = ssisrunner.execute();
Console.WriteLine(result);
Console.ReadLine();
}
public List <Database> GetDatabasesForServer(string serverAddress, string username, string password)
{
if (string.IsNullOrWhiteSpace(serverAddress))
{
throw new ArgumentNullException(nameof(serverAddress));
}
if (string.IsNullOrWhiteSpace(username))
{
throw new ArgumentNullException(nameof(username));
}
if (string.IsNullOrWhiteSpace(password))
{
throw new ArgumentNullException(nameof(password));
}
var databases = new List <Database>();
var connectionString = ConnectionStringBuilder.FromCredentials(serverAddress, username, password);
using (var connection = new SqlConnection(connectionString))
{
connection.Open();
using (var command = new SqlCommand("SELECT * FROM sys.databases", connection))
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var databaseName = reader.GetString(0);
databases.Add(new Database(databaseName));
}
}
}
return(databases);
}
public override async Task <T> GetEventAsync <T>(object eventId)
{
if (JsonColumnNameBuilder == null)
{
return(null);
}
using (var ctx = new AuditContext(ConnectionStringBuilder?.Invoke(null)))
{
var cmdText = GetSelectCommandText(null);
#if NET45
var result = ctx.Database.SqlQuery <string>(cmdText, new SqlParameter("@eventId", eventId));
var json = await result.FirstOrDefaultAsync();
#elif NETSTANDARD1_3 || NETSTANDARD2_0
var result = ctx.FakeIdSet.FromSql(cmdText, new SqlParameter("@eventId", eventId));
var json = (await result.FirstOrDefaultAsync())?.Id;
#endif
if (json != null)
{
return(AuditEvent.FromJson <T>(json));
}
}
return(null);
}
void ButtonBuildCommandChannel_Click(object sender, RoutedEventArgs e)
{
ConnectionStringBuilder csb = new ConnectionStringBuilder(ConnectionStringBuilder.ConnectionType.CommandChannel);
if (!string.IsNullOrEmpty(TextBoxCommandChannel.Text))
{
csb.ConnectionString = TextBoxCommandChannel.Text;
}
csb.Closed += new EventHandler(delegate(object popupWindow, EventArgs eargs)
{
if ((bool)csb.DialogResult)
{
TextBoxCommandChannel.Text = csb.ConnectionString;
}
});
#if !SILVERLIGHT
csb.Owner = Window.GetWindow(this);
csb.WindowStartupLocation = WindowStartupLocation.CenterOwner;
csb.ShowDialog();
#else
csb.Show();
#endif
}
public void ReturnTheTagFromASingleTagPost()
{
String expected = string.Empty.GetRandom();
String rootPath = $"c:\\{string.Empty.GetRandom()}";
var connectionString = new ConnectionStringBuilder("this")
.AddFilePath(rootPath)
.Build();
var postJson = new MediaPostBuilder()
.UseRandomFlickrPost()
.ClearTags()
.AddTag(expected)
.Build();
var postFiles = new MockMediaFileCollectionBuilder()
.AddPost(postJson)
.Build(rootPath);
var directoryProvider = new MockDirectoryServiceBuilder()
.AddPostFiles(postFiles.Select(f => f.GetFilename()))
.Build(rootPath);
var fileSystem = new MockFileServiceBuilder()
.AddPosts(postFiles)
.Build();
var target = new ContentRepositoryBuilder()
.AddFileService(fileSystem.Object)
.AddDirectoryService(directoryProvider.Object)
.Build(connectionString);
var pages = target.GetAllPosts();
var actual = pages.Single().Tags.Single();
Assert.Equal(expected, actual);
}
internal void SetupBuilder(string address, string username, string password, string logPath)
{
// Create builder
ConnectionStringBuilder builder = null;
if (!FdkHelper.UseLrp)
{
var fixBuilder = new FixConnectionStringBuilder();
fixBuilder.TargetCompId = "EXECUTOR";
fixBuilder.ProtocolVersion = FixProtocolVersion.TheLatestVersion.ToString();
fixBuilder.SecureConnection = true;
fixBuilder.Port = 5004;
fixBuilder.ExcludeMessagesFromLogs = "W";
fixBuilder.DecodeLogFixMessages = false;
fixBuilder.Address = address;
fixBuilder.Username = username;
fixBuilder.Password = password;
fixBuilder.FixLogDirectory = logPath;
fixBuilder.FixEventsFileName = string.Format("{0}.trade.events.log", username);
fixBuilder.FixMessagesFileName = string.Format("{0}.trade.messages.log", username);
builder = fixBuilder;
}
else
{
var fixBuilder = new LrpConnectionStringBuilder();
fixBuilder.SecureConnection = true;
fixBuilder.Port = 5004; ////ExcludeMessagesFromLogs = "W",
fixBuilder.Address = address;
fixBuilder.Username = username;
fixBuilder.Password = password;
fixBuilder.MessagesLogFileName = string.Format("{0}.trade.events.log", username);
builder = fixBuilder;
}
Builder = builder;
}
void TradeReports(ConnectionStringBuilder builder, TestContext testContext)
{
var connectionString = builder.ToString();
this.dataTrade = new DataTrade(connectionString);
this.dataTrade.Logon += this.OnLogon;
this.dataTrade.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
//Test Limit order
var order = this.dataTrade.Server.SendOrderEx(testContext.Symbol, TradeCommand.Limit, TradeRecordSide.Buy, testContext.VeryLowPrice, testContext.Volume, null, null, null, null, DateTime.UtcNow.AddHours(1), testContext.Comment, null, null, 1000000);
Assert.IsTrue(order.Price == testContext.VeryLowPrice, "Invalid order price = {0}", order.Price);
order.Delete();
Reports.TradeTransactionReport tradeReport = this.dataTrade.Server.GetTradeTransactionReports(TimeDirection.Backward, false, DateTime.UtcNow.AddMinutes(-5), DateTime.UtcNow.AddMinutes(5), false).Item;
Assert.IsTrue(tradeReport.TradeRecordType == order.Type);
Assert.IsTrue(tradeReport.Price == order.Price);
//Test stop order
order = this.dataTrade.Server.SendOrderEx(testContext.Symbol, TradeCommand.Stop, TradeRecordSide.Buy, testContext.VeryHighPrice, testContext.Volume, null, null, null, null, DateTime.UtcNow.AddHours(1), testContext.Comment, null, null, 1000000);
Assert.IsTrue(order.Price == testContext.VeryHighPrice, "Invalid order price = {0}", order.Price);
order.Delete();
tradeReport = this.dataTrade.Server.GetTradeTransactionReports(TimeDirection.Backward, false, DateTime.UtcNow.AddMinutes(-5), DateTime.UtcNow.AddMinutes(5), false).Item;
Assert.IsTrue(tradeReport.TradeRecordType == order.Type);
Assert.IsTrue(tradeReport.StopPrice == order.Price);
this.dataTrade.Logon -= this.OnLogon;
this.dataTrade.Stop();
this.dataTrade.Dispose();
}
private void ReportViewer_Load(object sender, EventArgs e)
{
if (isReportViewerLoaded)
{
return;
}
var reportDataSource1 = new ReportDataSource();
var dataset = new SoldTickets();
dataset.BeginInit();
reportDataSource1.Name = "SoldTicketsDataSet";
reportDataSource1.Value = dataset.BrowseTickets;
_reportViewer.LocalReport.DataSources.Add(reportDataSource1);
_reportViewer.LocalReport.ReportEmbeddedResource = "Administration.Report.SoldTicketsReport.rdlc";
dataset.EndInit();
var connectionString = ConnectionStringBuilder.Build(
Settings.Default.server,
Settings.Default.database,
Settings.Default.user,
Settings.Default.password);
var connection = new SqlConnection(connectionString);
var adapter = new BrowseTicketsTableAdapter {
ClearBeforeFill = true, Connection = connection
};
adapter.Fill(dataset.BrowseTickets);
_reportViewer.SetDisplayMode(DisplayMode.PrintLayout);
_reportViewer.RefreshReport();
isReportViewerLoaded = true;
}
public void CreatesANewConnectionForEachOpen()
{
IConnection connection1 = null;
IConnection connection2 = null;
var provider = new NormalConnectionProvider(ConnectionStringBuilder.Create(TestHelper.ConnectionString()));
try
{
connection1 = provider.Open(null);
connection2 = provider.Open(null);
Assert.NotSame(connection1, connection2);
}
finally
{
if (connection1 != null)
{
provider.Close(connection1);
}
if (connection2 != null)
{
provider.Close(connection2);
}
}
}
public void ConnectionStringBuilder_GetDatabaseFromDatabaseTest()
{
var builder = new ConnectionStringBuilder();
var connectionString = "data source=.;Database =WarriorDB;persist security info=False;user id=sa";
var database = builder.GetDatabase(connectionString);
Assert.AreEqual(database, "WarriorDB");
connectionString = "data source=.;Database=WarriorDB;persist security info=False;user id=sa";
database = builder.GetDatabase(connectionString);
Assert.AreEqual(database, "WarriorDB");
connectionString = "data source=.;database=WarriorDB;persist security info=False;user id=sa";
database = builder.GetDatabase(connectionString);
Assert.AreEqual(database, "WarriorDB");
connectionString = "data source=.;database =WarriorDB;persist security info=False;user id=sa";
database = builder.GetDatabase(connectionString);
Assert.AreEqual(database, "WarriorDB");
connectionString = "data source=.;database= WarriorDB;persist security info=False;user id=sa";
database = builder.GetDatabase(connectionString);
Assert.AreEqual(database, "WarriorDB");
}
private void BuildDataChannel()
{
if (CurrentItem != null)
{
ConnectionStringBuilder csb = new ConnectionStringBuilder(ConnectionStringBuilder.ConnectionType.DataChannel);
if (!string.IsNullOrEmpty(CurrentItem.DataChannel))
{
csb.ConnectionString = CurrentItem.DataChannel;
}
csb.Closed += delegate
{
if ((bool)csb.DialogResult)
{
CurrentItem.DataChannel = csb.ConnectionString;
}
};
csb.Owner = Application.Current.MainWindow;
csb.WindowStartupLocation = WindowStartupLocation.CenterOwner;
csb.ShowDialog();
}
}
private void BuildConnectionString()
{
if ((object)CurrentItem != null)
{
ConnectionStringBuilder csb = new ConnectionStringBuilder(ConnectionStringBuilder.ConnectionType.DeviceConnection);
if (!string.IsNullOrEmpty(CurrentItem.ConnectionString))
{
csb.ConnectionString = CurrentItem.ConnectionString;
}
csb.Closed += delegate
{
if (csb.DialogResult.GetValueOrDefault())
{
CurrentItem.ConnectionString = csb.ConnectionString;
}
};
csb.Owner = Application.Current.MainWindow;
csb.WindowStartupLocation = WindowStartupLocation.CenterOwner;
csb.ShowDialog();
}
}
static void Main(string[] args)
{
ConnectionStringBuilder db = new ConnectionStringBuilder("MinionsDB");
DbContext em = new EntityManager(db.ConnectionString, true);
var books = em.FindAll <Book>()
.OrderByDescending(b => b.PublishedOn)
.ThenBy(b => b.Rating)
.Take(3)
.Select(b => new
{
b.Title,
b.Author,
b.Rating
})
.OrderByDescending(b => b.Rating)
.ThenBy(b => b.Title)
.ToList();
foreach (var book in books)
{
Console.WriteLine("{0} ({1}) - {2}/10", book.Title, book.Author, book.Rating);
}
}
void CloseOrDeleteOrTradeRecords(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataTrade = new DataTrade(connectionString);
this.dataTrade.Logon += this.OnLogon;
this.dataTrade.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
this.dataTrade.SynchOperationTimeout = 20000;
var count = 0;
for (var records = this.dataTrade.Server.GetTradeRecords(); records.Length > 0; records = this.dataTrade.Server.GetTradeRecords())
{
foreach (var element in records)
{
if (element.IsPendingOrder)
{
element.Delete();
}
else
{
element.Close();
}
++count;
}
}
Console.WriteLine("{0} trade records have been deleted/closed", count);
}
public void TryConnect()
{
var connectWorker = new BackgroundWorker();
connectWorker.DoWork += (sender, args) =>
{
view.Dispatcher.Invoke(() => { view.IndicateProgress(); });
string connectionString;
if (isTrustedConnection)
{
connectionString = ConnectionStringBuilder.Build(Server, "master");
}
else
{
connectionString = ConnectionStringBuilder.Build(Server, "master", User, Password);
}
var executor = new CommandExecutor("SELECT GETDATE()", connectionString, false);
try
{
executor.ExecuteCommand().ThrowIfException();
view.Dispatcher.Invoke(() => { view.IndicateSuccess(); });
IsConnected = true;
UpdateDatabasesList(connectionString);
}
catch (Exception e)
{
view.Dispatcher.Invoke(() => { view.IndicateFail(); });
IsConnected = false;
}
};
connectWorker.RunWorkerAsync();
}
void BackwardBarsEnumeration(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnLogon;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
var startTime = new DateTime(2015, 10, 10, 12, 0, 0, 0, DateTimeKind.Utc);
var endTime = new DateTime(2015, 10, 10, 12, 1, 0, 0, DateTimeKind.Utc);
var data = new List <Bar>();
var bars = new Bars(this.dataFeed, "EURUSD", PriceType.Bid, BarPeriod.S1, endTime, startTime);
foreach (var element in bars)
{
Assert.IsTrue(startTime <= element.From, "startTime <= element.From");
Assert.IsTrue(element.To <= endTime, "element.To <= endTime");
Assert.IsTrue(element.From < element.To, "Invalid a bar timestamp");
data.Add(element);
}
this.dataFeed.Logon -= this.OnLogon;
this.dataFeed.Stop();
for (var index = 1; index < data.Count; ++index)
{
var first = data[index];
var second = data[index - 1];
Assert.IsTrue(first.To <= second.From, "Invalid bars sequence order.");
}
}
public void Tick(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnLogon;
this.dataFeed.Tick += this.OnTick;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
var symbols = new[] { "EURUSD" };
this.dataFeed.Server.SubscribeToQuotes(symbols, 0);
status = this.tickEvent.WaitOne(TickWaitingTimeout);
Assert.IsTrue(status, "Timeout of tick event");
this.dataFeed.Stop();
this.dataFeed.Logon -= this.OnLogon;
this.dataFeed.Tick -= this.OnTick;
}
public void RequestTheContentsOfTheCorrectFiles()
{
Int32 count = 25.GetRandom(10);
String rootPath = $"c:\\{string.Empty.GetRandom()}";
String relativePath = string.Empty.GetRandom();
String folderPath = Path.Combine(rootPath, relativePath);
var connectionString = new ConnectionStringBuilder("this")
.AddFilePath(rootPath)
.Build();
var files = new SourceFileCollectionBuilder()
.AddRandomFiles(count, relativePath)
.Build();
var fileService = new MockFileServiceBuilder()
.AddSourceFiles(files)
.Build();
var directoryService = new MockDirectoryServiceBuilder()
.AddSourceFiles(files)
.Build(rootPath);
var target = new ContentRepositoryBuilder()
.AddFileService(fileService.Object)
.AddDirectoryService(directoryService.Object)
.Build(connectionString);
var actual = target.GetFolderContents(relativePath);
foreach (var file in files)
{
String filePath = System.IO.Path.Combine(relativePath, file.FileName);
fileService.Verify(fs => fs.ReadAllBytes(filePath), Times.Once);
}
}
protected override IntPtr OnCreate()
{
var connStr = ConnectionString;
if (connStr.IsNullOrEmpty())
{
throw new InvalidOperationException("未设置连接字符串");
}
var builder = new ConnectionStringBuilder(connStr);
var dataSource = builder["DataSource"] ?? builder["Server"];
var port = builder["Port"].ToInt();
//if (port <= 0) port = 6030;
var user = builder["username"] ?? builder["user"] ?? builder["uid"];
var pass = builder["password"] ?? builder["pass"] ?? builder["pwd"];
var db = builder["database"] ?? builder["db"];
var uri = new NetUri(dataSource);
if (port > 0)
{
uri.Port = port;
}
#if DEBUG
XTrace.WriteLine("连接TDengine：server={0};user={1};pass={2};db={3}", dataSource, user, pass, db);
#endif
var handler = TD.Connect(uri.Address + "", user, pass, db, (Int16)uri.Port);
if (handler == IntPtr.Zero)
{
throw new XCodeException("打开数据库连接失败！");
}
return(handler);
}
public void ConnectionStringBuilder_SetDatabaseFromDataSourceTest()
{
var builder = new ConnectionStringBuilder();
var connectionString = "Data Source =TempDB.db";
connectionString = builder.SetDatabase("WarriorDB.db", connectionString);
Assert.AreEqual(connectionString, "Data Source=WarriorDB.db");
connectionString = "Data Source=TempDB.db";
connectionString = builder.SetDatabase("WarriorDB.db", connectionString);
Assert.AreEqual(connectionString, "Data Source=WarriorDB.db");
connectionString = "data source =TempDB.db";
connectionString = builder.SetDatabase("WarriorDB.db", connectionString);
Assert.AreEqual(connectionString, "data source=WarriorDB.db");
connectionString = "data source=TempDB.db";
connectionString = builder.SetDatabase("WarriorDB.db", connectionString);
Assert.AreEqual(connectionString, "data source=WarriorDB.db");
connectionString = "data source= TempDB.db";
connectionString = builder.SetDatabase("WarriorDB.db", connectionString);
Assert.AreEqual(connectionString, "data source=WarriorDB.db");
connectionString = "data source=TempDB.db;";
connectionString = builder.SetDatabase("WarriorDB.db", connectionString);
Assert.AreEqual(connectionString, "data source=WarriorDB.db;");
connectionString = @"Data Source=c:\TempDB.db;Version=3;New=True;";
connectionString = builder.SetDatabase(@"c:\WarriorDB.db", connectionString);
Assert.AreEqual(connectionString, @"Data Source=c:\WarriorDB.db;Version=3;New=True;");
}
/// <summary>
/// Initializes a new instance of the <see cref="NormalConnectionProvider"/> class.
/// </summary>
/// <param name="builder">
/// The builder.
/// </param>
public NormalConnectionProvider(ConnectionStringBuilder builder)
{
_builder = builder;
}
void ConnectionErrorLogout(ConnectionStringBuilder builder)
{
var fixBuilder = builder as FixConnectionStringBuilder;
fixBuilder.Address = "localhost";
fixBuilder.FixLogDirectory = "C:\\Temporary\\Logs";
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnLogon;
this.dataFeed.Logout += this.OnLogout;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(!status, "Logon has been generated by error");
status = this.logoutEvent.WaitOne(10 * LogoutWaitingTimeout);
Assert.IsTrue(status, "Timeout of logout event");
Assert.IsTrue(LogoutReason.NetworkError == this.logoutReason);
this.dataFeed.Stop();
this.dataFeed.Logon -= this.OnLogon;
this.dataFeed.Logout -= this.OnLogout;
}
void Logon(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnLogon;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
var fixBuilder = builder as FixConnectionStringBuilder;
if (fixBuilder != null)
{
var st = this.dataFeed.UsedProtocolVersion.ToString();
Assert.IsTrue(fixBuilder.ProtocolVersion == st, "Server is not supported required protocol version");
}
this.dataFeed.Stop();
this.dataFeed.Logon -= this.OnLogon;
}
void CreateAndDestroy(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
}
void BackwardBarsEnumeration(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnLogon;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
var startTime = new DateTime(2015, 10, 10, 12, 0, 0, 0, DateTimeKind.Utc);
var endTime = new DateTime(2015, 10, 10, 12, 1, 0, 0, DateTimeKind.Utc);
var data = new List<Bar>();
var bars = new Bars(this.dataFeed, "EURUSD", PriceType.Bid, BarPeriod.S1, endTime, startTime);
foreach (var element in bars)
{
Assert.IsTrue(startTime <= element.From, "startTime <= element.From");
Assert.IsTrue(element.To <= endTime, "element.To <= endTime");
Assert.IsTrue(element.From < element.To, "Invalid a bar timestamp");
data.Add(element);
}
this.dataFeed.Logon -= this.OnLogon;
this.dataFeed.Stop();
for (var index = 1; index < data.Count; ++index)
{
var first = data[index];
var second = data[index - 1];
Assert.IsTrue(first.To <= second.From, "Invalid bars sequence order.");
}
}
void IncorrectSubscribeToQuotes(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnLogon;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
try
{
this.dataFeed.Server.SubscribeToQuotes(null, 0);
Assert.Fail("Null parameter has been accepted");
}
catch
{
}
try
{
var symbols = new[] { "EURUSD" };
this.dataFeed.Server.SubscribeToQuotes(symbols, -1);
Assert.Fail("Negative parameter has been accepted");
}
catch
{
}
try
{
var symbols = new[] { "EURUSD" };
this.dataFeed.Server.SubscribeToQuotes(symbols, 6);
Assert.Fail("Negative parameter has been accepted");
}
catch
{
}
try
{
var symbols = new[] { "YYY/XXX" };
this.dataFeed.Server.SubscribeToQuotes(symbols, 0);
Assert.Fail("Invalid symbols have been accepted");
}
catch
{
}
this.dataFeed.Stop();
this.dataFeed.Logon -= this.OnLogon;
}
public void Connect()
{
try
{
ConnectionState = ConnectionState.Connecting;
ConnectionStringBuilder csb = new ConnectionStringBuilder();
csb.DbPath = Properties.Settings.Default.DbPath;
csb.Db = "BudgetModel";
Container = new BudgetModelContainer(csb.ToString());
ConnectionState = ConnectionState.Open;
Container.Connection.StateChange += Connection_StateChange;
}
catch (Exception ex)
{
ConnectionState = ConnectionState.Closed;
throw ex;
}
Play();
}
private DataTable GetPlainSQLReportResult(BaseHeaderDTO headerDTO, string locationID, IList<FilterDTO> allFilters, IDictionary<string, string> parameters)
{
var filterInfos = GetFilterInfo(allFilters, parameters);
var filterString = GetFilterString(filterInfos, headerDTO.Type == "C");
var commandText = headerDTO.QueryStartString + " " + filterString + " " + headerDTO.QueryEndString;
var connectionString = new ConnectionStringBuilder().Build(headerDTO.Database, locationID);
using (var connection = new SqlConnection(connectionString))
{
connection.Open();
using (var cmd = new SqlCommand(commandText, connection))
using (var reader = cmd.ExecuteReader())
using (var table = new DataTable())
{
table.Load(reader);
return table;
}
}
}
public void ConnectionStringBuilder_SetDatabaseFromInitialCatalogTest()
{
var builder = new ConnectionStringBuilder();
var connectionString = "data source=.;Initial Catalog =TempDB;persist security info=False;user id=sa";
connectionString = builder.SetDatabase("WarriorDB", connectionString);
Assert.AreEqual(connectionString, "data source=.;Initial Catalog=WarriorDB;persist security info=False;user id=sa");
connectionString = "data source=.;Initial Catalog=TempDB;persist security info=False;user id=sa";
connectionString = builder.SetDatabase("WarriorDB", connectionString);
Assert.AreEqual(connectionString, "data source=.;Initial Catalog=WarriorDB;persist security info=False;user id=sa");
connectionString = "data source=.;initial catalog=TempDB;persist security info=False;user id=sa";
connectionString = builder.SetDatabase("WarriorDB", connectionString);
Assert.AreEqual(connectionString, "data source=.;initial catalog=WarriorDB;persist security info=False;user id=sa");
connectionString = "data source=.;initial catalog=TempDB;persist security info=False;user id=sa";
connectionString = builder.SetDatabase("WarriorDB", connectionString);
Assert.AreEqual(connectionString, "data source=.;initial catalog=WarriorDB;persist security info=False;user id=sa");
connectionString = "data source=.;initial catalog= TempDB;persist security info=False;user id=sa";
connectionString = builder.SetDatabase("WarriorDB", connectionString);
Assert.AreEqual(connectionString, "data source=.;initial catalog=WarriorDB;persist security info=False;user id=sa");
}
void RegularLogout(ConnectionStringBuilder builder)
{
var fixBuilder = builder as FixConnectionStringBuilder;
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnLogon;
this.dataFeed.Logout += this.OnLogout;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
this.dataFeed.Stop();
status = this.logoutEvent.WaitOne(0);
Assert.IsTrue(status, "Timeout of logout event");
this.dataFeed.Logon -= this.OnLogon;
this.dataFeed.Logout -= this.OnLogout;
Assert.IsTrue(LogoutReason.ClientInitiated == this.logoutReason);
}
void ModifyLimitOrder(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataTrade = new DataTrade(connectionString);
this.dataTrade.SynchOperationTimeout = 20000;
this.dataTrade.Logon += this.OnLogon;
this.dataTrade.Start();
Boolean status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
const Double price = 1.1;
var start = DateTime.UtcNow;
var order = this.dataTrade.Server.SendOrderEx("EURUSD", TradeCommand.Limit, TradeRecordSide.Buy, price, 10000, null, null, null, "comment", 1000000);
var end = DateTime.UtcNow;
var interval = (end - start);
Console.WriteLine("Interval = {0}", interval);
Assert.IsTrue(order.Price == price, "Invalid order price = {0}", order.Price);
order.Modify(1.0, null, null, null);
order.Delete();
this.dataTrade.Logon -= this.OnLogon;
this.dataTrade.Stop();
this.dataTrade.Dispose();
}
void NotValidUsernameAndPasswordLogout(ConnectionStringBuilder builder)
{
var fixBuilder = builder as FixConnectionStringBuilder;
fixBuilder.Username = "******";
fixBuilder.Password = "******";
fixBuilder.FixLogDirectory = "C:\\Temporary\\logs";
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += OnLogon;
this.dataFeed.Logout += OnLogout;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(!status, "Logon has been generated by error");
status = this.logoutEvent.WaitOne(10 * LogoutWaitingTimeout);
Assert.IsTrue(status, "Timeout of logout event");
if ("ext.0.0" == fixBuilder.ProtocolVersion)
{
Assert.IsTrue(LogoutReason.None == this.logoutReason);
}
else
{
Assert.IsTrue(LogoutReason.InvalidCredentials == this.logoutReason);
}
this.dataFeed.Stop();
this.dataFeed.Logon -= OnLogon;
this.dataFeed.Logout -= OnLogout;
}
public INamedConnectionString AddConnection()
{
var builder = new ConnectionStringBuilder(this);
builders.Add(builder);
return builder;
}
public void Tick(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnLogon;
this.dataFeed.Tick += this.OnTick;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
var symbols = new[] { "EURUSD" };
this.dataFeed.Server.SubscribeToQuotes(symbols, 0);
status = this.tickEvent.WaitOne(TickWaitingTimeout);
Assert.IsTrue(status, "Timeout of tick event");
this.dataFeed.Stop();
this.dataFeed.Logon -= this.OnLogon;
this.dataFeed.Tick -= this.OnTick;
}
public ConnectionTester(ConnectionStringBuilder builder)
{
this.Builder = builder;
}
void ForwardAndBackwardBarsEnumerationConsistency(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataFeed = new DataFeed(connectionString);
this.dataFeed.Logon += this.OnLogon;
this.dataFeed.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
var startTime = new DateTime(2011, 10, 10, 12, 0, 0, 0, DateTimeKind.Utc);
var endTime = new DateTime(2011, 10, 10, 12, 1, 0, 0, DateTimeKind.Utc);
var forwardBars = new Bars(this.dataFeed, "EURUSD", PriceType.Bid, BarPeriod.S1, startTime, endTime);
var forwardData = forwardBars.ToList();
var backwardBars = new Bars(this.dataFeed, "EURUSD", PriceType.Bid, BarPeriod.S1, endTime, startTime);
var backwardData = backwardBars.ToList();
var count = forwardData.Count;
Assert.IsTrue(forwardData.Count == backwardData.Count, "forwardData.Count == backwardData.Count");
for (var index = 0; index < count; ++index)
{
var first = forwardData[index];
var second = backwardData[count - 1 - index];
Assert.IsTrue(first.From == second.From);
Assert.IsTrue(first.To == second.To);
}
}
void TradeReports(ConnectionStringBuilder builder, TestContext testContext)
{
var connectionString = builder.ToString();
this.dataTrade = new DataTrade(connectionString);
this.dataTrade.Logon += this.OnLogon;
this.dataTrade.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
//Test Limit order
var order = this.dataTrade.Server.SendOrderEx(testContext.Symbol, TradeCommand.Limit, TradeRecordSide.Buy, testContext.VeryLowPrice, testContext.Volume, null, null, DateTime.UtcNow.AddHours(1), testContext.Comment, 1000000);
Assert.IsTrue(order.Price == testContext.VeryLowPrice, "Invalid order price = {0}", order.Price);
order.Delete();
Reports.TradeTransactionReport tradeReport = this.dataTrade.Server.GetTradeTransactionReports(TimeDirection.Backward, false, DateTime.UtcNow.AddMinutes(-5), DateTime.UtcNow.AddMinutes(5)).Item;
Assert.IsTrue(tradeReport.TradeRecordType == order.Type);
Assert.IsTrue(tradeReport.Price == order.Price);
//Test stop order
order = this.dataTrade.Server.SendOrderEx(testContext.Symbol, TradeCommand.Stop, TradeRecordSide.Buy, testContext.VeryHighPrice, testContext.Volume, null, null, DateTime.UtcNow.AddHours(1), testContext.Comment, 1000000);
Assert.IsTrue(order.Price == testContext.VeryHighPrice, "Invalid order price = {0}", order.Price);
order.Delete();
tradeReport = this.dataTrade.Server.GetTradeTransactionReports(TimeDirection.Backward, false, DateTime.UtcNow.AddMinutes(-5), DateTime.UtcNow.AddMinutes(5)).Item;
Assert.IsTrue(tradeReport.TradeRecordType == order.Type);
Assert.IsTrue(tradeReport.StopPrice == order.Price);
this.dataTrade.Logon -= this.OnLogon;
this.dataTrade.Stop();
this.dataTrade.Dispose();
}
void CreateConnectAndDispose(ConnectionStringBuilder builder)
{
}
void CloseBy(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
using (this.dataTrade = new DataTrade(connectionString))
{
this.dataTrade.Logon += OnLogon;
this.dataTrade.AccountInfo += DataTrade_AccountInfo;
this.dataTrade.Start();
bool status = this.logonEvent.WaitOne(LogonWaitingTimeout);
status &= this.accountInfoEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
TradeRecord order1 = this.dataTrade.Server.SendOrderEx("EURUSD", TradeCommand.Market, TradeRecordSide.Buy, 0, 10000, null, null, null, "comment", 1000000);
TradeRecord order2 = this.dataTrade.Server.SendOrderEx("EURUSD", TradeCommand.Market, TradeRecordSide.Sell, 0, 10000, null, null, null, "comment", 1000000);
Assert.IsTrue( dataTrade.Server.CloseByPositions(order1.OrderId, order2.OrderId) );
var iter = this.dataTrade.Server.GetTradeTransactionReports(TimeDirection.Backward, false, DateTime.UtcNow.AddMinutes(-5), DateTime.UtcNow.AddMinutes(5));
TradeTransactionReport tradeReport1 = iter.Item;
iter.Next();
TradeTransactionReport tradeReport2 = iter.Item;
//Assert.IsTrue(tradeReport1.PositionById == order1.OrderId);
Assert.IsTrue(tradeReport2.PositionById == order2.OrderId);
this.dataTrade.Logon -= this.OnLogon;
this.dataTrade.AccountInfo -= DataTrade_AccountInfo;
this.dataTrade.Stop();
}
}
void CreateAndDestroy(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataTrade = new DataTrade(connectionString);
this.dataTrade.Dispose();
}
private DataTable GetStoredProcedureReportResult(BaseHeaderDTO headerDTO, string userID, string locationID, IList<FilterDTO> allFilters, IDictionary<string, string> parameters)
{
var connectionString = new ConnectionStringBuilder().Build(headerDTO.Database, locationID);
using (var connection = new SqlConnection(connectionString))
{
connection.Open();
using (var cmd = new SqlCommand(headerDTO.StoredProcedureName, connection))
{
cmd.CommandType = CommandType.StoredProcedure;
foreach(var filter in allFilters)
cmd.Parameters.Add(new SqlParameter(filter.Name, parameters.ContainsKey(filter.Name) ? parameters[filter.Name] : ""));
cmd.Parameters.Add(new SqlParameter("@strOrder", ""));
cmd.Parameters.Add(new SqlParameter("@UID", userID));
using (var reader = cmd.ExecuteReader())
using (var table = new DataTable())
{
table.Load(reader);
return table;
}
}
}
}
internal DisposableConnection(ConnectionStringBuilder builder)
: base(builder)
{
}
void ModifyLimitOrder(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataTrade = new DataTrade(connectionString);
this.dataTrade.Logon += this.OnLogon;
this.dataTrade.Start();
var status = this.logonEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
//const double activationPrice = 1.1;
//const double newActivationPrice = 1.0;
//const double newStopLoss = 0.8;
//const double newTakeProfit = 1.3;
var newExpirationTime = DateTime.UtcNow.AddHours(1);
var order = this.dataTrade.Server.SendOrderEx("EURUSD", TradeCommand.Limit, TradeRecordSide.Buy, 1.1, 10000, null, null, null, "comment", 1000000);
/*
//this.ModifyLimitOrder(order, activationPrice, null, null, null, null);
this.ModifyLimitOrder(order, activationPrice, null, null, null, newExpirationTime);
//this.ModifyLimitOrder(order, activationPrice, null, null, newTakeProfit, null);
this.ModifyLimitOrder(order, activationPrice, null, null, newTakeProfit, newExpirationTime);
//this.ModifyLimitOrder(order, activationPrice, null, newStopLoss, null, null);
this.ModifyLimitOrder(order, activationPrice, null, newStopLoss, null, newExpirationTime);
//this.ModifyLimitOrder(order, activationPrice, null, newStopLoss, newTakeProfit, null);
this.ModifyLimitOrder(order, activationPrice, null, newStopLoss, newTakeProfit, newExpirationTime);
//this.ModifyLimitOrder(order, activationPrice, newActivationPrice, null, null, null);
this.ModifyLimitOrder(order, activationPrice, newActivationPrice, null, null, newExpirationTime);
//this.ModifyLimitOrder(order, activationPrice, newActivationPrice, null, newTakeProfit, null);
this.ModifyLimitOrder(order, activationPrice, newActivationPrice, null, newTakeProfit, newExpirationTime);
//this.ModifyLimitOrder(order, activationPrice, newActivationPrice, newStopLoss, null, null);
this.ModifyLimitOrder(order, activationPrice, newActivationPrice, newStopLoss, null, newExpirationTime);
//this.ModifyLimitOrder(order, activationPrice, newActivationPrice, newStopLoss, newTakeProfit, null);
this.ModifyLimitOrder(order, activationPrice, newActivationPrice, newStopLoss, newTakeProfit, newExpirationTime);
*/
order.Delete();
this.dataTrade.Logon -= this.OnLogon;
this.dataTrade.Stop();
this.dataTrade.Dispose();
}
protected string GetConnectionString(AuditEvent auditEvent)
{
return(ConnectionStringBuilder?.Invoke(auditEvent));
}
void ModifyPosition(ConnectionStringBuilder builder)
{
var connectionString = builder.ToString();
this.dataTrade = new DataTrade(connectionString);
this.dataTrade.Logon += OnLogon;
this.dataTrade.AccountInfo += DataTrade_AccountInfo;
this.dataTrade.Start();
bool status = this.logonEvent.WaitOne(LogonWaitingTimeout);
status &= this.accountInfoEvent.WaitOne(LogonWaitingTimeout);
Assert.IsTrue(status, "Timeout of logon event");
var start = DateTime.UtcNow;
TradeRecord order = this.dataTrade.Server.SendOrderEx("EURUSD", TradeCommand.Market, TradeRecordSide.Buy, 0, 10000, null, null, null, "comment", 1000000);
DateTime end = DateTime.UtcNow;
TimeSpan interval = (end - start);
Console.WriteLine("Interval = {0}", interval);
var modified = order.Modify(null, 1.0, null, null);
order.Close();
this.dataTrade.Logon -= this.OnLogon;
this.dataTrade.AccountInfo -= DataTrade_AccountInfo;
this.dataTrade.Stop();
this.dataTrade.Dispose();
}
