protected override void Exercise(IObjectContainer db)
{
Assert.AreEqual(1, db.Query(typeof(ConcurrentRenameTestCase.QueryItem)).Count);
ConcurrentRenameTestCase.QueryItem newItem = new ConcurrentRenameTestCase.QueryItem
();
db.Store(newItem);
db.Commit();
db.Delete(newItem);
db.Commit();
}
public Boolean alterarStatus(clsStatus objAtualizar)
{
try
{
if (!temDuplicidade(objAtualizar, "Alterar"))
{
clsStatus objStatusBuscar = new clsStatus();
objStatusBuscar.Codigo = objAtualizar.Codigo;
db = ServidorSingleton.obterServidor().OpenClient();
IObjectSet leitor = db.QueryByExample(objStatusBuscar);
clsStatus objStatus = (clsStatus)leitor.Next();
objStatus.Descricao = objAtualizar.Descricao;
db.Store(objStatus);
db.Commit();
db.Close();
db.Dispose();
return true;
}
else
{
return false;
}
}
catch (Exception ex)
{
throw new Exception("Erro atualizando o status :" + ex.ToString());
}
}
public void SetUp()
{
_filePath = Path.GetTempFileName();
//Db4objects.Db4o.Config.IConfiguration db4oConfiguration = Db4oFactory.Configure();
//Db4objects.Db4o.Config.IObjectClass objectClass = db4oConfiguration.ObjectClass(typeof(LanguageForm));
// objectClass.ObjectField("_writingSystemId").Indexed(true);
// objectClass.ObjectField("_form").Indexed(true);
_db = Db4oFactory.OpenFile(_filePath);
((YapStream) _db).GetNativeQueryHandler().QueryOptimizationFailure +=
OnQueryOptimizationFailure;
for (int i = 0;i < 10000;i++)
{
Entry e = new Entry();
e.name = new MultiText();
e.name._forms[0] = new LanguageForm("en", "en-" + i);
//e.name._forms[1] = new LanguageForm("fr", "fr-"+i);
e.name._singleForm = new LanguageForm("en", i.ToString());
_db.Set(e);
}
_db.Commit();
_db.Dispose();
_db = Db4oFactory.OpenFile(_filePath);
}
public Boolean cadastrarStatus(clsStatus objStatus)
{
try
{
if (!temDuplicidade(objStatus, "Cadastrar"))
{
objStatus.Codigo = obtemNovoId(); //Executa a solicitação de um novo id
db = ServidorSingleton.obterServidor().OpenClient();
db.Store(objStatus);
db.Commit();
return true;
}
else {
return false;
}
}
catch (Exception ex)
{
db.Rollback();
throw new Exception("Erro cadastrando o status :" + ex.ToString());
}
finally {
db.Close();
db.Dispose();
}
}
public Boolean cadastrarCliente(Cliente objCliente)
{
objCliente.Codigo = obtemNovoId();
try
{
if (!temDuplicidade(objCliente, "Cadastrar"))
{
db = ServidorSingleton.obterServidor().OpenClient();
db.Store(objCliente);
db.Commit();
return true;
}
else {
return false;
}
}
catch(Exception e)
{
throw new Exception("Erro cadastrando o cliente :" + e.Message);
}
finally {
db.Close();
db.Dispose();
}
}
public static void StoreCarCommit(IObjectContainer db)
{
Pilot pilot = new Pilot("Rubens Barrichello", 99);
Car car = new Car("BMW");
car.Pilot = pilot;
db.Store(car);
db.Commit();
}
public Boolean alterarFuncionario(Funcionario objFuncionarioAlterar)
{
try
{
if (!temDuplicidade(objFuncionarioAlterar, "Alterar"))
{
db = ServidorSingleton.obterServidor().OpenClient();
Funcionario objFuncionarioProt = FactoryClasses.criarFuncionario();
objFuncionarioProt.Codigo = objFuncionarioAlterar.Codigo;
IObjectSet leitor = db.QueryByExample(objFuncionarioProt);
if (leitor.HasNext())
{
Funcionario objFuncionario = (Funcionario)leitor.Next();
//Atribui o cargo
IObjectSet leitorCargo = db.QueryByExample(objFuncionarioAlterar.Cargo);
if (leitorCargo.HasNext())
{
Cargo objCargo = (Cargo)leitorCargo.Next();
objFuncionario.Cargo = objCargo;
}
leitorCargo = null;
objFuncionario.DataAdmissao = objFuncionarioAlterar.DataAdmissao;
objFuncionario.DataDemissao = objFuncionarioAlterar.DataDemissao;
objFuncionario.Email = objFuncionarioAlterar.Email;
objFuncionario.Login = objFuncionarioAlterar.Login;
objFuncionario.Nome = objFuncionarioAlterar.Nome;
objFuncionario.Senha = objFuncionarioAlterar.Senha;
objFuncionario.Telefone = objFuncionarioAlterar.Telefone;
db.Store(objFuncionario);
db.Commit();
leitor = null;
return true;
}
else
{
leitor = null;
return false;
}
}
else
{
return false;
}
}
catch (Exception ex)
{
db.Rollback();
throw new Exception("Erro atualizando o funcionario :" + ex.ToString());
}
finally
{
db.Close();
db.Dispose();
}
}
private static void RollbackChanges(IObjectContainer container)
{
// #example: Commit changes
container.Store(new Pilot("John"));
container.Store(new Pilot("Joanna"));
container.Commit();
// #end example
}
private static void StoreObjects(IObjectContainer container)
{
Random rnd = new Random();
for (int i = 0; i < 500000; i++)
{
container.Store(new DataObject(rnd));
}
container.Commit();
}
private static void WorkWithObjects(IObjectContainer container)
{
while (!Console.KeyAvailable)
{
Random rnd = new Random();
StoreData(container, rnd);
DeleteData(container, rnd);
container.Commit();
}
}
private static void TryToFragmentDatabase(IObjectContainer container)
{
while (!Console.KeyAvailable)
{
Random rnd = new Random();
StoreData(container, rnd);
DeleteData(container, rnd);
container.Commit();
}
}
public static void Setup()
{
if(File.Exists(Constants.DatabasePath))
{
File.Delete(Constants.DatabasePath);
}
_db = Db4oFactory.OpenFile(Constants.DatabasePath);
var settings = new Settings();
settings.ScreenName = "detroitpro";
_db.Store(settings);
_db.Commit();
}
public Boolean atualizarSolicitacao(SolicitacaoMateriais objSolicitacao)
{
SolicitacaoMateriais objSolicitacaoProt = FactoryClasses.criarSolicitacaoMateriais();
objSolicitacaoProt.Codigo = objSolicitacao.Codigo;
try
{
db = ServidorSingleton.obterServidor().OpenClient();
IObjectSet leitor = db.QueryByExample(objSolicitacaoProt);
if (leitor.HasNext())
{
SolicitacaoMateriais objSolicitacaoCache = (SolicitacaoMateriais)leitor.Next();
objSolicitacaoCache.GestorObra = objSolicitacao.GestorObra;
int i = 0;
foreach (Materiais material in objSolicitacaoCache.Materiais) {
if (material.Codigo == objSolicitacao.Codigo) {
Fornecedor objFornecedor = FactoryClasses.criarFornecedor();
objFornecedor.Codigo = objSolicitacao.Materiais[i].Fornecedor.Codigo;
material.Fornecedor = objFornecedor;
}
i++;
}
objSolicitacaoCache.Materiais = objSolicitacao.Materiais;
objSolicitacaoCache.Status = objSolicitacao.Status;
objSolicitacaoCache.DataEntrega = objSolicitacao.DataEntrega;
objSolicitacaoCache.NumNotaFiscal = objSolicitacao.NumNotaFiscal;
objSolicitacaoCache.DataEntrega = objSolicitacao.DataEntrega;
objSolicitacaoCache.Msg = objSolicitacao.Msg;
db.Store(objSolicitacaoCache);
db.Commit();
db.Close();
db.Dispose();
return true;
}
else
{
db.Close();
db.Dispose();
return false;
}
}
catch (Exception e)
{
db.Rollback();
db.Close();
db.Dispose();
throw new Exception("Erro atualizando a solicitação :" + e.Message);
}
}
public Boolean alterarFilme(clsFilme objAtualizar)
{
try
{
db = ServidorSingleton.obterServidor().OpenClient();
clsFilme filmeBuscar = new clsFilme();
filmeBuscar.Codigo = objAtualizar.Codigo;
IObjectSet leitor = db.QueryByExample(filmeBuscar);
if (leitor.HasNext())
{
clsFilme objFilme = (clsFilme)leitor.Next();
objFilme.Ano = objAtualizar.Ano;
objFilme.Avaliacao = objAtualizar.Avaliacao;
objFilme.TituloBr = objAtualizar.TituloBr;
objFilme.TituloOriginal = objAtualizar.TituloOriginal;
IObjectSet leitorGenero = db.QueryByExample(objAtualizar.Genero);
if (leitorGenero.HasNext()) {
objFilme.Genero = (clsGenero)leitorGenero.Next();
}
leitorGenero = null;
IObjectSet leitorStatus = db.QueryByExample(objAtualizar.Status);
if (leitorStatus.HasNext())
{
objFilme.Status = (clsStatus)leitorStatus.Next();
}
leitorStatus = null;
db.Store(objFilme);
db.Commit();
return true;
}
else
{
return false;
}
leitor = null;
}
catch (Exception ex)
{
db.Rollback();
throw new Exception("Erro atualizando o filme :" + ex.ToString());
}
finally {
db.Close();
db.Dispose();
}
}
private void DeleteAndReadd(IObjectContainer db, Collection4 removed)
{
var removeIter = removed.GetEnumerator();
while (removeIter.MoveNext())
{
db.Delete(removeIter.Current);
}
db.Commit();
var readdIter = removed.GetEnumerator();
while (readdIter.MoveNext())
{
db.Store(readdIter.Current);
}
db.Commit();
}
public Boolean alterarFornecedor(Fornecedor objFornecedorAtualizar)
{
try
{
if (!temDuplicidade(objFornecedorAtualizar, "Alterar"))
{
db = ServidorSingleton.obterServidor().OpenClient();
Fornecedor objFornecedorPrototipo = FactoryClasses.criarFornecedor();
objFornecedorPrototipo.Codigo = objFornecedorAtualizar.Codigo;
IObjectSet leitor = db.QueryByExample(objFornecedorPrototipo);
if (leitor.HasNext())
{
Fornecedor objFornecedor = (Fornecedor)leitor.Next();
objFornecedor.Cidade = objFornecedorAtualizar.Cidade;
objFornecedor.Cnpj = objFornecedorAtualizar.Cnpj;
objFornecedor.Email = objFornecedorAtualizar.Email;
objFornecedor.Endereco = objFornecedorAtualizar.Endereco;
objFornecedor.InscrEstadual = objFornecedorAtualizar.InscrEstadual;
objFornecedor.RazaoSocial = objFornecedorAtualizar.RazaoSocial;
db.Store(objFornecedor);
db.Commit();
leitor = null;
return true;
}
else
{
leitor = null;
return false;
}
}
else {
return false;
}
}
catch (Exception ex)
{
db.Rollback();
throw new Exception("Erro atualizando o fornecedor :" + ex.ToString());
}
finally
{
db.Close();
db.Dispose();
}
}
public Boolean alterarCliente(Cliente objClienteAtualizar)
{
try
{
if (!temDuplicidade(objClienteAtualizar, "Alterar"))
{
db = ServidorSingleton.obterServidor().OpenClient();
Cliente objClientePrototipo = FactoryClasses.criarCliente();
objClientePrototipo.Codigo = objClienteAtualizar.Codigo;
IObjectSet leitor = db.QueryByExample(objClientePrototipo);
if (leitor.HasNext())
{
Cliente objCliente = (Cliente)leitor.Next();
objCliente.Cnpj = objClienteAtualizar.Cnpj;
objCliente.Nome = objClienteAtualizar.Nome;
db.Store(objCliente);
db.Commit();
leitor = null;
return true;
}
else
{
leitor = null;
return false;
}
}
else {
return false;
}
}
catch (Exception ex)
{
db.Rollback();
throw new Exception("Erro atualizando o cliente :" + ex.ToString());
}
finally
{
db.Close();
db.Dispose();
}
}
public void AddProxyInfoToDb(ProxyAuthentication proxyAuthObj)
{
if (Db4oClient.RecentConnFile == null)
{
Db4oClient.RecentConnFile = Config.OMNConfigDatabasePath();
}
_proxyAuthObj = proxyAuthObj;
_container = Db4oClient.RecentConn;
ProxyAuthenticator proxyobj = ReturnProxyAuthenticationInfo();
if (proxyobj == null)
{
_container.Store(this);
}
else
{
proxyobj._proxyAuthObj = proxyAuthObj;
_container.Store(proxyobj);
}
_container.Commit();
_container.Ext().Refresh(proxyobj, 1);
}
public Boolean cadastrarGenero(clsGenero objGenero)
{
try
{
if (!temDuplicidade(objGenero, "Cadastrar")) //Verifica se já existe
{
objGenero.Codigo = obtemNovoId();
db = ServidorSingleton.obterServidor().OpenClient();
db.Store(objGenero);
db.Commit();
db.Close();
db.Dispose();
return true;
} else {
return false;
}
}
catch (Exception ex)
{
throw new Exception("Erro cadastrando o genero :" + ex.ToString());
}
}
private void EnsureMetaDataAreKnown(IObjectContainer client)
{
client.Store(new QueryInCallBackCSCallback.MetaInfo());
client.Store(new QueryInCallBackCSCallback.ToStore());
client.Commit();
}
public Boolean excluirStatus(clsStatus objStatus)
{
FilmeDAO objFilmeDAO = new FilmeDAO();
if (!objFilmeDAO.temStatusEmFilme(objStatus))
{
try
{
db = ServidorSingleton.obterServidor().OpenClient();
IObjectSet leitor = db.QueryByExample(objStatus);
clsStatus s = (clsStatus)leitor.Next();
db.Delete(s);
db.Commit();
return true;
}
catch (Exception ex)
{
throw new Exception("Erro tentando excluir o Status :" + ex.ToString());
}
finally
{
db.Close();
db.Dispose();
}
}
else {
return false;
}
}
private void Store(IObjectContainer container, object obj)
{
container.Store(obj);
container.Commit();
}
private void AgregoInstancia()
{
try
{
if (!bEdit)
{//es una bonita alta
IObjectContainer dbcliente = Db4oFactory.OpenFile(_InstancesFile);
Instancia _tmpInstancia = new Instancia();
_tmpInstancia.File = txtFile.Text;
_tmpInstancia.AutoInit = chkStart.Checked;
_tmpInstancia.Password = txtPassword.Text;
_tmpInstancia.Port = txtPort.Text;
_tmpInstancia.Server = txtServer.Text;
_tmpInstancia.User = txtUser.Text;
_tmpInstancia.FileUsers = _UsersFile;
dbcliente.Set(_tmpInstancia);
dbcliente.Commit();
dbcliente.Close();
}
else
{//es un bonito edit
if (instanciasEdit != null && sOldFile.Trim().Length > 0)
{
foreach (Instancia Ins in instanciasEdit)
{
RunServer _tempServer = new RunServer(Ins);
if (_tempServer.IsRunning())//detengo el servicio
{
_tempServer.Stop();
}
Ins.File = txtFile.Text.Trim();
Ins.Password = txtPassword.Text;
Ins.User = txtUser.Text.Trim();
Ins.Port = txtPort.Text.Trim();
Ins.Server = txtServer.Text.Trim();
Ins.AutoInit = chkStart.Checked;
if (Ins.FileUsers == null)
{
Ins.FileUsers = _UsersFile;
}
dbclienteEdit.Set(Ins);
foreach (TreeNode nodo in treeFiles.Nodes[0].Nodes)
{
if (nodo.Text == NombreArchivo(sOldFile))
{
nodo.Remove();
nodo.Text = NombreArchivo(Ins.File);
}
}
}
dbclienteEdit.Commit();
dbclienteEdit.Close();
ClearEdit();
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
/*finally
* {
* dbclienteEdit.Close();
* }*/
}
private static void ConcurrencyLimitations()
{
DeleteDatabases();
// #example: Lost replication
IObjectServer serverDatabase = OpenDatabaseServer(DesktopDatabaseName);
IObjectContainer mobileDatabase = OpenDatabase(MobileDatabaseName);
{
IObjectContainer serverDbConnection =
Db4oClientServer.OpenClient(Host, Port, UserName, UserName);
serverDbConnection.Store(new Pilot("Pilot 1"));
serverDbConnection.Commit();
// The replication starts here
IObjectContainer connectionForReplication =
Db4oClientServer.OpenClient(Host, Port, UserName, UserName);
IReplicationProvider clientReplication
= new Db4oEmbeddedReplicationProvider(connectionForReplication);
IReplicationProvider mobileRelicationPartner
= new Db4oEmbeddedReplicationProvider(mobileDatabase);
IReplicationSession replicationSession =
Replication.Begin(clientReplication, mobileRelicationPartner);
IObjectSet changesOnDesktop =
replicationSession.ProviderA().ObjectsChangedSinceLastReplication();
// during the replication other clients store data on the server
serverDbConnection.Store(new Pilot("Pilot 2"));
serverDbConnection.Commit();
foreach (object changedObjectOnDesktop in changesOnDesktop)
{
replicationSession.Replicate(changedObjectOnDesktop);
}
replicationSession.Commit();
serverDbConnection.Store(new Pilot("Pilot 3"));
serverDbConnection.Commit();
}
// Pilot 2 is not replicated
PrintPilots(mobileDatabase);
{
IObjectContainer connectionForReplication =
Db4oClientServer.OpenClient(Host, Port, UserName, UserName);
IReplicationProvider clientRelicationPartner
= new Db4oEmbeddedReplicationProvider(connectionForReplication);
IReplicationProvider mobileRelicationPartner
= new Db4oEmbeddedReplicationProvider(mobileDatabase);
IReplicationSession replicationSession =
Replication.Begin(clientRelicationPartner, mobileRelicationPartner);
IObjectSet changesOnDesktop =
replicationSession.ProviderA().ObjectsChangedSinceLastReplication();
foreach (object changedOnDesktop in changesOnDesktop)
{
replicationSession.Replicate(changedOnDesktop);
}
replicationSession.Commit();
}
// Pilot 2 is still not replicated
PrintPilots(mobileDatabase);
// #end example
serverDatabase.Close();
mobileDatabase.Close();
}
private static void StorePilot(IObjectContainer container)
{
container.Store(new Pilot("John"));
container.Commit();
}
internal void RenameFolderInDatabase(FavouriteFolder oldFavFolder, FavouriteFolder newFavFolder)
{
try
{
container = Db4oClient.RecentConn;
FavouriteList favList = FetchAllFavouritesForAConnection();
List<FavouriteFolder> lstFavFolder = favList.lstFavFolder;
bool check = false;
FavouriteFolder temp = null;
foreach (FavouriteFolder str in lstFavFolder)
{
if (str != null)
{
if (str.FolderName.Equals(oldFavFolder.FolderName))
{
temp = str;
check = true;
break;
}
}
}
if (check == true)
{
lstFavFolder.Remove(temp);
container.Delete(temp);
temp.FolderName = newFavFolder.FolderName;
lstFavFolder.Add(temp);
favList.lstFavFolder = lstFavFolder;
container.Ext().Store(favList, 5);
container.Commit();
}
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
private void Store(IObjectContainer container, object obj)
{
container.Store(obj);
container.Commit();
}
private void importRelationsBtn_Click(object sender, RoutedEventArgs e)
{
var lines = loadFile();
if (lines.Count() == 0)
{
return;
}
var counterA = 0;
var counterP = 0;
for (int i = lines.Count() - 1; i > 0; i--)
{
if (lines[i].IndexOf(';') != -1)
{
string[] elements = lines[i].Split(new string[] { ";" }, StringSplitOptions.None);
if (elements.Count() == 2)
{
var artCheck = _db.QueryByExample(new Article()
{
Title = elements[0].Trim()
});
var bookCheck = _db.QueryByExample(new Book()
{
Title = elements[0].Trim()
});
var autCheck = _db.QueryByExample(new Author()
{
LastName = elements[1].Trim()
});
IObjectSet check = null;
if (bookCheck.Count == 1)
{
check = bookCheck;
}
if (artCheck.Count == 1)
{
check = artCheck;
}
if (check != null && autCheck.Count == 1)
{
var publication = check.Next() as Publication;
var author = autCheck.Next() as Author;
if (!publication.Authors.Contains(author))
{
publication.Authors.Add(author);
_db.Store(publication.Authors);
counterA++;
}
if (!author.Publications.Contains(publication))
{
author.Publications.Add(publication);
_db.Store(author.Publications);
counterP++;
}
}
else
{
MessageBox.Show(String.Format(
"Relacja nie pasująca do niczego:\n{0}\n{1}",
elements[0].Trim(),
elements[1].Trim()
));
}
}
}
}
_db.Commit();
MessageBox.Show(String.Format("Dodano relacje:\nautorów: {0}\npubliacji: {1}", counterP, counterA));
showAuthorsList();
}
protected override void SaveChanges()
{
Container.Commit();
}
private static void RunOperations(IObjectContainer container)
{
var joe = (from Person p in container
where p.Name.Equals("Joe")
select p).First();
joe.Name = "Joe Senior";
container.Store(joe);
container.Store(new Person("Joe Junior"));
container.Commit();
}
private void FillRelationsOfEntity(Type entityType, IObjectContainer container)
{
var relations = GetRelationsOfEntity(entityType);
if (relations == null || relations.Count == 0)
{
return;
}
var fillingEventArgs = new MigratorFillingTypeRelationsEventArgs
{
TypeRelationsToFill = relations,
EntityType = entityType
};
OnFillingType(fillingEventArgs);
if (fillingEventArgs.Cancel ||
(fillingEventArgs.TypeRelationsToFill == null || fillingEventArgs.TypeRelationsToFill.Count == 0))
{
return;
}
relations = fillingEventArgs.TypeRelationsToFill;
var properties = entityType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.SetProperty);
var fields = entityType.GetFields(BindingFlags.NonPublic | BindingFlags.Instance);
var entityQuery = container.Query();
entityQuery.Constrain(entityType);
var entityList = entityQuery.Execute().ToList <object>(container, 1);
var entityListCount = entityList == null ? 0 : entityList.Count;
if (entityListCount == 0)
{
return;
}
var entityTempCount = 0;
foreach (var entity in entityList)
{
foreach (var relation in relations)
{
var propertyAttrib = relation.Key;
var relAttrib = relation.Value;
if (!relAttrib.IsEntityParent)
{
#region FIND AND SET PARENT PROPERTY
var parentQuery = container.Query();
parentQuery.Constrain(propertyAttrib.PropertyType);
var colsCount = relAttrib.ParentColumnNames.Count();
for (var i = 0; i < colsCount; i++)
{
var propertyName = relAttrib.PropertyNames[i];
var foreigFieldName = relAttrib.ForeignFieldNames[i];
var propertyInfo = properties.Single(prop => prop.Name.Equals(propertyName));
var propertyValue = propertyInfo.GetValue(entity, null);
parentQuery.Descend(foreigFieldName).Constrain(propertyValue).Equal();
}
var parent = parentQuery.Execute().ToList <object>(container, 1).SingleOrDefault();
if (parent == null)
{
continue;
}
propertyAttrib.SetValue(entity, parent, null);
#endregion
}
else
{
#region FIND CHILD PROPERTIES
var collectionType = propertyAttrib.PropertyType.GetGenericTypeDefinition();
var collectionField = fields.Single(fl => fl.Name.Equals(relAttrib.PrivateCollectionFieldName));
var childType = propertyAttrib.PropertyType.GetGenericArguments()[0];
var childQuery = container.Query();
childQuery.Constrain(childType);
var colsCount = relAttrib.ChildColumnNames.Count();
for (var i = 0; i < colsCount; i++)
{
var propertyName = relAttrib.PropertyNames[i];
var foreigFieldName = relAttrib.ForeignFieldNames[i];
var propertyInfo = properties.Single(prop => prop.Name.Equals(propertyName));
var propertyValue = propertyInfo.GetValue(entity, null);
childQuery.Descend(foreigFieldName).Constrain(propertyValue).Equal();
}
var childs = childQuery.Execute().ToList <object>(container, 1);
if (childs == null || childs.Count == 0)
{
continue;
}
var constructedType = collectionType.MakeGenericType(childType);
var childCollection = Activator.CreateInstance(constructedType);
var addMehod = childCollection.GetType().GetMethod("Add");
foreach (var child in childs)
{
addMehod.Invoke(childCollection, new[] { child });
}
collectionField.SetValue(entity, childCollection);
#endregion
}
}
entityTempCount++;
if (entityTempCount != EntitiesCommitLimit)
{
continue;
}
container.Commit();
entityTempCount = 0;
}
if (entityTempCount > 0)
{
container.Commit();
}
var filledEventArgs = new MigratorFilledTypeRelationsEventArgs
{
EntityType = entityType
};
OnFilledType(filledEventArgs);
}
public Boolean alterarMaterial(Materiais objMaterialAtualizar)
{
try
{
if (!temDuplicidade(objMaterialAtualizar, "Alterar"))
{
db = ServidorSingleton.obterServidor().OpenClient();
//Carrega o fornecedor
IObjectSet leitorFornecedor = db.QueryByExample(objMaterialAtualizar.Fornecedor);
if (leitorFornecedor.HasNext())
{
objMaterialAtualizar.Fornecedor = (Fornecedor)leitorFornecedor.Next();
}
leitorFornecedor = null;
//Carrega o comprador
IObjectSet leitorComprador = db.QueryByExample(objMaterialAtualizar.Comprador);
if (leitorComprador.HasNext())
{
objMaterialAtualizar.Comprador = (Comprador)leitorComprador.Next();
}
leitorComprador = null;
Materiais objMaterialPrototipo = FactoryClasses.criarMateriais();
objMaterialPrototipo.Codigo = objMaterialAtualizar.Codigo;
IObjectSet leitor = db.QueryByExample(objMaterialPrototipo);
if (leitor.HasNext())
{
Materiais objMaterial = (Materiais)leitor.Next();
objMaterial.Unidade = objMaterialAtualizar.Unidade;
objMaterial.Comprador = objMaterialAtualizar.Comprador;
objMaterial.Descricao = objMaterialAtualizar.Descricao;
objMaterial.DescricaoPopular = objMaterialAtualizar.DescricaoPopular;
objMaterial.Fornecedor = objMaterialAtualizar.Fornecedor;
objMaterial.ValorCompra = objMaterialAtualizar.ValorCompra;
objMaterial.ValorVenda = objMaterialAtualizar.ValorVenda;
db.Store(objMaterial);
db.Commit();
leitor = null;
return true;
}
else
{
leitor = null;
return false;
}
}
else {
return false;
}
}
catch (Exception ex)
{
db.Rollback();
throw new Exception("Erro atualizando o material :" + ex.ToString());
}
finally
{
db.Close();
db.Dispose();
}
}
public Boolean cadastrarMaterial(Materiais objMaterial)
{
objMaterial.Codigo = obtemNovoId();
try
{
if (!temDuplicidade(objMaterial, "Cadastrar"))
{
db = ServidorSingleton.obterServidor().OpenClient();
//Carrega o fornecedor
IObjectSet leitorFornecedor = db.QueryByExample(objMaterial.Fornecedor);
if (leitorFornecedor.HasNext())
{
objMaterial.Fornecedor = (Fornecedor)leitorFornecedor.Next();
}
leitorFornecedor = null;
//Carrega o comprador
IObjectSet leitorComprador = db.QueryByExample(objMaterial.Comprador);
if (leitorComprador.HasNext())
{
objMaterial.Comprador = (Comprador)leitorComprador.Next();
}
leitorComprador = null;
db.Store(objMaterial);
db.Commit();
return true;
}
else {
return false;
}
}
catch(Exception e)
{
throw new Exception("Erro cadastrando o material :" + e.Message);
}
finally {
db.Close();
db.Dispose();
}
}
internal void AddFolderToDatabase(FavouriteFolder favFolder)
{
try
{
container = Db4oClient.RecentConn;
if (m_lstFavfolder != null)
{
FavouriteList favList = FetchAllFavouritesForAConnection();
if (favList == null)
{
favList = new FavouriteList(m_connParam);
List<FavouriteFolder> lstFavfolder = new List<FavouriteFolder>();
favList.m_TimeOfCreation = Sharpen.Runtime.CurrentTimeMillis();
lstFavfolder.Add(favFolder);
container.Store(favList);
container.Commit();
return;
}
container.Activate(favList, 5);
List<FavouriteFolder> lstFavFolder = favList.lstFavFolder;
bool check = false;
FavouriteFolder temp = null;
foreach (FavouriteFolder str in lstFavFolder)
{
if (str != null)
{
if (str.FolderName.Equals(favFolder.FolderName))
{
temp = str;
check = true;
break;
}
}
}
if (check == false)
{
lstFavFolder.Add(favFolder);
}
else
{
lstFavFolder.Remove(temp);
lstFavFolder.Add(favFolder);
container.Delete(temp);
}
favList.lstFavFolder = lstFavFolder;
container.Ext().Store(favList, 5);
container.Commit();
}
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
public Boolean excluirFilme(clsFilme objFilme)
{
db = ServidorSingleton.obterServidor().OpenClient();
try
{
IObjectSet leitor = db.QueryByExample(objFilme);
if (leitor.HasNext())
{
db.Delete((clsFilme)leitor.Next());
db.Commit();
return true;
}
else {
return false;
}
}
catch
{
db.Rollback();
return false;
}
finally {
db.Close();
db.Dispose();
}
}
private void Populate(IObjectContainer container)
{
for (int i = 0; i < 10; i++)
{
container.Store(new CrashSimulatingTestSuite.Item("delme"));
}
CrashSimulatingTestSuite.CrashData one = new CrashSimulatingTestSuite.CrashData(null
, "one");
CrashSimulatingTestSuite.CrashData two = new CrashSimulatingTestSuite.CrashData(one
, "two");
CrashSimulatingTestSuite.CrashData three = new CrashSimulatingTestSuite.CrashData
(one, "three");
container.Store(one);
container.Store(two);
container.Store(three);
container.Commit();
IObjectSet objectSet = container.Query(typeof(CrashSimulatingTestSuite.Item));
while (objectSet.HasNext())
{
container.Delete(objectSet.Next());
}
}
public void cadastrarFilme(clsFilme objFilme)
{
objFilme.Codigo = obtemNovoId();
db = ServidorSingleton.obterServidor().OpenClient();
try
{
//Coloca o genero em cache para não ser inserido novamente
IObjectSet leitorGenero = db.QueryByExample(objFilme.Genero);
if (leitorGenero.HasNext())
{
objFilme.Genero = (clsGenero)leitorGenero.Next();
}
leitorGenero = null;
//Coloca o status em cache para não ser inserido novamente
IObjectSet leitorStatus = db.QueryByExample(objFilme.Status);
if (leitorStatus.HasNext()) {
objFilme.Status = (clsStatus)leitorStatus.Next();
}
leitorStatus = null;
//Grava o filme
db.Store(objFilme);
db.Commit();
}
catch (Exception)
{
db.Rollback();
throw new Exception("Erro cadastrando o filme :" + ex.ToString());
}
finally {
db.Close();
db.Dispose();
}
}
private void FillRelationsOfEntity(Type entityType, IObjectContainer db4OContainer, int poolCount)
{
var relations = MigratorUtilities.GetRelationsOfEntity(entityType);
if (relations == null || relations.Count == 0)
{
return;
}
var properties = entityType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.SetProperty);
var fields = entityType.GetFields(BindingFlags.NonPublic | BindingFlags.Instance);
var entityQuery = db4OContainer.Query();
entityQuery.Constrain(entityType);
var entityList = entityQuery.Execute().ToList <object>(db4OContainer, 1);
var entityListCount = entityList == null ? 0 : entityList.Count;
if (entityListCount == 0)
{
return;
}
var entityTempCount = 0;
var blder = new StringBuilder();
foreach (var entity in entityList)
{
//foreach (var relation in relations)
//{
// var propertyAttrib = relation.Key;
// var relAttrib = relation.Value;
// if (!relAttrib.IsEntityParent)
// {
// #region FIND AND SET PARENT PROPERTY
// var parentQuery = db4OContainer.Query();
// parentQuery.Constrain(propertyAttrib.PropertyType);
// var colsCount = relAttrib.ParentColumnNames.Count();
// for (var i = 0; i < colsCount; i++)
// {
// var propertyName = relAttrib.PropertyNames[i];
// var foreigFieldName = relAttrib.ForeignFieldNames[i];
// var propertyInfo = properties.Single(prop => prop.Name.Equals(propertyName));
// var propertyValue = propertyInfo.GetValue(entity, null);
// parentQuery.Descend(foreigFieldName).Constrain(propertyValue).Equal();
// }
// var parent = parentQuery.Execute().ToList<object>(db4OContainer, 1).SingleOrDefault();
// if (parent == null)
// continue;
// propertyAttrib.SetValue(entity, parent, null);
// #endregion
// }
// else
// {
// #region FIND CHILD PROPERTIES
// var collectionType = propertyAttrib.PropertyType.GetGenericTypeDefinition();
// var collectionField = fields.Single(fl => fl.Name.Equals(relAttrib.PrivateCollectionFieldName));
// var childType = propertyAttrib.PropertyType.GetGenericArguments()[0];
// var childQuery = db4OContainer.Query();
// childQuery.Constrain(childType);
// var colsCount = relAttrib.ChildColumnNames.Count();
// for (var i = 0; i < colsCount; i++)
// {
// var propertyName = relAttrib.PropertyNames[i];
// var foreigFieldName = relAttrib.ForeignFieldNames[i];
// var propertyInfo = properties.Single(prop => prop.Name.Equals(propertyName));
// var propertyValue = propertyInfo.GetValue(entity, null);
// childQuery.Descend(foreigFieldName).Constrain(propertyValue).Equal();
// }
// var childs = childQuery.Execute().ToList<object>(db4OContainer, 1);
// if (childs == null || childs.Count == 0)
// continue;
// var constructedType = collectionType.MakeGenericType(childType);
// var childCollection = Activator.CreateInstance(constructedType);
// var addMehod = childCollection.GetType().GetMethod("Add");
// foreach (var child in childs)
// addMehod.Invoke(childCollection, new[] { child });
// collectionField.SetValue(entity, childCollection);
// #endregion
// }
//}
if (entityType.ToString().Contains("CreditCard"))
{
try
{
db4OContainer.Store(entity);
db4OContainer.Ext().Purge(entity);
db4OContainer.Commit();
}
catch (Exception excep)
{
blder.AppendLine(excep.Message);
}
}
entityTempCount++;
//if (entityTempCount == poolCount)
//{
// db4OContainer.Commit();
// entityTempCount = 0;
//}
}
//if(entityTempCount > 0)
// db4OContainer.Commit();
}
