public Boolean excluirCliente(Cliente objCliente)
{
db = ServidorSingleton.obterServidor().OpenClient();
try
{
IObjectSet leitor = db.QueryByExample(objCliente);
if (leitor.HasNext())
{
db.Delete((Cliente)leitor.Next());
db.Commit();
return(true);
}
else
{
return(false);
}
}
catch
{
db.Rollback();
return(false);
}
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 Boolean excluirFuncionario(Funcionario objFuncionario)
{
db = ServidorSingleton.obterServidor().OpenClient();
Funcionario objFuncionarioProt = FactoryClasses.criarFuncionario();
objFuncionarioProt.Codigo = objFuncionario.Codigo;
try
{
IObjectSet leitor = db.QueryByExample(objFuncionario);
if (leitor.HasNext())
{
db.Delete((Funcionario)leitor.Next());
db.Commit();
return(true);
}
else
{
return(false);
}
}
catch
{
db.Rollback();
return(false);
}
finally
{
db.Close();
db.Dispose();
}
}
public Funcionario efetuarLogin(Funcionario objFuncionario)
{
try
{
Funcionario objFunc;
db = ServidorSingleton.obterServidor().OpenClient();
IObjectSet leitor = db.QueryByExample(objFuncionario);
if (leitor.HasNext())
{
objFunc = (Funcionario)leitor.Next();
}
else
{
objFunc = null;
}
return(objFunc);
}
catch (Exception e)
{
throw new Exception("Erro efetuando login :" + e.Message);
}
finally
{
db.Close();
db.Dispose();
}
}
public Boolean cadastrarFuncionario(Funcionario objFuncionario)
{
objFuncionario.Codigo = obtemNovoId();
try
{
if (!temDuplicidade(objFuncionario, "Cadastrar"))
{
db = ServidorSingleton.obterServidor().OpenClient();
IObjectSet leitorCargo = db.QueryByExample(objFuncionario.Cargo);
if (leitorCargo.HasNext())
{
objFuncionario.Cargo = (Cargo)leitorCargo.Next();
}
leitorCargo = null;
db.Store(objFuncionario);
db.Commit();
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
throw new Exception("Erro cadastrando o funcionário :" + e.Message);
}
finally
{
db.Close();
db.Dispose();
}
}
private int obtemNovoId()
{
try
{
db = ServidorSingleton.obterServidor().OpenClient();
IQuery query = db.Query();
query.Constrain(typeof(SolicitacaoMateriais)).Greater();
query.Descend("codigo").OrderDescending();
IObjectSet leitor = query.Execute();
if (leitor.HasNext())
{
SolicitacaoMateriais objSolicitacao = (SolicitacaoMateriais)leitor.Next();
leitor = null;
return(Convert.ToInt32(objSolicitacao.Codigo) + 1);
}
else
{
leitor = null;
return(1);
}
}
catch (Exception ex)
{
throw new Exception("Erro obtendo o id da solicitação :" + ex.ToString());
}
finally
{
db.Close();
db.Dispose();
}
}
//Fornece um novo id pra todas as suas classes filhas
protected int obtemNovoId()
{
try
{
db = ServidorSingleton.obterServidor().OpenClient();
IQuery query = db.Query();
query.Constrain(typeof(Funcionario)).Greater();
query.Descend("codigo").OrderDescending();
IObjectSet leitor = query.Execute();
if (leitor.HasNext())
{
Funcionario objFuncionario = (Funcionario)leitor.Next();
leitor = null;
return(Convert.ToInt32(objFuncionario.Codigo) + 1);
}
else
{
leitor = null;
return(1);
}
}
catch (Exception ex)
{
throw new Exception("Erro obtendo o id do funcionario :" + ex.ToString());
}
finally
{
db.Close();
db.Dispose();
}
}
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 Boolean temDuplicidade(Funcionario objFuncionario, string modo)
{
bool possuiObjeto = false;
Funcionario objFuncionarioProt = FactoryClasses.criarFuncionario(); //Protótipo para consulta
try
{
db = ServidorSingleton.obterServidor().OpenClient();
objFuncionarioProt.Login = objFuncionario.Login; //Setando a descrição para busca
IObjectSet leitor = db.QueryByExample(objFuncionarioProt);
if (leitor.HasNext())
{
switch (modo)
{
case "Cadastrar":
possuiObjeto = true;
break;
case "Alterar":
Funcionario objFuncionarioDb = FactoryClasses.criarFuncionario();
objFuncionarioDb = (Funcionario)leitor.Next(); //Carregando em cache o obj do banco
//Comparando se o codigo a ser alterado é diferente do do banco.
if (Convert.ToInt32(objFuncionario.Codigo) != Convert.ToInt32(objFuncionarioDb.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 funcionario: " + ex.ToString());
}
finally
{
db.Close();
db.Dispose();
}
return(possuiObjeto);
}
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;
})));
}
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 Collection <Fornecedor> listarFornecedores()
{
db = ServidorSingleton.obterServidor().OpenClient();
Fornecedor objFornecedorPrototipo = FactoryClasses.criarFornecedor();
IObjectSet leitor = db.QueryByExample(objFornecedorPrototipo);
Collection <Fornecedor> objFornecedorColecao = new Collection <Fornecedor>();
foreach (Fornecedor item in leitor)
{
objFornecedorColecao.Add(item);
}
return(objFornecedorColecao);
}
public Collection <Materiais> listarMateriais()
{
db = ServidorSingleton.obterServidor().OpenClient();
Materiais objMaterialPrototipo = FactoryClasses.criarMateriais();
IObjectSet leitor = db.QueryByExample(objMaterialPrototipo);
Collection <Materiais> objMateriaisColecao = new Collection <Materiais>();
foreach (Materiais item in leitor)
{
objMateriaisColecao.Add(item);
}
return(objMateriaisColecao);
}
public Collection <Cliente> listarClientes()
{
db = ServidorSingleton.obterServidor().OpenClient();
Cliente objClientePrototipo = FactoryClasses.criarCliente();
IObjectSet leitor = db.QueryByExample(objClientePrototipo);
Collection <Cliente> objClienteColecao = new Collection <Cliente>();
foreach (Cliente item in leitor)
{
objClienteColecao.Add(item);
}
return(objClienteColecao);
}
//Lista todos os seus filhos em uma coleção de funcionarios
public Collection <Funcionario> listarFuncionarios()
{
db = ServidorSingleton.obterServidor().OpenClient();
Collection <Funcionario> objFuncionarioColecao = new Collection <Funcionario>();
Funcionario objFuncionarioProt = FactoryClasses.criarFuncionario();
IObjectSet leitor = db.QueryByExample(objFuncionarioProt);
foreach (Funcionario item in leitor)
{
objFuncionarioColecao.Add(item);
}
return(objFuncionarioColecao);
}
public Funcionario listarFuncionario(Funcionario objFuncionarioModelo)
{
db = ServidorSingleton.obterServidor().OpenClient();
Funcionario objFuncionario = FactoryClasses.criarFuncionario();
IObjectSet leitor = db.QueryByExample(objFuncionarioModelo);
if (leitor.HasNext())
{
objFuncionario = (Funcionario)leitor.Next();
}
leitor = null;
db.Close();
db.Dispose();
return(objFuncionario);
}
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 Fornecedor editarFornecedor(Fornecedor objFornecedorProt)
{
db = ServidorSingleton.obterServidor().OpenClient();
IObjectSet leitor = db.QueryByExample(objFornecedorProt);
Fornecedor objFornecedor = FactoryClasses.criarFornecedor();
if (leitor.HasNext())
{
objFornecedor = (Fornecedor)leitor.Next();
}
leitor = null;
db.Close();
db.Dispose();
return(objFornecedor);
}
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 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 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 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();
}
}
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 Collection <AnalistaFaturamento> listarAnalistasFaturamento()
{
db = ServidorSingleton.obterServidor().OpenClient();
IQuery query = db.Query();
query.Constrain(typeof(AnalistaFaturamento));
query.Descend("nome").OrderAscending();
IObjectSet leitor = query.Execute();
Collection <AnalistaFaturamento> objAnalistaFat = new Collection <AnalistaFaturamento>();
foreach (AnalistaFaturamento item in leitor)
{
objAnalistaFat.Add(item);
}
return(objAnalistaFat);
}
public Collection <Comprador> listarCompradores()
{
db = ServidorSingleton.obterServidor().OpenClient();
IQuery query = db.Query();
query.Constrain(typeof(Comprador));
query.Descend("nome").OrderAscending();
IObjectSet leitor = query.Execute();
Collection <Comprador> objCompradorColecao = new Collection <Comprador>();
foreach (Comprador item in leitor)
{
objCompradorColecao.Add(item);
}
return(objCompradorColecao);
}
//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);
}
}
private Boolean temDuplicidadeEng(EngenheiroCampo objEng)
{
bool retorno;
db = ServidorSingleton.obterServidor().OpenClient();
IObjectSet leitor = db.QueryByExample(objEng);
if (leitor.HasNext())
{
retorno = true;
}
else
{
retorno = false;
}
leitor = null;
return(retorno);
}
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();
}
}
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 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);
}
}
