public void TestPerfFillByKeyNormalVsExtensionMethod()
{
Helper.DropAllCollections();
//Insert de Paises
var c = new Country {
Code = "ES", Name = "España"
};
c.Save();
Stopwatch timer = Stopwatch.StartNew();
for (int i = 0; i < 1000000; i++)
{
var country = new Country();
country.FillByKey("ES");
}
timer.Stop();
Console.WriteLine(string.Format("Elapsed para ExtensionMethod: {0}", timer.Elapsed));
//Elapsed para ExtensionMethod: 00:04:38.5479462
timer = Stopwatch.StartNew();
for (int i = 0; i < 1000000; i++)
{
MongoMapper <Country> .FindByKey("ES");
}
timer.Stop();
Console.WriteLine(string.Format("Elapsed para StaticMethod: {0}", timer.Elapsed));
//Elapsed para StaticMethod: 00:04:27.1441065
}
public void AfterInsertDocument(
object Sender,
MongoMapper.OnAfterInsertEventHandler OnAfterInsert,
MongoMapper.OnAfterCompleteEventHandler OnAfterComplete,
Type ClassType)
{
if (OnAfterInsert != null)
{
OnAfterInsert(Sender, new EventArgs());
}
if (CustomContext.Rules != null)
{
CustomContext.Rules.OnAfterInsert(Sender, ClassType.Name);
}
if (OnAfterComplete != null)
{
OnAfterComplete(Sender, new EventArgs());
}
if (CustomContext.Rules != null)
{
CustomContext.Rules.OnAfterComplete(Sender, ClassType.Name);
}
if (CustomContext.CacheManager != null)
{
CustomContext.CacheManager.Insert(Sender, ClassType.Name);
}
}
public void BeforeDeleteDocument(object sender, MongoMapper.OnBeforeDeleteEventHandler onBeforeDelete,
Type classType)
{
if (onBeforeDelete != null) onBeforeDelete(sender, new EventArgs());
if (Context.Rules != null)
Context.Rules.OnBeforeDelete(sender, classType.Name);
}
public void BeforeUpdateDocument(object sender, MongoMapper.OnBeforeModifyEventHandler onBeforeModify,
Type classType)
{
if (onBeforeModify != null) onBeforeModify(sender, new EventArgs());
if (Context.Rules != null)
Context.Rules.OnBeforeModify(sender, classType.Name);
}
public async Task <string> Add(Lanyard lanyard)
{
var entity = MongoMapper.MapToEntity(lanyard, false);
await _collection.InsertOneAsync(entity);
return(entity.Id.ToString());
}
public async Task <Lanyard> Get(string id)
{
if (!ObjectId.TryParse(id, out var objectId))
{
return(null);
}
var entity = await _collection
.Find(x => x.Id == objectId)
.FirstOrDefaultAsync();
return(MongoMapper.MapToDTO(entity));
}
public async Task <bool> Update(Lanyard lanyard)
{
if (!ObjectId.TryParse(lanyard.Id, out var objectId))
{
return(false);
}
var entity = MongoMapper.MapToEntity(lanyard);
var result = await _collection.ReplaceOneAsync(x => x.Id == objectId, entity);
return(result.IsAcknowledged &&
result.IsModifiedCountAvailable &&
result.ModifiedCount > 0);
}
public void TestEvents()
{
Helper.DropAllCollections();
var c = new Country {
Code = "FR", Name = "España"
};
c.OnBeforeInsert += (s, e) => { ((Country)s).Name = "Francia"; };
c.Save();
var c3 = MongoMapper <Country> .FindByKey("FR");
Assert.AreEqual(c3.Name, "Francia");
}
public void AfterInsertDocument(object sender, MongoMapper.OnAfterInsertEventHandler onAfterInsert,
MongoMapper.OnAfterCompleteEventHandler onAfterComplete, Type classType)
{
if (onAfterInsert != null) onAfterInsert(sender, new EventArgs());
if (Context.Rules != null)
Context.Rules.OnAfterInsert(sender, classType.Name);
if (onAfterComplete != null) onAfterComplete(sender, new EventArgs());
if (Context.Rules != null)
Context.Rules.OnAfterComplete(sender, classType.Name);
if (Context.CacheManager != null)
Context.CacheManager.Insert(sender, classType.Name);
}
public void AfterUpdateDocument(object sender, MongoMapper.OnAfterModifyEventHandler onAfterModify,
MongoMapper.OnAfterCompleteEventHandler onAfterComplete, Type classType)
{
if (onAfterModify != null) onAfterModify(sender, new EventArgs());
if (Context.Rules != null)
Context.Rules.OnAfterModify(sender, classType.Name);
if (onAfterComplete != null) onAfterComplete(sender, new EventArgs());
if (Context.Rules != null)
Context.Rules.OnAfterComplete(sender, classType.Name);
if (Context.CacheManager != null)
Context.CacheManager.Update(sender, classType.Name);
}
public void TestServerDelete()
{
Helper.DropAllCollections();
for (int i = 0; i < 100; i++)
{
var c = new Country {
Code = i.ToString(), Name = String.Format("Nombre {0}", i)
};
c.Save();
Assert.AreEqual(i + 1, CountryCollection.Instance.Find().CountAsync().Result);
}
MongoMapper <Country> .ServerDelete(MongoQuery <Country> .Eq(c => c.Code, "0"));
Assert.AreEqual(99, CountryCollection.Instance.Find().CountAsync().Result);
}
public void TestUdpate()
{
Helper.DropAllCollections();
var c = new Country {
Code = "ES", Name = "España"
};
c.Save();
var c2 = MongoMapper <Country> .FindByKey("ES");
c2.Name = "España Up";
c2.Save();
var c3 = MongoMapper <Country> .FindByKey("ES");
Assert.AreEqual(c3.Name, "España Up");
var Countries = CountryCollection.Instance;
Countries.Find(x => x.Code, "ES");
Assert.AreEqual(Countries.Count, 1);
}
public void TestRelations()
{
Helper.DropAllCollections();
var c = new Country {
Code = "ES", Name = "España"
};
c.Save();
c = new Country {
Code = "UK", Name = "Reino Unido"
};
c.Save();
var p = new Person
{
Name = "Pepito Perez",
Age = 35,
BirthDate = DateTime.Now.AddDays(57).AddYears(-35),
Married = true,
Country = "XXXXX",
BankBalance = decimal.Parse("3500,00")
};
p.Childs.Add(
new Child {
ID = 1, Age = 10, BirthDate = DateTime.Now.AddDays(57).AddYears(-10), Name = "Juan Perez"
});
p.Childs.Add(
new Child {
ID = 2, Age = 7, BirthDate = DateTime.Now.AddDays(57).AddYears(-7), Name = "Ana Perez"
});
try
{
p.Save();
Assert.Fail();
}
catch (ValidateUpRelationException ex)
{
Assert.AreEqual(ex.GetBaseException().GetType(), typeof(ValidateUpRelationException));
p.Country = "ES";
p.Save();
}
c = MongoMapper <Country> .FindByKey("ES");
try
{
c.Delete();
Assert.Fail();
}
catch (ValidateDownRelationException ex)
{
Assert.AreEqual(ex.GetBaseException().GetType(), typeof(ValidateDownRelationException));
List <Person> persons = new List <Person>();
persons.MongoFind(C => C.Country, "ES");
foreach (Person p2 in persons)
{
p2.Country = "UK";
p2.Save();
}
c.Delete();
}
List <Person> personsInUk = new List <Person>();
personsInUk.MongoFind(C => C.Country, "UK");
foreach (Person personInUk in personsInUk)
{
Assert.AreEqual(personInUk.Country, "UK");
}
}
public void AfterUpdateDocument(
object Sender,
MongoMapper.OnAfterModifyEventHandler OnAfterModify,
MongoMapper.OnAfterCompleteEventHandler OnAfterComplete,
Type ClassType)
{
if (OnAfterModify != null)
{
OnAfterModify(Sender, new EventArgs());
}
if (CustomContext.Rules != null)
{
CustomContext.Rules.OnAfterModify(Sender, ClassType.Name);
}
if (OnAfterComplete != null)
{
OnAfterComplete(Sender, new EventArgs());
}
if (CustomContext.Rules != null)
{
CustomContext.Rules.OnAfterComplete(Sender, ClassType.Name);
}
if (CustomContext.CacheManager != null)
{
CustomContext.CacheManager.Update(Sender, ClassType.Name);
}
}
public void TestGroupSum()
{
Helper.DropAllCollections();
var c = new Country {
Code = "NL", Name = "Holanda"
};
c.Save();
c = new Country {
Code = "ES", Name = "SPAIN"
};
c.Save();
for (int i = 0; i < 10; i++)
{
var p = new Person
{
Name = i.ToString(),
Age = i,
BirthDate = DateTime.Now.AddDays(57).AddYears(-35),
Married = true,
Country = "ES",
BankBalance = decimal.Parse("3500,00")
};
p.Save();
}
for (int i = 0; i < 5; i++)
{
var p = new Person
{
Name = i.ToString(),
Age = i,
BirthDate = DateTime.Now.AddDays(57).AddYears(-35),
Married = true,
Country = "NL",
BankBalance = decimal.Parse("3500,00")
};
p.Save();
}
var operations = new[] {
new BsonDocument {
{
//$Country es $c
"$group", new BsonDocument {
{ "_id", "$" + MongoMapperHelper.ConvertFieldName("Person", "Country") },
{ "Total", new BsonDocument {
{ "$sum", 1 }
} },
}
}
}
};
var mongoresult = MongoMapper <Person> .Aggregate(operations);
foreach (var document in mongoresult)
{
if (document["_id"].ToString() == "ES")
{
Assert.AreEqual(10, int.Parse(document["Total"].ToString()));
}
else if (document["_id"].ToString() == "NL")
{
Assert.AreEqual(5, int.Parse(document["Total"].ToString()));
}
else
{
throw new InconclusiveException("");
}
}
}
public void ObjectComplete(object Sender, MongoMapper.OnObjectCompleteEventHandler OnObjectComplete, Type ClassType)
{
if (OnObjectComplete != null)
{
OnObjectComplete(Sender, new EventArgs());
}
}
public void ObjectInit(object Sender, MongoMapper.OnObjectInitEventHandler OnObjectInit, Type ClassType)
{
if (OnObjectInit != null)
{
OnObjectInit(Sender, new EventArgs());
}
}
public void BeforeUpdateDocument(
object Sender, MongoMapper.OnBeforeModifyEventHandler OnBeforeModify, Type ClassType)
{
if (OnBeforeModify != null)
{
OnBeforeModify(Sender, new EventArgs());
}
if (CustomContext.Rules != null)
{
CustomContext.Rules.OnBeforeModify(Sender, ClassType.Name);
}
}
public void BeforeInsertDocument(
object Sender, MongoMapper.OnBeforeInsertEventHandler OnBeforeInsert, Type ClassType)
{
if (OnBeforeInsert != null)
{
OnBeforeInsert(Sender, new EventArgs());
}
if (CustomContext.Rules != null)
{
CustomContext.Rules.OnBeforeInsert(Sender, ClassType.Name);
}
}
public static void MapAll()
{
MongoMapper.MapAll();
MongoMapper.Map <UserAccount>();
}
static void Main(string[] args)
{
IDBConnection<SqlConnection> sqlServerConnection = new SQLServerConnection();
var sqlServerDatabase = sqlServerConnection.GetDatabase("");
var sqlServerMapper = new SQLServerMapper<Client, DataSet>();
var sqlClientBL = GenericBLFactory<Client, Guid, IList<FilterQuery>, DataSet, SqlConnection>.Create(sqlServerConnection, "", "", sqlServerMapper);
sqlClientBL.GetById(new Guid());
//var sqlServerRepo = new SQLServerRepository<Client>("", null);
//sqlServerRepo.GetById("5");
string databaseName = "test";
string clientDocument = "client";
string employeeDocument = "employee";
// IoC configuration
var containerBuilder = new ContainerBuilder();
IConfigIoC manager = new IoCManager(containerBuilder);
manager.Configure();
IContainer builder = containerBuilder.Build();
var dbConnection = builder.Resolve<IDBConnection<IMongoDatabase>>();
//Connection
dbConnection.OpenConnection();
IMongoDatabase mongoDatabase = dbConnection.GetDatabase(databaseName);
//ClientBL
var clientMongoMapper = new MongoMapper<Client, BsonDocument>();
var clientBL = GenericBLFactory<Client, string, IList<FilterQuery>, BsonDocument, IMongoDatabase>.Create(dbConnection, databaseName, clientDocument, clientMongoMapper);
var employeeMongoMapper = new MongoMapper<Employee, BsonDocument>();
var employeeBL = GenericBLFactory<Employee, string, IList<FilterQuery>, BsonDocument, IMongoDatabase>.Create(dbConnection, databaseName, employeeDocument, employeeMongoMapper);
//Creation
var client = new Client("55554", "Joan");
var employee = new Employee("12", "Joan", "Wolters Kluwers");
//Insert
clientBL.Create(client);
employeeBL.Create(employee);
//GetById
var obtainedClient = clientBL.GetById(client.Id);
Console.WriteLine("Cliente insertado correctamente. Id: {0}, Name: {1}", obtainedClient.Id, obtainedClient.Name);
var obtainedEmployee = employeeBL.GetById(employee.Id);
Console.WriteLine("Employee insertado correctamente. Id: {0}, Name: {1}, WorkStation: {2}", obtainedEmployee.Id, obtainedEmployee.Name, obtainedEmployee.WorkStation);
Console.ReadLine();
//GetFiltered
IList<FilterQuery> queryGetFiltered = new List<FilterQuery>();
queryGetFiltered.Add(new FilterQuery("_id", "55554", "$eq"));
queryGetFiltered.Add(new FilterQuery("name", "Joan", "$eq"));
var resultGetFiltered = clientBL.GetFiltered(queryGetFiltered);
Console.WriteLine("Clientes encontrados:");
foreach (var oneClient in resultGetFiltered)
{
Console.WriteLine("Cliente encontrado: Id: {0}, Name: {1}", oneClient.Id, oneClient.Name);
}
IList<FilterQuery> queryGetFiltered2 = new List<FilterQuery>();
queryGetFiltered2.Add(new FilterQuery("_id", "12", "$eq"));
queryGetFiltered2.Add(new FilterQuery("workstation", "Wolters Kluwers", "$eq"));
var resultGetFiltered2 = employeeBL.GetFiltered(queryGetFiltered2);
Console.WriteLine("Employees encontrados:");
foreach (var oneEmployee in resultGetFiltered2)
{
Console.WriteLine("Employee encontrado Id: {0}, Name: {1}, WorkStation: {2}", oneEmployee.Id, oneEmployee.Name, oneEmployee.WorkStation);
}
Console.ReadLine();
}
