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 LocalAssetServer()
{
bool yapfile;
this._assetRequests = new BlockingQueue<ARequest>();
yapfile = System.IO.File.Exists("assets.yap");
OpenSim.Framework.Console.MainConsole.Instance.WriteLine("Local Asset Server class created");
try
{
db = Db4oFactory.OpenFile("assets.yap");
OpenSim.Framework.Console.MainConsole.Instance.WriteLine("Db4 Asset database creation");
}
catch (Exception e)
{
db.Close();
OpenSim.Framework.Console.MainConsole.Instance.WriteLine("Db4 Asset server :Constructor - Exception occured");
OpenSim.Framework.Console.MainConsole.Instance.WriteLine(e.ToString());
}
if (!yapfile)
{
this.SetUpAssetDatabase();
}
this._localAssetServerThread = new Thread(new ThreadStart(RunRequests));
this._localAssetServerThread.IsBackground = true;
this._localAssetServerThread.Start();
}
private int obtemNovoIdEng()
{
try
{
db = ServidorSingleton.obterServidor().OpenClient();
IQuery query = db.Query();
query.Constrain(typeof(EngenheiroCampo)).Greater();
query.Descend("codigo").OrderDescending();
IObjectSet leitor = query.Execute();
if (leitor.HasNext())
{
EngenheiroCampo objEng = (EngenheiroCampo)leitor.Next();
leitor = null;
return Convert.ToInt32(objEng.Codigo) + 1;
}
else
{
leitor = null;
return 1;
}
}
catch (Exception ex)
{
throw new Exception("Erro obtendo o id do engenheiro :" + ex.ToString());
}
finally
{
db.Close();
db.Dispose();
}
}
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());
}
}
private void Close(IObjectContainer objectContainer)
{
objectContainer.Close();
if (_server != null)
{
_server.Close();
_server = null;
}
}
/// <exception cref="System.Exception"></exception>
public static void WithContainer(IObjectContainer container, IContainerBlock block
)
{
try
{
block.Run(container);
}
finally
{
container.Close();
}
}
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();
}
}
public void Initialise(string dfile)
{
OpenSim.Framework.Console.MainConsole.Instance.WriteLine("Db4LocalStorage Opening " + dfile);
datastore = dfile;
try
{
db = Db4oFactory.OpenFile(datastore);
OpenSim.Framework.Console.MainConsole.Instance.WriteLine("Db4LocalStorage creation");
}
catch (Exception e)
{
db.Close();
OpenSim.Framework.Console.MainConsole.Instance.WriteLine("Db4LocalStorage :Constructor - Exception occured");
OpenSim.Framework.Console.MainConsole.Instance.WriteLine(e.ToString());
}
}
public virtual void TestOpenWithNonStaticConfiguration()
{
var config1 = NewConfiguration();
config1.File.ReadOnly = true;
Assert.Expect(typeof(DatabaseReadOnlyException), new _ICodeBlock_30(this, config1
));
var config2 = NewConfiguration();
IObjectContainer db2 = Db4oEmbedded.OpenFile(config2, TempFile());
try
{
db2.Store(new Data(2));
Assert.AreEqual(1, db2.Query(typeof(Data))
.Count);
}
finally
{
db2.Close();
}
}
static public bool Borrar(long Id)
{
using (IObjectContainer db = Connect.getDataBase())
{
try
{
Recurso o = new Recurso(Id);
Connect.setdbId(db, o);
db.Delete(o);
return(true);
}
catch
{
return(false);
}
finally
{
db.Close();
}
}
}
protected void Add_Document_for_User_Click(object sender, EventArgs e)
{
int count;
string docname;
float versionOfDoc;
System.Web.HttpContext context = System.Web.HttpContext.Current;
string docname_versionOfDoc = (String)context.Session["docNameVersionNo"];
List <String> compare = new List <string>();
compare = docname_versionOfDoc.Split(':').ToList();
docname = compare[0];
versionOfDoc = float.Parse(compare[1]);
string username = (string)Session["UserName"];
try
{
Config path = new Config();
DB = Db4oFactory.OpenFile(path.addressOfDocument);
IObjectSet result = DB.QueryByExample(new Document_model(docname, versionOfDoc));
Document_model docmodel = (Document_model)result.Next();
count = docmodel.Count_document_reviever - 1;
docmodel.Count_document_reviever = count;
docmodel.List_reviever.Remove(username);
if (docmodel.Count_document_reviever == 0)
{
docmodel.DocumentStatus = "Complete";
}
DB.Ext().Store(docmodel, 3);
DB.Close();
Page.RegisterStartupScript("Alert&Redirect", "<script>alert('Review Successfull!!'); location.href='./Document_page.aspx';</script>");
}
catch
{
}
}
public int GetExecutorThreadCount(string executorId, params ThreadState[] threadState)
{
int threadCount = 0;
if (threadState == null && threadState.Length == 0)
{
return(threadCount);
}
ArrayList threadList = new ArrayList();
IObjectContainer container = GetStorage();
try
{
IList <ThreadStorageView> threadsList =
container.Query <ThreadStorageView>(delegate(ThreadStorageView threadFinder)
{
return(threadFinder.ExecutorId != null && threadFinder.ExecutorId == executorId);
});
foreach (ThreadStorageView thread in threadsList)
{
foreach (ThreadState state in threadState)
{
if (thread.State == state)
{
threadCount++;
break; // no point in continuing since there is only one state for a thread
}
}
}
}
finally
{
container.Close();
}
return(threadCount);
}
private void button3_Click(object sender, EventArgs e)
{
IObjectContainer db = null;//Deklaration des Db-Arbeitsobjekt.
try
{
db = Db4oFactory.OpenFile("a"); //Db-Arbeitsobjekt wird durch die OpenFile methode zugewiesen.
IList <Duesenflugzeug> fluege =
db.Query <Duesenflugzeug>(delegate(Duesenflugzeug flieger) //Die Methode Query verwendet in mehrfacher Hinsicht eine sehr spezielle
//Syntax,die gibt eine Ilist mit Typ düsenflugzeug zurück,und die methode
//hat einen Predicate delegate als parameter ,Diese delegate hat eine anonyme Methode gespeichert,die methode nimmt düsenflugzeug
//objekt,und dann prüfen ob diese kennung schon existiert,
//wenn ja,wird dieses düsenflugzeug object in der IList gespeichert.
{
return(flieger.Kennung == textBoxKennung.Text);
}
);
if (fluege.Count > 0)
{
flieger = fluege.First();
db.Delete(flieger);
Console.WriteLine("Flug {0} gelöscht ", flieger.Kennung);
}
else
{
Console.WriteLine("Kein Flug mit der Kennung {0} in der Datenbank", textBoxKennung.Text);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.GetType() + ":" + ex.Message);
}
finally
{
if (db != null)
{
db.Close();
}
}
}
private void btnOpenDb4o_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog dlg = new OpenFileDialog();
dlg.DefaultExt = ".yap";
dlg.Filter = "db4o file (*.yap)|*.yap";
dlg.InitialDirectory = AppDomain.CurrentDomain.BaseDirectory;
if ((bool)dlg.ShowDialog())
{
if (db != null)
{
db.Close();
}
originFile = dlg.FileName;
tbFilePath.Text = originFile;
db = Db4oFactory.OpenFile(originFile);
var ext = db.Ext();
PopulateCombos(db);
}
}
public static void AddRooms(int roomID, int RoomNum, int Persons, string Beds)
{
string path = Directory.GetCurrentDirectory() + "\\database.srph";
//IObjectContainer db;
IEmbeddedConfiguration config = Db4oEmbedded.NewConfiguration();
config.Common.ObjectClass(typeof(Rooms)).CascadeOnUpdate(true);
config.Common.ObjectClass(typeof(Rooms)).CascadeOnDelete(true);
config.Common.ObjectClass(typeof(Rooms)).CascadeOnActivate(true);
//db = Db4oEmbedded.OpenFile(config, path);
using (IObjectContainer db = Db4oEmbedded.OpenFile(config, path))
{
var room = new Rooms(roomID, RoomNum, Persons, Beds);
db.Store(room);
db.Commit();
db.Close();
}
}
public static void IndividualUUID()
{
// #example: Enable db4o uuids for certain classes
IEmbeddedConfiguration configuration = Db4oEmbedded.NewConfiguration();
configuration.File.GenerateUUIDs = ConfigScope.Individually;
configuration.Common.ObjectClass(typeof(SpecialClass)).GenerateUUIDs(true);
// #end example
IObjectContainer container = Db4oEmbedded.OpenFile(configuration, "database.db4o");
SpecialClass withUUID = new SpecialClass();
container.Store(withUUID);
NormalClass withoutUUID = new NormalClass();
container.Store(withoutUUID);
AssertNotNull(container.Ext().GetObjectInfo(withUUID).GetUUID());
AssertNull(container.Ext().GetObjectInfo(withoutUUID).GetUUID());
container.Close();
}
private void button4_Click(object sender, EventArgs e)
{
DB = Db4oFactory.OpenFile("dbConcessionaria.yap");
try
{
classeFornecedor forn = DB.Query <classeFornecedor>(P => P.cnpjFornecedor.Equals(maskedTextBox1.Text)).Single();
forn.cnpjFornecedor = maskedTextBox1.Text;
forn.nomeFornecedor = textBox1.Text;
forn.telefoneFornecedor = textBox2.Text;
forn.emailFornecedor = textBox3.Text;
DB.Store(forn);
DB.Commit();
}
finally
{
DB.Close();
exibir();
limpar();
}
}
public Flugauswahldialog()
{
InitializeComponent();
IObjectContainer db = null;
db = Db4oFactory.OpenFile(dbName);
IObjectSet result = db.QueryByExample(typeof(Duesenflugzeug));
for (int i = 0; i < result.Count; i++)
{
var Puffer = (Duesenflugzeug)result[i];
var Q = Puffer.typ.ToString();
comboBox1.Items.Add(Q);
}
comboBox1.Update();
db.Close();
}
public static void saveConfig(appConfig config)
{
IObjectContainer db = Db4oFactory.OpenFile(appConfig.configFilePath);
try
{
IList <appConfig> list = db.Query <appConfig>(typeof(appConfig));
if (list.Count <= 0)
{
db.Store(config);
}
else
{
appConfig.copy(config, list[0]);
db.Store(list[0]);
}
}
finally
{
db.Close();
}
}
private static void MigrationOnTheFly()
{
DeleteDatabases();
IObjectContainer desktopDatabaseWithoutUUID = Db4oEmbedded.OpenFile(DesktopDatabaseName);
desktopDatabaseWithoutUUID.Store(new Car(new Pilot("Max"), "Max's Car"));
desktopDatabaseWithoutUUID.Store(new Car(new Pilot("Joe"), "Joe's Car"));
desktopDatabaseWithoutUUID.Commit();
desktopDatabaseWithoutUUID.Close();
IObjectContainer desktopDatabase = OpenDatabase(DesktopDatabaseName);
IObjectContainer mobileDatabase = OpenDatabase(MobileDatabaseName);
IReplicationProvider desktopRelicationPartner
= new Db4oEmbeddedReplicationProvider(desktopDatabase);
IReplicationProvider mobileRelicationPartner
= new Db4oEmbeddedReplicationProvider(mobileDatabase);
// #example: Migrate on the fly
IReplicationSession replicationSession = Replication.Begin(desktopRelicationPartner, mobileRelicationPartner);
IList <Car> initialReplication = desktopDatabase.Query <Car>();
foreach (Car changedObjectOnDesktop in initialReplication)
{
IObjectInfo infoAboutObject = desktopDatabase.Ext().GetObjectInfo(changedObjectOnDesktop);
if (null == infoAboutObject.GetUUID())
{
desktopDatabase.Ext().Store(changedObjectOnDesktop, 2);
}
replicationSession.Replicate(changedObjectOnDesktop);
}
replicationSession.Commit();
// #end example
PrintCars(mobileDatabase);
CloseDBs(desktopDatabase, mobileDatabase);
}
private void BtnBuscar_Click(object sender, EventArgs e)
{
DataPat.Rows.Clear();
// IObjectContainer BD = Db4oFactory.OpenFile("C://Users//Luilly//Documents//DB//DBOO.dboo");
IObjectContainer BD = Db4oFactory.OpenFile(Util.NombreArchivo);
try
{
IList <Patente> consulta = BD.Query <Patente>();
if (consulta.Count > 0)
{
foreach (Patente paten in consulta)
{
DataPat.Rows.Add(paten.Titulo, paten.NoRegistro);
}
}
}
finally
{
BD.Close();
}
}
public ResultObject Import(string importFilePath, string appDBDirectory, string activeDBName, string activeDBExtension)
{
ResultObject ro;
try {
IObjectContainer db = _factory.OpenConnection(importFilePath);
ro = new ResultObject(true, db);
ro.AddMessage("Import dat proběhl úspěšně!");
db.Close();
} catch (IncompatibleFileFormatException e) {
ro = new ResultObject(false);
ro.AddMessage("Import dat selhal. Špatný formát dat.");
} catch (DatabaseReadOnlyException e) {
ro = new ResultObject(false);
ro.AddMessage("Import dat selhal. Nelze importovat data jen pro čtení.");
} catch (Exception e) {
ro = new ResultObject(false);
ro.AddMessage("Zvolená data nelze importovat.");
}
if (!ro.Success)
{
return(ro);
}
DateTime now = DateTime.Now;
string activeDbFilePath = Path.Combine(appDBDirectory, activeDBName + "." + activeDBExtension);
string oldDbBackupFileName = string.Format("backup_{0}_{1}_{2}_{3}_{4}_{5}_v{6}.{7}", now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second, Assembly.GetExecutingAssembly().GetName().Version.ToString().Replace(".", "-"), activeDBExtension);
string lastWorkingDbBackupPath = Path.Combine(appDBDirectory, oldDbBackupFileName);
File.Move(activeDbFilePath, lastWorkingDbBackupPath);
File.Copy(importFilePath, activeDbFilePath);
return(ro);
}
public BindableCollection <PersonModel> AllPossibleFathers(PersonModel person)
{
IObjectContainer db = Db4oFactory.OpenFile("person.data");
BindableCollection <PersonModel> possibleFathers = new BindableCollection <PersonModel>();
var allMenInDatabase = db.QueryByExample(new PersonModel(EGender.Male));
foreach (var man in allMenInDatabase)
{
possibleFathers.Add((PersonModel)man);
}
db.Close();
List <PersonModel> menWithBirthDate = new List <PersonModel>();
foreach (var man in possibleFathers)
{
if (man.BirthDate != null)
{
menWithBirthDate.Add(man);
}
}
foreach (var man in menWithBirthDate)
{
possibleFathers.Remove(man);
}
possibleFathers = PossibleFathersHelper.RemovePossiblyWrongImportedFathers(possibleFathers) as BindableCollection <PersonModel>;
possibleFathers = PossibleFathersHelper.RemoveDescendantsFromPossibleFathers(possibleFathers, person) as BindableCollection <PersonModel>;
var items = possibleFathers.Where(x => x.Name == person.Name);
if (items != null)
{
foreach (var thisPerson in items.ToList())
{
possibleFathers.Remove(thisPerson);
}
}
items = null;
possibleFathers.Add(new PersonModel("-brak-"));
return(possibleFathers);
}
private void Pat_Load(object sender, EventArgs e)
{
DataPat.Rows.Clear();
IObjectContainer BD = Db4oFactory.OpenFile(Util.NombreArchivo);
try
{
IList <Patente> consulta = BD.Query <Patente>();
if (consulta.Count > 0)
{
foreach (Patente pate in consulta)
{
DataPat.Rows.Add(pate.Titulo, pate.NoRegistro);
}
}
}
finally
{
BD.Close();
}
}
private void CreateDatabase(string fileName)
{
IObjectContainer db = Db4oEmbedded.OpenFile(Config(), fileName);
Collection4 removed = new Collection4();
for (int idx = 0; idx < NumItemsPerClass; idx++)
{
RepeatDeleteReaddTestCase.ItemA itemA = new RepeatDeleteReaddTestCase.ItemA(idx);
RepeatDeleteReaddTestCase.ItemB itemB = new RepeatDeleteReaddTestCase.ItemB(FillStr
('x', idx));
db.Store(itemA);
db.Store(itemB);
if ((idx % DeleteRatio) == 0)
{
removed.Add(itemA);
removed.Add(itemB);
}
}
db.Commit();
DeleteAndReadd(db, removed);
db.Close();
}
private void CreateDatabase(string fileName, int blockSize)
{
IObjectContainer db = Db4oEmbedded.OpenFile(Config(blockSize), fileName);
var removed = new Collection4();
for (var idx = 0; idx < NumItemsPerClass; idx++)
{
var itemA = new ItemA(idx);
var itemB = new ItemB(FillStr('x'
, idx));
db.Store(itemA);
db.Store(itemB);
if ((idx % DeleteRatio) == 0)
{
removed.Add(itemA);
removed.Add(itemB);
}
}
db.Commit();
DeleteAndReadd(db, removed);
db.Close();
}
public override bool RunJob()
{
bool bError = false;
try
{
if (servidor.IsRunning())
{
IObjectContainer dbcliente = Db4oFactory.OpenClient(this.sServer, Convert.ToInt32(this.sPort),
this.sUsuario, this.sPassword);
dbcliente.Ext().Backup(sBackupFile);
dbcliente.Close();
}
}
catch (Exception ex)
{
bError = true;
Log.AddToLog(sJobName, ex.Message);
}
return(bError);
}
public Boolean excluirCargo(Cargo objCargo)
{
//Validação de existência do cargo utilizado por algum usuário
FuncionarioDAO objFuncionarioDAO = FactoryDAO.criarFuncionarioDAO();
if (!objFuncionarioDAO.possuiFuncionarioPorCargo(objCargo))
{
db = ServidorSingleton.obterServidor().OpenClient();
try
{
IObjectSet leitor = db.QueryByExample(objCargo);
if (leitor.HasNext())
{
db.Delete((Cargo)leitor.Next());
db.Commit();
return(true);
}
else
{
return(false);
}
}
catch
{
db.Rollback();
return(false);
}
finally
{
db.Close();
db.Dispose();
}
}
else
{
return(false);
}
}
public override void InitConfig()
{
try
{
db = Db4oFactory.OpenFile("openuser.yap");
IObjectSet result = db.Get(typeof(DbUserConfig));
if (result.Count == 1)
{
m_log.Info("[DBUSERCONFIG]: DbUserConfig.cs:InitConfig() - Found a UserConfig object in the local database, loading");
foreach (DbUserConfig cfg in result)
{
this.GridServerURL = cfg.GridServerURL;
this.GridSendKey = cfg.GridSendKey;
this.GridRecvKey = cfg.GridRecvKey;
this.DefaultStartupMsg = cfg.DefaultStartupMsg;
}
}
else
{
m_log.Info("[DBUSERCONFIG]: DbUserConfig.cs:InitConfig() - Could not find object in database, loading precompiled defaults");
LoadDefaults();
m_log.Info("[DBUSERCONFIG]: Writing out default settings to local database");
db.Set(this);
db.Close();
}
}
catch (Exception e)
{
m_log.Warn("DbUserConfig.cs:InitConfig() - Exception occured");
m_log.Warn(e.ToString());
}
m_log.Info("[DBUSERCONFIG]: User settings loaded:");
m_log.Info("[DBUSERCONFIG]: Default startup message: " + this.DefaultStartupMsg);
m_log.Info("[DBUSERCONFIG]: Grid server URL: " + this.GridServerURL);
m_log.Info("[DBUSERCONFIG]: Key to send to grid: " + this.GridSendKey);
m_log.Info("[DBUSERCONFIG]: Key to expect from grid: " + this.GridRecvKey);
}
private void btnGuardar_Click_1(object sender, EventArgs e)
{
IObjectContainer BD = Db4oFactory.OpenFile(Util.NombreArchivo);
Patente pt = new Patente("");
pt.Titulo = TxtTitulo.Text;
IList <Patente> resultados = BD.Query <Patente>(x => x.Titulo == TxtTitulo.Text);
if (resultados.Count > 0)
{
Patente v = new Patente("");
v = resultados.First <Patente>();
//Estudiante v = new Estudiante("","");
//v.NoControl = TxtNumcontrol.Text;
v.Titulo = TxtTitulo.Text;
v.NoRegistro = TxtNumRegistro.Text;
BD.Store(v);
BD.Commit();
MessageBox.Show("Exito!!! Se Modifico");
TxtNumRegistro.Clear();
TxtTitulo.Clear();
}
else
{
MessageBox.Show("Error!!! No se Modifico");
}
TxtNumRegistro.Clear();
TxtTitulo.Clear();
btnGuardar.Visible = false;
BD.Close();
}
private void loginBtn_Click(object sender, EventArgs e)
{
if (emailTxt.Text.Equals("*****@*****.**") && passTxt.Text.Equals("admin"))
{
MessageBox.Show("Welcome Admin!");
AdminForm af = new AdminForm();
af.Show();
this.Hide();
resetValues();
}
else
{
try
{
DB = Db4oFactory.OpenFile("User Database.yap");
List <User> userList = (from x in DB.Query <User>()
where x.Email.Equals(emailTxt.Text) && x.Password.Equals(passTxt.Text)
select x).ToList();
if (userList.Count == 0)
{
MessageBox.Show("Invalid Username/Password");
}
else
{
//gets current user and redirect currUser to shop form
MessageBox.Show("Welcome, " + userList.ElementAt(0).Email);
ShopForm sf = new ShopForm(userList.ElementAt(0));
sf.Show();
this.Hide();
resetValues();
}
}
finally
{
DB.Close();
}
}
}
private void button1_Click(object sender, EventArgs e)
{
IObjectContainer db = Db4oEmbedded.OpenFile("EmployeeManager3.yap");
if (double.Parse(textBox4.Text) < 300)
{
MessageBox.Show("Lỗi nhập liệu", "Lỗi");
}
else
{
var employee = new Employee(textBox1.Text, textBox2.Text, (Company)this.comboBox1.SelectedItem, double.Parse(textBox4.Text));
db.Store(employee);
var pilot1 = new Company
{
CompanyName = comboBox1.Text,
};
IObjectSet result = db.QueryByExample(pilot1);
int a = result.Count;
Company p2 = (Company)result[0];
Company p = (Company)result[1];
var pilot2 = new Employee
{
FullName = textBox1.Text,
};
IObjectSet result1 = db.QueryByExample(pilot2);
Employee p1 = (Employee)result1[0];
p1.HomeBase = p2;
db.Store(p1);
db.Delete(p);
db.Close();
getdata();
}
}
public override void InitConfig()
{
try
{
db = Db4oFactory.OpenFile("openuser.yap");
IObjectSet result = db.Get(typeof(DbUserConfig));
if (result.Count == 1)
{
m_log.Info("[DBUSERCONFIG]: DbUserConfig.cs:InitConfig() - Found a UserConfig object in the local database, loading");
foreach (DbUserConfig cfg in result)
{
this.GridServerURL=cfg.GridServerURL;
this.GridSendKey=cfg.GridSendKey;
this.GridRecvKey=cfg.GridRecvKey;
this.DefaultStartupMsg=cfg.DefaultStartupMsg;
}
}
else
{
m_log.Info("[DBUSERCONFIG]: DbUserConfig.cs:InitConfig() - Could not find object in database, loading precompiled defaults");
LoadDefaults();
m_log.Info("[DBUSERCONFIG]: Writing out default settings to local database");
db.Set(this);
db.Close();
}
}
catch(Exception e)
{
m_log.Warn("DbUserConfig.cs:InitConfig() - Exception occured");
m_log.Warn(e.ToString());
}
m_log.Info("[DBUSERCONFIG]: User settings loaded:");
m_log.Info("[DBUSERCONFIG]: Default startup message: " + this.DefaultStartupMsg);
m_log.Info("[DBUSERCONFIG]: Grid server URL: " + this.GridServerURL);
m_log.Info("[DBUSERCONFIG]: Key to send to grid: " + this.GridSendKey);
m_log.Info("[DBUSERCONFIG]: Key to expect from grid: " + this.GridRecvKey);
}
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());
}
}
public static void AssertDataClassKnown(string databaseFileName, IEmbeddedConfiguration
config, bool expected)
{
IObjectContainer db = Db4oEmbedded.OpenFile(config, databaseFileName);
try
{
var storedClass = db.Ext().StoredClass(typeof(Data
));
if (expected)
{
Assert.IsNotNull(storedClass);
}
else
{
Assert.IsNull(storedClass);
}
}
finally
{
db.Close();
}
}
public string AddApplication(ApplicationStorageView application)
{
if (application == null)
{
return(null);
}
string applicationId = Guid.NewGuid().ToString();
application.ApplicationId = applicationId;
IObjectContainer container = GetStorage();
try
{
container.Set(application);
}
finally
{
container.Close();
}
return(applicationId);
}
public static SavedData getSaveData(SavedData data)
{
SavedData configR = null;
IObjectContainer db = Db4oFactory.OpenFile(staticClass.configFilePath);
try
{
IList <SavedData> list = db.Query <SavedData>(delegate(SavedData cf)
{
return(data.name == cf.name);
}
);
if (list.Count > 0)
{
configR = list[0];
}
}
finally
{
db.Close();
}
return(configR);
}
public List <SaveableStockItem> GetStock()
{
List <SaveableStockItem> retval = null;
using (IObjectContainer db = Db4oEmbedded.OpenFile(DB_FILNAME))
{
try
{
retval = new List <SaveableStockItem>();
SaveableStockItem query = new SaveableStockItem(null, 0);
IObjectSet result = db.QueryByExample(query);
foreach (Object item in result)
{
retval.Add((SaveableStockItem)item);
}
}
finally
{
db.Close();
}
}
return(retval);
}
public static SQLConnConfig getDefaultDBConfig(DBType type)
{
SQLConnConfig config = null;
IObjectContainer db = Db4oFactory.OpenFile(SQLConnConfig.configFilePath);
try
{
IList <SQLConnConfig> list = db.Query <SQLConnConfig>(delegate(SQLConnConfig cf)
{
return(cf.dbType == type);
}
);
if (list.Count > 0)
{
config = list[0];
}
}
finally
{
db.Close();
}
return(config);
}
public Boolean possuiFuncionarioPorCargo(Cargo objCargo)
{
bool retorno;
db = ServidorSingleton.obterServidor().OpenClient();
Funcionario objFuncionario = FactoryClasses.criarFuncionario();
objFuncionario.Cargo = objCargo;
IObjectSet leitor = db.QueryByExample(objFuncionario);
if (leitor.HasNext())
{
retorno = true;
}
else
{
retorno = false;
}
leitor = null;
db.Close();
db.Dispose();
return(retorno);
}
public Collection<SolicitacaoMateriais> listarSolicitacoesAprovadas()
{
db = ServidorSingleton.obterServidor().OpenClient();
return new Collection<SolicitacaoMateriais>(db.Query<SolicitacaoMateriais>(delegate(SolicitacaoMateriais objSolicitacao)
{
db.Close();
db.Dispose();
//Tras aquelas solicitações que possuem gestores da obra, ou seja, foram validadas
return objSolicitacao.GestorObra != null;
}));
}
private Boolean temDuplicidade(Materiais objMaterial, string modo)
{
bool possuiObjeto = false;
Materiais objMaterialProt = FactoryClasses.criarMateriais(); //Protótipo para consulta
try
{
db = ServidorSingleton.obterServidor().OpenClient();
objMaterialProt.Descricao = objMaterial.Descricao; //Setando a descrição para busca
IObjectSet leitor = db.QueryByExample(objMaterialProt);
if (leitor.HasNext())
{
switch (modo)
{
case "Cadastrar":
possuiObjeto = true;
break;
case "Alterar":
Materiais objMaterialDb = FactoryClasses.criarMateriais();
objMaterialDb = (Materiais)leitor.Next(); //Carregando em cache o obj do banco
//Comparando se o codigo a ser alterado é diferente do do banco.
if (Convert.ToInt32(objMaterial.Codigo) != Convert.ToInt32(objMaterialDb.Codigo))
{
//É diferente, logo se trata de um objeto diferente do que esta sendo alterado
//A alteração não pode ser feita
possuiObjeto = true;
}
else
{
possuiObjeto = false;
}
break;
}
}
else
{
possuiObjeto = false;
}
leitor = null;
}
catch (Exception ex)
{
throw new Exception("Erro verificando a duplicidade do material: " + ex.ToString());
}
finally
{
db.Close();
db.Dispose();
}
return possuiObjeto;
}
//Lista os materiais conforme busca
public Collection<Materiais> listarMateriaisBusca(string materialBuscar)
{
db = ServidorSingleton.obterServidor().OpenClient();
if (materialBuscar.Length > 0)
{
return new Collection<Materiais>(db.Query<Materiais>(delegate(Materiais objMaterial)
{
db.Close();
db.Dispose();
return objMaterial.Descricao.ToLower().Contains(materialBuscar.ToLower())
|| objMaterial.DescricaoPopular.ToLower().Contains(materialBuscar.ToLower());
}));
}
else {
return null;
}
}
public Collection<clsStatus> listarStatus()
{
try
{
Collection<clsStatus> objStatusColecao = new Collection<clsStatus>();
db = ServidorSingleton.obterServidor().OpenClient();
IQuery query = db.Query();
query.Constrain(typeof(clsStatus));
query.Descend("descricao").OrderAscending();
IObjectSet leitor = query.Execute();
foreach (clsStatus item in leitor)
{
objStatusColecao.Add(item);
}
leitor = null;
return objStatusColecao;
}
catch (Exception ex)
{
throw new Exception("Erro listando os status :" + ex.ToString());
}
finally {
db.Close();
db.Dispose();
}
}
public Collection<SolicitacaoMateriais> listarSolicitacoes()
{
db = ServidorSingleton.obterServidor().OpenClient();
SolicitacaoMateriais objSolicitacaoProt = FactoryClasses.criarSolicitacaoMateriais();
Collection<SolicitacaoMateriais> objSolicitacaoColecao = new Collection<SolicitacaoMateriais>();
IObjectSet leitor = db.QueryByExample(objSolicitacaoProt);
foreach (SolicitacaoMateriais item in leitor) {
objSolicitacaoColecao.Add(item);
}
leitor = null;
db.Close();
db.Dispose();
return objSolicitacaoColecao;
}
public Boolean temStatusEmFilme(clsStatus objStatus)
{
bool temfilme;
try
{
db = ServidorSingleton.obterServidor().OpenClient();
clsFilme objFilme = new clsFilme();
objFilme.Status = objStatus;
IObjectSet leitor = db.QueryByExample(objFilme);
if (leitor.HasNext())
{
temfilme = true;
}
else
{
temfilme = false;
}
leitor = null;
}
catch (Exception ex)
{
throw new Exception("Erro verificando possibilidade de exclusão do status:" + ex.ToString());
}
finally
{
db.Close();
db.Dispose();
}
return temfilme;
}
public Collection<Pedido> listarPedidos()
{
db = ServidorSingleton.obterServidor().OpenClient();
Pedido objPedidoProt = FactoryClasses.criarPedido();
IObjectSet leitor = db.QueryByExample(objPedidoProt);
Collection<Pedido> objPedidoColecao = new Collection<Pedido>();
foreach (Pedido pedido in leitor) {
objPedidoColecao.Add(pedido);
}
leitor = null;
db.Close();
db.Dispose();
return objPedidoColecao;
}
public Cliente editarCliente(Cliente objClienteProt)
{
db = ServidorSingleton.obterServidor().OpenClient();
IObjectSet leitor = db.QueryByExample(objClienteProt);
Cliente objCliente = FactoryClasses.criarCliente();
if (leitor.HasNext()) {
objCliente = (Cliente)leitor.Next();
}
leitor = null;
db.Close();
db.Dispose();
return objCliente;
}
public void cadastrarPedido(SolicitacaoMateriais objSolicitacao)
{
//Atualiza a solicitação no db
SolicitacaoMateriaisDAO objSolicitacaoDAO = FactoryDAO.criarSolicitacaoMateriaisDAO();
if (objSolicitacaoDAO.atualizarSolicitacao(objSolicitacao))
{
SolicitacaoMateriais objSolicitacaoProt = FactoryClasses.criarSolicitacaoMateriais();
objSolicitacaoProt.Codigo = objSolicitacao.Codigo;
db = ServidorSingleton.obterServidor().OpenClient();
IObjectSet leitor = db.QueryByExample(objSolicitacaoProt);
if (leitor.HasNext())
{
objSolicitacaoProt = null;
objSolicitacaoProt = (SolicitacaoMateriais)leitor.Next();
}
leitor = null;
Collection<Pedido> objPedidoColecao = new Collection<Pedido>();
foreach (Materiais material in objSolicitacaoProt.Materiais)
{
Pedido objPedido = FactoryClasses.criarPedido();
objPedido.SolicitacaoMateriais = objSolicitacaoProt;
Collection<Materiais> objMateriaisColecao = new Collection<Materiais>();
objMateriaisColecao.Add(material);
objPedido.Materiais = objMateriaisColecao;
objPedido.Codigo = obtemNovoId();
db = ServidorSingleton.obterServidor().OpenClient();
db.Store(objPedido);
db.Commit();
}
//Le os pedidos
Pedido objPedidoProt = FactoryClasses.criarPedido();
objPedidoProt.SolicitacaoMateriais = objSolicitacaoProt;
db = ServidorSingleton.obterServidor().OpenClient();
IObjectSet leitorPedidoCache = db.QueryByExample(objPedidoProt);
int codFornecedor = 0;
int contador = 0;
int codPedido = 0;
while (leitorPedidoCache.HasNext())
{
Pedido objPedidoLer = (Pedido)leitorPedidoCache.Next();
if (contador == 0)
{
codFornecedor = objPedidoLer.Materiais[0].Fornecedor.Codigo;
}
else
{
if (codFornecedor == objPedidoLer.Materiais[0].Fornecedor.Codigo)
{
//Retira os itens deste pedido e coloca no anterior
Collection<Materiais> objMateriaisColecaoTmp = new Collection<Materiais>();
foreach (Materiais item in objPedidoLer.Materiais)
{
objMateriaisColecaoTmp.Add(item);
}
//exclui o pedido atual
db.Delete(objPedidoLer);
//Carrega o anterior em cache
Pedido p = FactoryClasses.criarPedido();
p.Codigo = codPedido;
IObjectSet leitorPedido2 = db.QueryByExample(p);
if (leitorPedido2.HasNext())
{
p = null;
p = (Pedido)leitorPedido2.Next();
//Atualiza o pedido anterior com os dados do pedido que foi apagado
foreach (Materiais item in p.Materiais)
{
objMateriaisColecaoTmp.Add(item);
}
p.Materiais = objMateriaisColecaoTmp;
db.Store(p);
db.Commit();
}
leitorPedido2 = null;
}
}
codFornecedor = objPedidoLer.Materiais[0].Fornecedor.Codigo;
codPedido = objPedidoLer.Codigo;
contador++;
}
leitorPedidoCache = null;
db.Close();
db.Dispose();
}
}
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 CloseIgnoringExceptions(IObjectContainer container)
{
try
{
container.Close();
}
catch (Exception e)
{
Runtime.PrintStackTrace(e);
}
}
public clsStatus obterStatus(int codStatus)
{
clsStatus objStatusProt = new clsStatus();
clsStatus objStatus = new clsStatus();
objStatusProt.Codigo = codStatus;
try
{
db = ServidorSingleton.obterServidor().OpenClient();
IObjectSet leitor = db.QueryByExample(objStatusProt);
if (leitor.HasNext())
{
return (clsStatus)leitor.Next();
}
else {
return null;
}
leitor = null;
}
catch (Exception ex)
{
throw new Exception("Erro obtendo o genero :" + ex.ToString());
}
finally
{
db.Close();
db.Dispose();
}
}
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();
}
}
public Boolean cadastrarSolicitacao(SolicitacaoMateriais objSolicitacao)
{
objSolicitacao.Codigo = obtemNovoId();
try
{
db = ServidorSingleton.obterServidor().OpenClient();
IObjectSet leitorEng = db.QueryByExample(objSolicitacao.EngenheiroCampo);
if (leitorEng.HasNext()) {
objSolicitacao.EngenheiroCampo = (EngenheiroCampo)leitorEng.Next();
}
leitorEng = null;
IObjectSet leitorCliente = db.QueryByExample(objSolicitacao.Cliente);
if (leitorCliente.HasNext()) {
objSolicitacao.Cliente = (Cliente)leitorCliente.Next();
}
leitorCliente = null;
for (int i = 0; i < objSolicitacao.Materiais.Count; i++ )
{
Materiais objMaterialProt = FactoryClasses.criarMateriais();
objMaterialProt.Codigo = objSolicitacao.Materiais[i].Codigo;
IObjectSet leitorMaterial = db.QueryByExample(objMaterialProt);
if (leitorMaterial.HasNext())
{
objSolicitacao.Materiais[i] = (Materiais)leitorMaterial.Next();
}
leitorMaterial = null;
}
db.Store(objSolicitacao);
db.Commit();
return true;
}
catch (Exception e)
{
db.Rollback();
throw new Exception("Erro cadastrando a solicitação :" + e.Message);
}
finally {
db.Close();
db.Dispose();
}
}
//Lista a busca dinâmica
public Collection<clsFilme> listarFilmes(string ano,
string tituloOriginal,
string tituloBr,
clsGenero objGenero,
clsStatus objStatus)
{
try
{
int intAno = Convert.ToInt32(ano);
}
catch {
ano = "";
}
//Se não foi informado genero/status, seta a descrição como "" para buscar todos
if (objGenero == null) {
objGenero = new clsGenero();
objGenero.Descricao = "";
}
if (objStatus == null) {
objStatus = new clsStatus();
objStatus.Descricao = "";
}
db = ServidorSingleton.obterServidor().OpenClient();
return new Collection<clsFilme>(db.Query<clsFilme>(delegate(clsFilme objFilme)
{
db.Close();
db.Dispose();
return objFilme.TituloBr.ToLower().Contains(tituloBr.ToLower())
&& objFilme.TituloOriginal.ToLower().Contains(tituloOriginal.ToLower())
&& objFilme.Ano.ToString().Contains(ano)
&& objFilme.Genero.Descricao.StartsWith(objGenero.Descricao)
&& objFilme.Status.Descricao.StartsWith(objStatus.Descricao);
}));
}
private void EnsureClose(IObjectContainer client)
{
client.Close();
_clientDisconnectedEvent.WaitOne();
}
private int obtemNovoId()
{
try
{
db = ServidorSingleton.obterServidor().OpenClient();
IQuery query = db.Query();
query.Constrain(typeof(clsFilme)).Greater();
query.Descend("codigo").OrderDescending();
IObjectSet leitor = query.Execute();
if (leitor.HasNext())
{
clsFilme objFilme = (clsFilme)leitor.Next();
return Convert.ToInt32(objFilme.Codigo) + 1;
}
else
{
return 1;
}
leitor = null;
}
catch (Exception ex)
{
throw new Exception("Erro obtendo o id do filme :" + ex.ToString());
}
finally
{
db.Close();
db.Dispose();
}
}
public Materiais editarMaterial(Materiais objMaterialProt)
{
db = ServidorSingleton.obterServidor().OpenClient();
IObjectSet leitor = db.QueryByExample(objMaterialProt);
Materiais objMaterial = FactoryClasses.criarMateriais();
if (leitor.HasNext()) {
objMaterial = (Materiais)leitor.Next();
}
leitor = null;
db.Close();
db.Dispose();
return objMaterial;
}
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 CloseAndWait(IObjectContainer db)
{
db.Close();
try
{
((ObjectContainerBase)db).ThreadPool().Join(3000);
}
catch (Exception)
{
}
}
