public void Data_DatabaseWriter_RepeatingQueries()
{
var dbWriter = DatabaseWriter <CustomerInfo> .Construct();
var customer = new CustomerInfo();
// Multiple Gets
var a = dbWriter.GetAll().ToList();
var aCount = a.Count;
var b = dbWriter.GetAll().ToList();
var bCount = b.Count;
// datastore.Save
customer = dbWriter.GetByID(a.FirstOrDefaultSafe().ID);
customer.FirstName = DateTime.UtcNow.Ticks.ToString();
dbWriter = DatabaseWriter <CustomerInfo> .Construct(customer);
dbWriter.Save();
// Save check
var c = dbWriter.GetAll().ToList();
var cCount = c.Count;
Assert.IsTrue(aCount == bCount && bCount == cCount);
// customer.save
customer.Update();
// Multiple Gets
var x = dbWriter.GetAll().ToList();
var xCount = x.Count;
var y = dbWriter.GetAll().ToList();
var yCount = y.Count;
var z = dbWriter.GetAll().ToList();
var zCount = z.Count;
Assert.IsTrue(xCount == yCount && yCount == zCount);
}
private void Save(Action <DatabaseWriter> save)
{
IsEnabled = false;
var info = Cache.DbInfo;
var database = Cache.Database;
var writer = new DatabaseWriter();
info.OpenDatabaseFile(x => writer
.LoadExisting(x, info.Data.MasterKey));
save(writer);
info.SetDatabase(x => writer.Save(
x, database.RecycleBin));
IsEnabled = true;
ThreadPool.QueueUserWorkItem(_ => ListItems(
_group, Cache.Database.RecycleBin));
Cache.UpdateRecents();
lstHistory.ItemsSource = null;
ThreadPool.QueueUserWorkItem(_ =>
ListHistory(database));
Dispatcher.BeginInvoke(() =>
info.NotifyIfNotSyncable());
}
public void Data_DatabaseWriter_CountAny()
{
var db = DatabaseWriter <CustomerType> .Construct();
// GetAll() count and any
var resultsAll = db.GetAll();
Assert.IsTrue(resultsAll.Count() > 0);
Assert.IsTrue(resultsAll.Any());
// GetAll().Take(1) count and any
var resultsTake = db.GetAll().Take(1);
Assert.IsTrue(resultsTake.Count() == 1);
Assert.IsTrue(resultsTake.Any());
// Get an ID to test
var id = db.GetAllExcludeDefault().FirstOrDefaultSafe().ID;
Assert.IsTrue(id != TypeExtension.DefaultInteger);
// GetAll().Where count and any
var resultsWhere = db.GetAll().Where(x => x.ID == id);
Assert.IsTrue(resultsWhere.Count() > 0);
Assert.IsTrue(resultsWhere.Any());
}
public void Data_DatabaseWriter_Update()
{
var testEntity = new CustomerInfo();
var saver = DatabaseWriter <CustomerInfo> .Construct();
var oldFirstName = TypeExtension.DefaultString;
var newFirstName = DateTime.UtcNow.Ticks.ToString();
int entityID = TypeExtension.DefaultInteger;
var entityKey = TypeExtension.DefaultGuid;
// Create and capture original data
this.Data_DatabaseWriter_Insert();
testEntity = saver.GetAll().OrderByDescending(x => x.CreatedDate).FirstOrDefaultSafe();
oldFirstName = testEntity.FirstName;
entityID = testEntity.ID;
entityKey = testEntity.Key;
testEntity.FirstName = newFirstName;
Assert.IsTrue(testEntity.IsNew == false);
Assert.IsTrue(testEntity.ID != TypeExtension.DefaultInteger);
Assert.IsTrue(testEntity.Key != TypeExtension.DefaultGuid);
// Do Update
saver = DatabaseWriter <CustomerInfo> .Construct(testEntity);
saver.Save();
// Pull from DB and retest
testEntity = saver.GetByID(entityID);
Assert.IsTrue(testEntity.IsNew == false);
Assert.IsTrue(testEntity.ID == entityID);
Assert.IsTrue(testEntity.Key == entityKey);
Assert.IsTrue(testEntity.ID != TypeExtension.DefaultInteger);
Assert.IsTrue(testEntity.Key != TypeExtension.DefaultGuid);
}
public void Data_DatabaseWriter_Delete()
{
var dbWriter = DatabaseWriter <CustomerInfo> .Construct();
var testEntity = new CustomerInfo();
var oldID = TypeExtension.DefaultInteger;
var oldKey = TypeExtension.DefaultGuid;
// Insert and baseline test
this.Data_DatabaseWriter_Insert();
testEntity = dbWriter.GetAll().OrderByDescending(x => x.CreatedDate).FirstOrDefaultSafe();
oldID = testEntity.ID;
oldKey = testEntity.Key;
Assert.IsTrue(testEntity.IsNew == false);
Assert.IsTrue(testEntity.ID != TypeExtension.DefaultInteger);
Assert.IsTrue(testEntity.Key != TypeExtension.DefaultGuid);
// Do delete
dbWriter = DatabaseWriter <CustomerInfo> .Construct(testEntity);
dbWriter.Delete();
// Pull from DB and retest
testEntity = dbWriter.GetAll().Where(x => x.ID == oldID).FirstOrDefaultSafe();
Assert.IsTrue(testEntity.IsNew);
Assert.IsTrue(testEntity.ID != oldID);
Assert.IsTrue(testEntity.Key != oldKey);
Assert.IsTrue(testEntity.IsNew);
Assert.IsTrue(testEntity.Key == TypeExtension.DefaultGuid);
// Add to recycle bin for cleanup
DatabaseWriterTests.RecycleBin.Add(testEntity.ID);
}
protected void lnkViewForm_Click(object sender, EventArgs e)
{
var btn = sender as LinkButton;
if (btn != null)
{
var row = btn.NamingContainer as GridViewRow;
if (row != null)
{
gvCBC.SelectedIndex = row.RowIndex;
if (gvCBC.SelectedDataKey != null)
{
var year = gvCBC.SelectedDataKey[0].ToString();
var id = gvCBC.SelectedDataKey[1].ToString();
var taxRefNo = btn.CommandArgument.Split('|')[0];
var request = Request.QueryString["New"] == null ? 0 : Convert.ToInt32(Request.QueryString["New"]);
if (request == 0)
{
DatabaseWriter.UpdateViewedCBC(Convert.ToDecimal(id));
}
Response.Redirect(
string.Format(
"~/pages/cbcForm.aspx?incLocal={0}&refno={1}&year={2}&bck={3}&mspecId={4}"
, 1
, taxRefNo
, year
, Request.Url.PathAndQuery.ToBase64String()
, 0));
}
}
}
}
public void Data_DatabaseWriter_GetWhere()
{
// Plain EntityInfo object
var testData2 = DatabaseWriter <CustomerInfo> .Construct();
var testEntity2 = new CustomerInfo();
var testId2 = testData2.GetAllExcludeDefault().FirstOrDefaultSafe().ID;
testEntity2 = testData2.GetAll().Where(x => x.ID == testId2).FirstOrDefaultSafe();
Assert.IsTrue(testEntity2.IsNew == false);
Assert.IsTrue(testEntity2.ID != TypeExtension.DefaultInteger);
Assert.IsTrue(testEntity2.Key != TypeExtension.DefaultGuid);
// CrudEntity object
this.Data_DatabaseWriter_Insert();
var testData = DatabaseWriter <CustomerInfo> .Construct();
var testEntity = new CustomerInfo();
var testId = testData.GetAllExcludeDefault().FirstOrDefaultSafe().ID;
testEntity = testData.GetAll().Where(x => x.ID == testId).FirstOrDefaultSafe();
Assert.IsTrue(testEntity.IsNew == false);
Assert.IsTrue(testEntity.ID != TypeExtension.DefaultInteger);
Assert.IsTrue(testEntity.Key != TypeExtension.DefaultGuid);
}
public ProfileController()
{
client = new DatabaseClient();
reader = new DatabaseReader();
writer = new DatabaseWriter();
updater = new DatabaseUpdater();
}
public void Data_DatabaseWriter_GetByID()
{
var custData = DatabaseWriter <CustomerInfo> .Construct();
var custEntity = new CustomerInfo();
var randomID = custData.GetAll().FirstOrDefaultSafe().ID;
var randomID2 = custData.GetAll().OrderByDescending(x => x.ID).FirstOrDefaultSafe().ID;
// GetByID
var custGetByID = custData.GetByID(randomID);
var custFirstName = custGetByID.FirstName;
Assert.IsTrue(custGetByID.ID != TypeExtension.DefaultInteger);
Assert.IsTrue(custGetByID.Key != TypeExtension.DefaultGuid);
// By custom where
var fname = custData.GetAll().Where(y => y.FirstName == custFirstName);
Assert.IsTrue(fname.Any());
var fnEntity = fname.FirstOrDefaultSafe();
Assert.IsTrue(fnEntity.IsNew == false);
Assert.IsTrue(fnEntity.FirstName != TypeExtension.DefaultString);
// Where 1 record
custEntity = custData.GetAll().Take(1).FirstOrDefaultSafe();
Assert.IsTrue(custEntity.ID == randomID);
Assert.IsTrue(custEntity.IsNew == false);
}
public void WriteAsyncWhenResultIsValidShouldWriteToDatabase()
{
var factory = DatabaseHelper.GetMockConnectionFactory();
using (var connection = factory.CreateConnectionAsync().Result)
{
DatabaseHelper.CreateTablesIfNotExist();
var deviceId = AddDummyDevviceToInMemoryDatabase();
var result = new ConveyorSimulator.SimulationResult
{
Id = deviceId,
Speed = 213,
DateTime = DateTime.UtcNow,
PackageTrackingAlarmState = PackageTrackingAlarmState.Okay,
CurrentRecipeCount = 2,
CurrentBoards = 3
};
var writer = new DatabaseWriter(factory, Mock.Of <ILogger>());
writer.WriteAsync(result).Wait();
var results = connection.Query("SELECT * FROM DeviceReadings");
Assert.AreEqual(1, results.Count());
}
}
public void ApproveCBCReport(string taxRefNo, int year, int approved, string userId)
{
var result = DatabaseWriter.UpdateCBCStatus(approved, taxRefNo, year, userId);
if (approved == 1)
{
string Subject = "";
var email = string.IsNullOrEmpty(ADUser.CurrentUser.Mail) ? "*****@*****.**" : ADUser.CurrentUser.Mail;
string[] senderEmail = { email };
if (result.HasRows)
{
DateTime repperiod = Convert.ToDateTime(result.Tables[0].Rows[0]["ReportingPeriod"].ToString());
var reportingPeriod = repperiod.ToString("yyyy-MM-dd");
Subject = string.Format("New data came in for the reporting period {0} ", reportingPeriod);
Common.SendEmailToUsers(result, reportingPeriod, Subject, FDRPage.Statuses.DeletePackage, senderEmail);
Common.SendEmailToRole("Approver", reportingPeriod, Subject, FDRPage.Statuses.DeletePackage, senderEmail);
}
else
{
// DatabaseWriter.ApproveOutgoingCBC(outCBC.Id, countryCode, year, statusId, ADUser.CurrentSID);
Subject = string.Format("CBC for Tax No: {0} has been Accepted ", taxRefNo);
Common.SendEmailToRole("Reviewer", taxRefNo, Subject, FDRPage.Statuses.Accepted, senderEmail);
}
}
}
public int AddNewMne(
decimal partyId
, string taxpayerReferenceNumber
, int yearofAssessment
, string registeredName
, string tradingName
, string registrationNumber
, DateTime financialYearEnd
, decimal turnoverAmount
, string nameUltimateHoldingCo
, string ultimateHoldingCompanyResOutSaInd
, string taxResidencyCountryCodeUltimateHoldingCompany
, string ultimateHoldingCoIncomeTaxRefNo
, string masterLocalFileRequiredInd
, string cbCReportRequiredInd
, DateTime datestamp)
{
return(DatabaseWriter.SaveNewEntity(
partyId,
taxpayerReferenceNumber,
yearofAssessment,
registeredName,
tradingName,
registrationNumber,
financialYearEnd,
turnoverAmount,
nameUltimateHoldingCo,
ultimateHoldingCompanyResOutSaInd,
taxResidencyCountryCodeUltimateHoldingCompany,
ultimateHoldingCoIncomeTaxRefNo,
masterLocalFileRequiredInd,
cbCReportRequiredInd,
datestamp
));
}
public void WriteRecord_MultipleRecordsWithoutTransactionAndNoCommit_ChangesAreCommitted()
{
var people = Person.Faker.Generate(2);
var commands = new SqlCommand[]
{
DatabaseWriterTests.GenerateInsertPersonCommand(people[0]),
DatabaseWriterTests.GenerateInsertPersonCommand(people[1])
};
var commandFactory = MockRepository.GenerateMock <IDatabaseWriterCommandFactory>();
commandFactory.Stub(x => x.Create(Arg <object> .Is.Equal(people[0]))).Return(commands[0]);
commandFactory.Stub(x => x.Create(Arg <object> .Is.Equal(people[1]))).Return(commands[1]);
using (var databaseWriter = new DatabaseWriter(commandFactory, DatabaseWriterTests.DbConnectionString, false))
{
databaseWriter.Open();
databaseWriter.WriteRecord(people[0]);
databaseWriter.WriteRecord(people[1]);
}
using (var testDb = new TestDb(DatabaseWriterTests.DbConnectionString))
{
var records = testDb.Delete("dbo.Person", people.ToArray());
Assert.AreEqual(2, records.Length);
}
}
private void Save()
{
progBusy.IsBusy = true;
string groupId;
if (!NavigationContext.QueryString
.TryGetValue("group", out groupId))
{
groupId = null;
}
ThreadPool.QueueUserWorkItem(_ =>
{
var info = Cache.DbInfo;
var database = Cache.Database;
var writer = new DatabaseWriter();
info.OpenDatabaseFile(x => writer
.LoadExisting(x, info.Data.MasterKey));
if (_entry.ID != null)
{
_binding.Save();
writer.Details(_entry);
}
else
{
database.AddNew(
_entry, groupId);
writer.New(_entry);
}
info.SetDatabase(x => writer.Save(
x, database.RecycleBin));
Dispatcher.BeginInvoke(() =>
{
UpdateNotes();
progBusy.IsBusy = false;
_binding.HasChanges = false;
if (!info.NotifyIfNotSyncable())
{
new ToastPrompt
{
Title = Properties.Resources.SavedTitle,
Message = Properties.Resources.SavedCaption,
TextOrientation = System.Windows.Controls
.Orientation.Vertical,
}.Show();
}
});
ThreadPool.QueueUserWorkItem(
__ => Cache.AddRecent(_entry.ID));
});
}
public readonly Stream stream; //Stream is always open and is never closed.
public void SaveNow(string filename)
{
File.Delete(filename);
using (FileStream fs = new FileStream(filename, FileMode.Create))
{
DatabaseWriter.WriteDatabase(fs, tables);
}
}
public void WriteAsyncWhenResultIsNullShouldThrowArgumentNullException()
{
var writer = new DatabaseWriter(DatabaseHelper.GetMockConnectionFactory(), Mock.Of <ILogger>());
Func <Task> target = () => writer.WriteAsync(null);
Assert.ThrowsExceptionAsync <ArgumentNullException>(target);
}
public GameController()
{
client = new DatabaseClient();
reader = new DatabaseReader();
writer = new DatabaseWriter();
updater = new DatabaseUpdater();
rand = new Random();
}
public static void RemoveInstantElement <T>(this T table) where T : ITable
{
lock (Locker)
{
DatabaseWriter <T> .Remove(table);
ITableManager.RemoveFromCache(table);
}
}
public static void AddInstantElement <T>(this T table) where T : ITable
{
lock (Locker)
{
DatabaseWriter <T> .Insert(table);
ITableManager.AddToCache(table);
}
}
public static void Cleanup()
{
var db = DatabaseWriter <CustomerInfo> .Construct();
foreach (int item in CrudEntityTests.RecycleBin)
{
db.GetByID(item).Delete();
}
}
public void DatabaseWriter_Write_NotImplimented()
{
//arange
Writer w = new DatabaseWriter();
//act
bool sucess = w.Write("test");
//assert
Assert.IsTrue(sucess);
}
protected void btnGenerate_Click(object sender, EventArgs e)
{
Button btnGenerate = (Button)sender;
GridViewRow gvRow = (GridViewRow)btnGenerate.Parent.Parent;
Guid newUID = new Guid();
var xmldoc = new XmlDocument();
XmlNode messageSpec = xmldoc.CreateNode(XmlNodeType.Element, "MessageSpec", null);
var countryCode = gvRow.Cells[0].Text.Split('-')[1].Trim();
var country = gvRow.Cells[0].Text.Split('-')[0].Trim();
var year = int.Parse(gvRow.Cells[1].Text);
if (ValidateRequiredFields(year))
{
decimal id = 0;
var package = Common.GenerateNewPackage(countryCode, dpReportingPeriod.Text, ref messageSpec, id);
if (!string.IsNullOrEmpty(package.ToString()))
{
var outgoingCBC = new OutGoingCBCDeclarations()
{
Id = id,
Country = countryCode,
CBCData = package.ToString(),
NSCBCData = null,
StatusId = 2,
Year = year,
ReportingPeriod = DateTime.Parse(dpReportingPeriod.Text),
CreatedBy = Sars.Systems.Security.ADUser.CurrentSID
};
id = DatabaseWriter.SaveOutgoingCBC(outgoingCBC, ref newUID);
if (id > 0)
{
var newPackage = Common.GenerateNewPackage(countryCode, dpReportingPeriod.Text, ref messageSpec, id);
var newMessageSpec = messageSpec;
var nmPackage = Common.GenerateNMPackage(countryCode, dpReportingPeriod.Text, newMessageSpec);
var newPackagedCBC = new OutGoingCBCDeclarations()
{
Id = id,
Country = countryCode,
CBCData = newPackage.ToString(),
NSCBCData = nmPackage,
StatusId = 2,
Year = year,
CreatedBy = Sars.Systems.Security.ADUser.CurrentSID
};
var saved = DatabaseWriter.SaveOutgoingCBC(newPackagedCBC, ref newUID);
}
DBWriteManager.Insert_OutgoingPackageAuditTrail(newUID, Sars.Systems.Security.ADUser.CurrentSID, string.Format("Package for {0} generated", country));
LoadCBC();
MessageBox.Show(string.Format("Package for {0} was successfully generated", country));
}
}
}
private void Init(string dbName)
{
if (init) // Close existing connections
{
Close();
}
init = true;
dbWriter = new DatabaseWriter(dbName);
dbReader = new DatabaseReader(dbName);
Console.WriteLine("[DBADAPTER] Inited Database: " + dbName);
}
public static void RemoveInstantElement <T>(this T table, bool removefromList = true) where T : ITable
{
lock (Locker)
{
DatabaseWriter <T> .InstantRemove(table);
if (removefromList)
{
SaveTask.RemoveFromList(table);
}
}
}
public static void AddInstantElement <T>(this T table, bool addtolist = true) where T : ITable
{
lock (Locker)
{
DatabaseWriter <T> .InstantInsert(table);
if (addtolist)
{
SaveTask.AddToList(table);
}
}
}
public static void Cleanup()
{
var dbWriter = DatabaseWriter <CustomerInfo> .Construct();
var toDelete = new CustomerInfo();
foreach (int item in DatabaseWriterTests.RecycleBin)
{
toDelete = dbWriter.GetAll().Where(x => x.ID == item).FirstOrDefaultSafe();
dbWriter = DatabaseWriter <CustomerInfo> .Construct(toDelete);
dbWriter.Delete();
}
}
protected override List <Order> PreparePlaceOrders()
{
WriteToLogDB("PreparePlaceOrders", "Started");
Bar bar = DatabaseReader.SelectLastPrice(Symbol);
double lastPrice = bar.Close;
double buyPrice = RoundToStep(lastPrice - 0.02);
double sellPrice = RoundToStep(lastPrice + 0.02);
int buyVol = 0;
int sellVol = 0;
if (CurrentState.Position == 0)
{
buyVol = ContractsToTrade;
sellVol = ContractsToTrade;
}
else if (CurrentState.Position < 0)
{
buyVol = ContractsToTrade;
sellVol = ContractsToTrade - Math.Abs(CurrentState.Position);
}
else
{
buyVol = ContractsToTrade - Math.Abs(CurrentState.Position);
sellVol = ContractsToTrade;
}
if (buyPrice >= sellPrice || (buyPrice <= 0 && buyVol != 0) || (sellPrice <= 0 && sellVol != 0))
{
throw new SmartException(ExceptionImportanceLevel.HIGH, "PreparePlaceOrders", "ContrTrendStrat", "buyPrice = " + buyPrice + ", sellPrice = " + sellPrice);
}
WriteToLogDB("PreparePlaceOrders", "Buy: Price = " + buyPrice + ", Volume = " + buyVol + "; Sell: Price = " + sellPrice + ", Volume = " + sellVol);
List <Order> placeOrders = new List <Order>();
DateTime dTime = ServerTime.GetRealTime();
DatabaseWriter.InsertDecision(dTime, Symbol, ActionEnum.BUY, buyPrice, buyVol, 0);
DatabaseWriter.InsertDecision(dTime, Symbol, ActionEnum.SELL, sellPrice, sellVol, 0);
if (buyVol > 0)
{
placeOrders.Add(new Order(Symbol, GenerateCookie(), "", buyVol, 0, buyPrice, 0, ActionEnum.BUY, OrderTypeEnum.LIMIT));
}
if (sellVol > 0)
{
placeOrders.Add(new Order(Symbol, GenerateCookie(), "", sellVol, 0, sellPrice, 0, ActionEnum.SELL, OrderTypeEnum.LIMIT));
}
WriteToLogDB("PreparePlaceOrders", "Finished");
return(placeOrders);
}
private void SavePackage(StringBuilder package, decimal id, string countryCode, int year)
{
Guid newUid = new Guid();
var outgoingCBC = new OutGoingCBCDeclarations()
{
Id = id,
Country = countryCode,
NSCBCData = package.ToString(),
StatusId = 3,
Year = year,
CreatedBy = Sars.Systems.Security.ADUser.CurrentSID
};
decimal saved = DatabaseWriter.SaveOutgoingCBC(outgoingCBC, ref newUid);
}
public void Data_DatabaseWriter_GetAll()
{
var typeDB = DatabaseWriter <CustomerType> .Construct();
var typeResults = typeDB.GetAll().Take(1);
Assert.IsTrue(typeResults.Count() > 0);
this.Data_DatabaseWriter_Insert();
var custDB = DatabaseWriter <CustomerInfo> .Construct();
var custResults = custDB.GetAll().Take(1);
Assert.IsTrue(custResults.Count() > 0);
}
public void Data_DatabaseWriter_GetByKey()
{
// Should create 1 record
var custData = DatabaseWriter <CustomerInfo> .Construct();
var custCount = custData.GetAll().Count();
Assert.IsTrue(custCount > 0);
// ByKey Should return 1 record
var existingKey = custData.GetAll().FirstOrDefaultSafe().Key;
var custWhereKey = custData.GetByKey(existingKey);
Assert.IsTrue(custWhereKey.Key == existingKey);
Assert.IsTrue(custWhereKey.ID != TypeExtension.DefaultInteger);
}
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);
}
