/// <summary>
/// Drop foreign key
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void Remove_OnExecuted(object sender, ExecutedRoutedEventArgs e)
{
var updater = new DatabaseUpdater();
var res = updater.RemoveRelationship(InfoViewModel.RelationshipModel);
if (res != null)
{
await this.ShowMessageAsync("Drop foreign key", res);
return;
}
DatabaseModelDesignerViewModel.ConnectionInfoViewModels.Remove(InfoViewModel);
InfoViewModel = null;
RelationshipsListBox.SelectedIndex = 0;
}
/// <summary>
/// Create new
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void Confirm_OnExecuted(object sender, ExecutedRoutedEventArgs e)
{
var isOk = await CheckIntegrity();
if (isOk)
{
var relModel = new RelationshipModel
{
Name = RelationshipName,
Source = SourceTableVm.Model,
Destination = DestinationTableVm.Model
};
relModel.Attributes.AddRange(GridData);
relModel.Optionality = relModel.Attributes.All(t => t.Destination.AllowNull)
? Optionality.Optional
: Optionality.Mandatory;
relModel.DeleteAction = OnDeleteComboBox.SelectedValue as string;
relModel.UpdateAction = OnUpdateComboBox.SelectedValue as string;
var updater = new DatabaseUpdater();
string res = updater.AddRelationship(relModel);
if (res != null)
{
await this.ShowMessageAsync("Add foreign key", res);
}
else
{
ConnectionInfoViewModel model = new ConnectionInfoViewModel()
{
DestinationViewModel = DestinationTableVm,
SourceViewModel = SourceTableVm,
DesignerCanvas = Canvas
};
model.RelationshipModel.RefreshModel(relModel);
await model.BuildConnection3(DesignerViewModel);
DesignerViewModel.ConnectionInfoViewModels.Add(model);
DialogResult = true;
Close();
}
}
}
public override void MakeSchemaChanges()
{
try
{
var updater = new DatabaseUpdater <TFSUsersContext>(_tfsLogUsageConnString);
updater.CreateDatabaseIfNotExists();
using (var dac = WarehouseContext.CreateWarehouseDataAccessComponent())
{
_warehouseVersion.SetWarehouseVersion(dac);
}
}
catch (Exception err)
{
Utils.Log.LogEvent(RequestContext, err.Message, Utils.Log.LogEventInformationLevel.Error);
throw;
}
}
private void ConsumePoisFromJsonFile(GalacticSystemContext context, ILogger logger, IConfiguration config)
{
const string configKey = "POIUpdateDirectory";
var updateDir = config.GetSection("GalaxyUpdates")[configKey];
if (!Directory.Exists(updateDir))
{
logger.Log(LogLevel.Information, $"POI folder {updateDir} did not exist, skipping import.");
return;
}
if (!string.IsNullOrEmpty(updateDir))
{
logger.Log(LogLevel.Information, $"Checking {configKey} {updateDir}...");
foreach (var jsonFile in Directory.GetFiles(updateDir, "*.json"))
{
DatabaseUpdater.UpdatePOIsFromFile(context, jsonFile, logger);
File.Delete(jsonFile);
}
}
}
public void Updates_database()
{
var settings = new ConnectionSettings("server", "db", true, null, null);
var taskAttributes = new TaskAttributes(settings, "c:\\scripts");
var mocks = new MockRepository();
var executor = mocks.CreateMock <IScriptFolderExecutor>();
var taskObserver = mocks.CreateMock <ITaskObserver>();
using (mocks.Record())
{
executor.ExecuteScriptsInFolder(taskAttributes, "Update", taskObserver);
}
using (mocks.Playback())
{
IDatabaseActionExecutor updater = new DatabaseUpdater(executor);
updater.Execute(taskAttributes, taskObserver);
}
mocks.VerifyAll();
}
private void Wizard_OnFinishClick(object sender, RoutedEventArgs e)
{
ConfigFileHelper configFile = new ConfigFileHelper();
DatabaseUpdater databaseUpdateProvider = new DatabaseUpdater();
DatabaseFileHelper.ResetDatabaseReadOnlyFlag();
if (rdoSQLServer.IsChecked.HasValue && rdoSQLServer.IsChecked.Value)
{
configFile.SaveConfigFile(model.CreateConnectionString(txtPassword.Password));
}
else
{
if (databaseUpdateProvider.IsDatabaseVersionCorrect(GetConnectionString(true)))
{
configFile.SaveConfigFileForSqlExpress2008(txtServerName.Text);
}
else
{
configFile.SaveConfigFileForSqlExpress2005(txtServerName.Text);
}
}
_isWizardFinished = true;
_mainWindow.Visibility = Visibility.Visible;
ConfigurationManager.RefreshSection("connectionStrings");
Bootstrapper.Configure();
databaseUpdateProvider.InitializeDatabase(GetConnectionString(false));
_mainWindow.RefreshData();
_mainWindow.SetRecentItems();
Close();
}
protected override void OnStartup(StartupEventArgs e)
{
Boolean showEditor = false;
if (e.Args != null && e.Args.Length > 0)
{
List <String> args = new List <String>(e.Args);
if (args.Contains("-editor"))
{
showEditor = true;
}
if (args.Contains("-force"))
{
DatabaseUpdater.DeleteDataFolder();
}
}
LogProvider.Log("x64 hash: " + Hashing.SHA2Hash(Paths.EXTERNAL_DIRECTORY + @"\7zip\7zr-x64.exe"));
LogProvider.Log("x86 hash: " + Hashing.SHA2Hash(Paths.EXTERNAL_DIRECTORY + @"\7zip\7zr-x86.exe"));
GameSelector gs = new GameSelector(showEditor);
gs.Show();
}
static void Main(string[] args)
{
DatabaseReader reader = new DatabaseReader();
DatabaseWriter w = new DatabaseWriter();
DatabaseUpdater up = new DatabaseUpdater();
GameController cont = new GameController();
HttpClient client = new HttpClient();
User u = reader.getUser(1);
User u2 = reader.getUser(2);
//int gameid = w.addGame(u, u2);
//up.updateGame(gameid, "poggers");
//var open = reader.getOpenGames();
//int hey = w.newGameBlack(2);
//cont.quitGame(hey);
//cont.JoinGame(hey, 1);
var ahhh = cont.getUpdate(4);
//cont.UpdateGame(4, "2. Ke2");
var ahh = cont.getUpdate(4);
//cont.sendChat(4, "checkmate bitch you suck at chess");
var help = cont.getUpdate(4);
//var response = client.GetStringAsync("http://e05a8388588c.ngrok.io/FEN?FEN=rnbqk1nr%2Fpp1p1ppp%2F2p5%2F2b1p3%2F2B1P3%2F5Q2%2FPPPP1PPP%2FRNB1K1NR%20w%20KQkq%20-%200%204");
//Thread.Sleep(2000);
cont.botGame(1);
Console.WriteLine("stop here thanks");
}
public async void Test()
{
_databaseConnection.Connect();
/////////////////////////////////////
// OPERATIONAL, CONTEXUAL SCOPE... //
/////////////////////////////////////
// create a Writer to write to the database
IWriter writer = new Writer(_databaseConnection);
// create a Reader to read from the database
IReader reader = new Reader(_databaseConnection);
// create an Updater to update the database
IUpdater updater = new Updater(_databaseConnection);
Entry exampleMongoDBEntry = new Entry();
exampleMongoDBEntry.Message = "Hello";
// write the object to the "MyFirstCollection" Collection that exists within the
// previously referenced "MyFirstDatabase" that was used to create the "writer" object
writer.Write <Entry>("MyFirstCollection", exampleMongoDBEntry);
IEnumerable <Entry> readEntrys = reader.Read <Entry>("MyFirstCollection", // within this collection...
"Message", // for the object field "Description"
"Hello"); // return matches for 'Hello'
Assert.AreEqual(1, readEntrys.Count());
////////////////////////////////////
// AND ASYNCHRONOUS OPERATIONS... //
////////////////////////////////////
// read, write and update asynchronously using System.Threading.Task
IAsyncReader asyncReader = new AsyncReader(reader);
readEntrys = await asyncReader.ReadAsync <Entry>("MyFirstCollection", "Message", "Hello");
Assert.AreEqual(1, readEntrys.Count());
IAsyncWriter asyncWriter = new AsyncWriter(writer);
IAsyncUpdater asyncUpdater = new AsyncUpdater(updater);
// or delegate call backs
IAsyncDelegateReader asyncDelegateReader = new AsyncDelegateReader(reader);
asyncDelegateReader.AsyncReadCompleted += new ReadCompletedEvent(readerCallBack);
asyncDelegateReader.ReadAsync <Entry>("MyFirstCollection", "Message", "Hello");
_readerAutoResetEvent.WaitOne();
Assert.AreEqual(1, _asyncReadResults.Count());
IAsyncDelegateWriter asyncDelegateWriter = new AsyncDelegateWriter(writer);
IAsyncDelegateUpdater asyncDelegateUpdater = new AsyncDelegateUpdater(updater);
/////////////////////////////////////////////
// FOR A SERVER, DATABASE OR COLLECTION... //
/////////////////////////////////////////////
// get a little higher level with the EasyMongo.Database namespace to target a database for operations
IDatabaseReader databaseReader = new DatabaseReader(reader, asyncReader);
IDatabaseWriter databaseWriter = new DatabaseWriter(writer, asyncWriter);
IDatabaseUpdater databaseUpdater = new DatabaseUpdater(updater, asyncUpdater);
// or a little lower level with the EasyMongo.Collection namespace to target a specific Collection
ICollectionReader collectionReader = new CollectionReader(databaseReader, "MyFirstCollection");
ICollectionWriter collectionWriter = new CollectionWriter(databaseWriter, "MyFirstCollection");
ICollectionUpdater collectionUpdater = new CollectionUpdater(databaseUpdater, "MyFirstCollection");
///////////////////////////////////////////////
// TO RESTRICT CLIENT SCOPE (LAW OF DEMETER) //
///////////////////////////////////////////////
// operate only against "MyFirstDatabase"'s "MySecondCollection"
readEntrys = collectionReader.Read <Entry>("Message", "Hello");
Assert.AreEqual(1, readEntrys.Count());
/////////////////////
// GENERIC CLASSES //
/////////////////////
// Instead of defining generic type arguments at the method level,
// you can do it once at the class declaration
IWriter <Entry> writerT = new Writer <Entry>(writer);
writerT.Write("MySecondCollection", new Entry()
{
Message = "Goodbye World (Generically)"
});
///////////////////////////////
// SIMPLIFY CREATION VIA IoC //
///////////////////////////////
// because EasyMongo is a componentized framework built with blocks of functionality, EasyMongo
// works great with DI containers and Inversion of Control.
// here's an example of using the nuget Ninject extension to load EasyMongo mappings and a conn
// string from configuration
Ninject.IKernel kernel = new Ninject.StandardKernel();
ICollectionUpdater <Entry> collectionUpdaterT = kernel.TryGet <ICollectionUpdater <Entry> >();
// the alternative to this would be:
IServerConnection serverConn = new ServerConnection(LOCAL_MONGO_SERVER_CONNECTION_STRING);
IDatabaseConnection databaseConnn = new DatabaseConnection(serverConn, "MyFirstDatabase");
IDatabaseUpdater databaseUpdatr = new DatabaseUpdater(updater, asyncUpdater);
ICollectionUpdater collectionUpdaterTheHardWay = new CollectionUpdater(databaseUpdater, "MySecondCollection");
/////////////////////////
// SIMPLE QUERIES... //
/////////////////////////
databaseReader.Read <Entry>("MyFirstCollection", "Message", "Hello");
readEntrys = await databaseReader.ReadAsync <Entry>("MyFirstCollection", "Message", "Hello");
Assert.AreEqual(1, readEntrys.Count());
/////////////////////////
// POWERFUL QUERIES... //
/////////////////////////
// when more robust querying is needed leverage power of underlying MongoDB driver IMongoQuery
IMongoQuery query1 = Query.Matches("Message", new BsonRegularExpression("HE", "i"));
IEnumerable <Entry> queryResults = reader.Execute <Entry>("MyFirstCollection", query1);
Assert.AreEqual(1, queryResults.Count());
Assert.AreEqual("Hello", queryResults.ElementAt(0).Message);
//////////////////////
// AND COMBINATIONS //
//////////////////////
Entry exampleMongoDBEntry2 = new Entry();
exampleMongoDBEntry2.Message = "Hello Again";
Entry exampleMongoDBEntry3 = new Entry();
exampleMongoDBEntry3.Message = "Goodbye";
writer.Write <Entry>("MyFirstCollection", exampleMongoDBEntry2);
writer.Write <Entry>("MyFirstCollection", exampleMongoDBEntry3);
// "AND" multiple IMongoQueries...
IMongoQuery query2 = Query.Matches("Message", new BsonRegularExpression("Again"));
queryResults = reader.ExecuteAnds <Entry>("MyFirstCollection", new [] { query1, query2 });
Assert.AreEqual(1, queryResults.Count());
Assert.AreEqual("Hello Again", queryResults.ElementAt(0).Message);
// "OR" multiple IMongoQueries...
IMongoQuery query3 = Query.Matches("Message", new BsonRegularExpression("Goo"));
queryResults = reader.ExecuteOrs <Entry>("MyFirstCollection", new[] { query1, query2, query3 });
Assert.AreEqual(3, queryResults.Count());
Assert.AreEqual("Hello", queryResults.ElementAt(0).Message);
Assert.AreEqual("Hello Again", queryResults.ElementAt(1).Message);
Assert.AreEqual("Goodbye", queryResults.ElementAt(2).Message);
}
public static void Config(DatabaseUpdater updater)
{
updater.UpdateDatabase();
updater.SeedData().Wait();
}
private static ExitCode UpdateDataBase(CompatibilityError error, DatabaseUpdater dbUpdater, bool silent)
{
if(error is CompatibilityCheckVersionsError || error is CompatibilityUnableToOpenDatabaseError) {
if(error is CompatibilityCheckVersionsError) {
CompatibilityCheckVersionsError compatibilityCheckVersionsError = (CompatibilityCheckVersionsError)error;
Console.WriteLine(error.Message);
if(error is CompatibilityDatabaseIsOldError) {
if(compatibilityCheckVersionsError.Module != null &&
compatibilityCheckVersionsError.ModuleVersion != null &&
compatibilityCheckVersionsError.VersionFromDatabase != null) {
Console.WriteLine(
String.Format("The module '{0}' has version '{1}', the version from the database is '{2}'.",
compatibilityCheckVersionsError.Module.Name, compatibilityCheckVersionsError.ModuleVersion, compatibilityCheckVersionsError.VersionFromDatabase));
}
if(!silent) {
Console.WriteLine("Please backup the database before the update and press <Enter>.");
Console.ReadLine();
}
}
else {
Console.WriteLine(updateNotNeeded + ".");
return ExitCode.UpdateNotNeeded;
}
}
else {
if(!silent) {
Console.WriteLine("The database doesn't exist. It'll be created now.");
Console.WriteLine();
}
}
dbUpdater.Update();
Console.WriteLine();
Console.WriteLine(updateCompleted + ".");
Console.WriteLine();
if(!silent) {
Console.WriteLine("Please disconnect all connected users and press <Enter>.");
Console.ReadLine();
}
return ExitCode.UpdateCompleted;
}
else {
Console.WriteLine(updateError + ":");
Console.WriteLine(error.Message);
return ExitCode.UpdateError;
}
}
public async void Test()
{
_databaseConnection.Connect();
/////////////////////////////////////
// OPERATIONAL, CONTEXUAL SCOPE... //
/////////////////////////////////////
// create a Writer to write to the database
IWriter writer = new Writer(_databaseConnection);
// create a Reader to read from the database
IReader reader = new Reader(_databaseConnection);
// create an Updater to update the database
IUpdater updater = new Updater(_databaseConnection);
Entry exampleMongoDBEntry = new Entry();
exampleMongoDBEntry.Message = "Hello";
// write the object to the "MyFirstCollection" Collection that exists within the
// previously referenced "MyFirstDatabase" that was used to create the "writer" object
writer.Write<Entry>("MyFirstCollection", exampleMongoDBEntry);
IEnumerable<Entry> readEntrys = reader.Read<Entry>("MyFirstCollection", // within this collection...
"Message",// for the object field "Description"
"Hello");// return matches for 'Hello'
Assert.AreEqual(1, readEntrys.Count());
////////////////////////////////////
// AND ASYNCHRONOUS OPERATIONS... //
////////////////////////////////////
// read, write and update asynchronously using System.Threading.Task
IAsyncReader asyncReader = new AsyncReader(reader);
readEntrys = await asyncReader.ReadAsync<Entry>("MyFirstCollection", "Message", "Hello");
Assert.AreEqual(1, readEntrys.Count());
IAsyncWriter asyncWriter = new AsyncWriter(writer);
IAsyncUpdater asyncUpdater = new AsyncUpdater(updater);
// or delegate call backs
IAsyncDelegateReader asyncDelegateReader = new AsyncDelegateReader(reader);
asyncDelegateReader.AsyncReadCompleted += new ReadCompletedEvent(readerCallBack);
asyncDelegateReader.ReadAsync<Entry>("MyFirstCollection", "Message", "Hello");
_readerAutoResetEvent.WaitOne();
Assert.AreEqual(1, _asyncReadResults.Count());
IAsyncDelegateWriter asyncDelegateWriter = new AsyncDelegateWriter(writer);
IAsyncDelegateUpdater asyncDelegateUpdater = new AsyncDelegateUpdater(updater);
/////////////////////////////////////////////
// FOR A SERVER, DATABASE OR COLLECTION... //
/////////////////////////////////////////////
// get a little higher level with the EasyMongo.Database namespace to target a database for operations
IDatabaseReader databaseReader = new DatabaseReader(reader, asyncReader);
IDatabaseWriter databaseWriter = new DatabaseWriter(writer, asyncWriter);
IDatabaseUpdater databaseUpdater = new DatabaseUpdater(updater, asyncUpdater);
// or a little lower level with the EasyMongo.Collection namespace to target a specific Collection
ICollectionReader collectionReader = new CollectionReader(databaseReader, "MyFirstCollection");
ICollectionWriter collectionWriter = new CollectionWriter(databaseWriter, "MyFirstCollection");
ICollectionUpdater collectionUpdater = new CollectionUpdater(databaseUpdater, "MyFirstCollection");
///////////////////////////////////////////////
// TO RESTRICT CLIENT SCOPE (LAW OF DEMETER) //
///////////////////////////////////////////////
// operate only against "MyFirstDatabase"'s "MySecondCollection"
readEntrys = collectionReader.Read<Entry>("Message", "Hello");
Assert.AreEqual(1, readEntrys.Count());
/////////////////////
// GENERIC CLASSES //
/////////////////////
// Instead of defining generic type arguments at the method level,
// you can do it once at the class declaration
IWriter<Entry> writerT = new Writer<Entry>(writer);
writerT.Write("MySecondCollection", new Entry() { Message = "Goodbye World (Generically)" });
///////////////////////////////
// SIMPLIFY CREATION VIA IoC //
///////////////////////////////
// because EasyMongo is a componentized framework built with blocks of functionality, EasyMongo
// works great with DI containers and Inversion of Control.
// here's an example of using the nuget Ninject extension to load EasyMongo mappings and a conn
// string from configuration
Ninject.IKernel kernel = new Ninject.StandardKernel();
ICollectionUpdater<Entry> collectionUpdaterT = kernel.TryGet<ICollectionUpdater<Entry>>();
// the alternative to this would be:
IServerConnection serverConn = new ServerConnection(LOCAL_MONGO_SERVER_CONNECTION_STRING);
IDatabaseConnection databaseConnn = new DatabaseConnection(serverConn, "MyFirstDatabase");
IDatabaseUpdater databaseUpdatr = new DatabaseUpdater(updater, asyncUpdater);
ICollectionUpdater collectionUpdaterTheHardWay = new CollectionUpdater(databaseUpdater, "MySecondCollection");
/////////////////////////
// SIMPLE QUERIES... //
/////////////////////////
databaseReader.Read<Entry>("MyFirstCollection", "Message", "Hello");
readEntrys = await databaseReader.ReadAsync<Entry>("MyFirstCollection", "Message", "Hello");
Assert.AreEqual(1, readEntrys.Count());
/////////////////////////
// POWERFUL QUERIES... //
/////////////////////////
// when more robust querying is needed leverage power of underlying MongoDB driver IMongoQuery
IMongoQuery query1 = Query.Matches("Message", new BsonRegularExpression("HE", "i"));
IEnumerable<Entry> queryResults = reader.Execute<Entry>("MyFirstCollection", query1);
Assert.AreEqual(1, queryResults.Count());
Assert.AreEqual("Hello", queryResults.ElementAt(0).Message);
//////////////////////
// AND COMBINATIONS //
//////////////////////
Entry exampleMongoDBEntry2 = new Entry();
exampleMongoDBEntry2.Message = "Hello Again";
Entry exampleMongoDBEntry3 = new Entry();
exampleMongoDBEntry3.Message = "Goodbye";
writer.Write<Entry>("MyFirstCollection", exampleMongoDBEntry2);
writer.Write<Entry>("MyFirstCollection", exampleMongoDBEntry3);
// "AND" multiple IMongoQueries...
IMongoQuery query2 = Query.Matches("Message", new BsonRegularExpression("Again"));
queryResults = reader.ExecuteAnds<Entry>("MyFirstCollection", new []{ query1, query2});
Assert.AreEqual(1, queryResults.Count());
Assert.AreEqual("Hello Again", queryResults.ElementAt(0).Message);
// "OR" multiple IMongoQueries...
IMongoQuery query3 = Query.Matches("Message", new BsonRegularExpression("Goo"));
queryResults = reader.ExecuteOrs<Entry>("MyFirstCollection", new[] { query1, query2, query3 });
Assert.AreEqual(3, queryResults.Count());
Assert.AreEqual("Hello", queryResults.ElementAt(0).Message);
Assert.AreEqual("Hello Again", queryResults.ElementAt(1).Message);
Assert.AreEqual("Goodbye", queryResults.ElementAt(2).Message);
}
