private int obtemNovoId()
{
try
{
db = ServidorSingleton.obterServidor().OpenClient();
IQuery query = db.Query();
query.Constrain(typeof(Materiais)).Greater();
query.Descend("codigo").OrderDescending();
IObjectSet leitor = query.Execute();
if (leitor.HasNext())
{
Materiais objMateriais = (Materiais)leitor.Next();
leitor = null;
return(Convert.ToInt32(objMateriais.Codigo) + 1);
}
else
{
leitor = null;
return(1);
}
}
catch (Exception ex)
{
throw new Exception("Erro obtendo o id do material :" + ex.ToString());
}
finally
{
db.Close();
db.Dispose();
}
}
public void UpdateMateriais(Materiais materiais)
{
try
{
SqlConnection con = new SqlConnection(connectionString);
con.Open();
SqlCommand cmd = new SqlCommand();
cmd.Connection = con;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "[dbo].[Update-Materiais]";
cmd.Parameters.AddWithValue("@Nome", materiais.Nome);
cmd.Parameters.AddWithValue("@Validade", materiais.Validade);
cmd.Parameters.AddWithValue("@Descricao", materiais.Descricao);
cmd.Parameters.AddWithValue("@Quantidade", materiais.Quantidade);
cmd.Parameters.AddWithValue("@TipoMaterial", materiais.Tipo_Material);
cmd.ExecuteNonQuery();
con.Close();
}
catch (Exception)
{
throw;
}
}
public Boolean alterarMaterial(int codMaterial,
string unidade,
int codFornecedor,
int codComprador,
string descricao,
string descricaoPopular,
double valorCompra,
double valorVenda)
{
Materiais objMaterial = FactoryClasses.criarMateriais();
objMaterial.Codigo = codMaterial;
objMaterial.Unidade = unidade;
Fornecedor objFornecedor = FactoryClasses.criarFornecedor();
objFornecedor.Codigo = codFornecedor;
objMaterial.Fornecedor = objFornecedor;
Comprador objComprador = FactoryClasses.criarComprador();
objComprador.Codigo = codComprador;
objMaterial.Comprador = objComprador;
objMaterial.Descricao = descricao;
objMaterial.DescricaoPopular = descricaoPopular;
objMaterial.ValorCompra = valorCompra;
objMaterial.ValorVenda = valorVenda;
return(objMaterialBll.alterarMaterial(objMaterial));
}
public Boolean excluirMaterial(Materiais objMaterial)
{
db = ServidorSingleton.obterServidor().OpenClient();
try
{
IObjectSet leitor = db.QueryByExample(objMaterial);
if (leitor.HasNext())
{
db.Delete((Materiais)leitor.Next());
db.Commit();
return(true);
}
else
{
return(false);
}
}
catch
{
db.Rollback();
return(false);
}
finally
{
db.Close();
db.Dispose();
}
}
public Materiais editarMaterial(int codMaterial)
{
Materiais objMaterial = FactoryClasses.criarMateriais();
objMaterial.Codigo = codMaterial;
return(objMaterialBll.editarMaterial(objMaterial));
}
public Boolean excluirMaterial(int codMaterial)
{
Materiais objMaterial = FactoryClasses.criarMateriais();
objMaterial.Codigo = codMaterial;
return(objMaterialBll.excluirMaterial(objMaterial));
}
public OrcamentoMateriais(Fornecedor Fornecedor)
{
this.Fornecedor = Fornecedor;
Materiais = Fornecedor.Materiais;
QuantidadeDeMateriais = Materiais.Count;
Total = Materiais.Sum(m => m.Quantidade * m.ValorUnitario);
}
public Boolean cadastrarSolicitacao(int codCliente,
string msg,
int codEngenheiroCampo,
string materiais
)
{
SolicitacaoMateriais objSolicitacao = FactoryClasses.criarSolicitacaoMateriais();
Cliente objCliente = FactoryClasses.criarCliente();
objCliente.Codigo = codCliente;
objSolicitacao.Cliente = objCliente;
Mensagem objMsg = FactoryClasses.criarMensagem();
objMsg.Msg = msg;
Collection <Mensagem> objMsgColecao = new Collection <Mensagem>();
objMsgColecao.Add(objMsg);
objSolicitacao.Msg = objMsgColecao;
EngenheiroCampo objEngCampo = FactoryClasses.criarEngenheiroCampo();
objEngCampo.Codigo = codEngenheiroCampo;
objSolicitacao.EngenheiroCampo = objEngCampo;
//Pega cada linha de item
string[] arrMateriaisLinha = materiais.Split('§');
//Faz um for em cada linha
Collection <Materiais> objMateriaisColecao = new Collection <Materiais>();
for (int i = 0; i < arrMateriaisLinha.Length - 1; i++)
{
string[] arrMateriais = arrMateriaisLinha[i].Split('|');
//Faz um for na quantidade e adiciona quantos itens na coleçao correspondendte a quantidade
for (int j = 1; j <= Convert.ToInt32(arrMateriais[1]); j++)
{
Materiais objMateriais = FactoryClasses.criarMateriais();
objMateriais.Codigo = Convert.ToInt32(arrMateriais[0]);
objMateriaisColecao.Add(objMateriais);
}
}
objSolicitacao.Materiais = objMateriaisColecao;
SolicitacaoMateriaisStatus objSolicitacaoStatus = FactoryClasses.criarSolicitacaoMateriaisStatus();
objSolicitacaoStatus.Codigo = 1;
objSolicitacaoStatus.Descricao = "Aguardando validação do gestor";
objSolicitacao.Status = objSolicitacaoStatus;
objSolicitacao.DataHora = DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss");
SolicitacaoMateriaisBll objSolicitacaoBll = FactoryBll.criarSolicitacaoMateriaisBll();
return(objSolicitacaoBll.cadastrarSolicitacao(objSolicitacao));
}
public ActionResult DeletaMaterial(int id)
{
Materiais m = db.Materiais.Find(id);
db.Materiais.Remove(m);
db.SaveChanges();
return(RedirectToAction("Materiais", "Administrador"));
}
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);
}
public ActionResult EditarMaterial(Materiais model)
{
if (ModelState.IsValid)
{
db.Entry(model).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Materiais", "Administrador"));
}
return(View(model));
}
private void AtualizarGridMateriais()
{
dgvMaterial.DataSource = (from m in Materiais select new { Quantidade = m.Quantidade, UnidadeMedida = m.UnidadeMedida, Descricao = m.Detalhes, Id = m.Id }).ToList();
if (Materiais.Any())
{
dgvMaterial.Columns["Descricao"].DisplayIndex = 0;
dgvMaterial.Columns["Quantidade"].DisplayIndex = 1;
dgvMaterial.Columns["UnidadeMedida"].DisplayIndex = 2;
dgvMaterial.Columns["Excluir"].DisplayIndex = 3;
}
}
public async Task <IActionResult> Create(Materiais materiais)
{
if (!ModelState.IsValid)
{
var materiais1 = await _materiaisService.FindAllAsync();
return(View(materiais1));
}
await _materiaisService.InsertAsync(materiais);
return(RedirectToAction(nameof(Index)));
}
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 ActionResult CriarMaterial(Materiais material)
{
material.selecionado = false;
if (ModelState.IsValid)
{
db.Materiais.Add(material);
db.SaveChanges();
return(RedirectToAction("Materiais", "Administrador"));
}
return(View(material));
}
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 override async void ReverseInit(object returndData)
{
base.ReverseInit(returndData);
oHorario.Visualizar = false;
var newMaterial = returndData as Material;
if (!Materiais.Contains(newMaterial))
{
Materiais.Add(newMaterial);
}
else
{
await GetMateriais();
}
}
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 ActionResult EditarMaterial(int?id)
{
if (id == null)
{
string mensagem = "Id do material não informado!";
return(RedirectToAction("Erro", "Home", new { Mensagem = mensagem }));
}
Materiais m = db.Materiais.Find(id);
if (m == null)
{
string mensagem = "Material não encontrado!";
return(RedirectToAction("Erro", "Home", new { Mensagem = mensagem }));
}
return(View(m));
}
private void dgvMaterial_CellClick(object sender, DataGridViewCellEventArgs e)
{
if (e.ColumnIndex == indexColunaExcluir && Materiais.Any())
{
Materiais.RemoveAt(e.RowIndex);
AtualizarGridMateriais();
}
else if (e.ColumnIndex == indexColunaEditar && Materiais.Any())
{
EncomendaMaterial material = Materiais.ElementAt(e.RowIndex);
txtDetalhes.Text = material.Detalhes;
txtQuantidade.Text = material.Quantidade.ToString();
txtUnidadeMedida.Text = material.UnidadeMedida;
indexItemMaterialEditando = e.RowIndex;
}
}
// Update
public async Task UpdateAsync(Materiais obj)
{
bool existe = await _context.Materiais.AnyAsync(x => x.Id == obj.Id);
if (!existe)
{
throw new ApplicationException("Registro não encontrado.");
}
try
{
_context.Update(obj);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException e)
{
throw new ApplicationException(e.Message);
}
}
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 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();
}
}
//
// GET: /Corrimao/
public ActionResult Index()
{
var viewModel = new ServicosViewModel();
var acoInox = new Materiais("Aço Inox", "descriçao do aço inox", "");
var acoCarbono = new Materiais("Aço Carbono", "descriçao do aço carbono", "");
var aluminio = new Materiais("Aluminio", "descriçao do aluminio", "");
var vidro = new Materiais("Vidro", "descriçao do vidro", "");
viewModel.Servicos.Add(new Servico("Corrimao", "Descricao do corrimao", "2.jpg", new List <Materiais> {
acoInox, acoCarbono, aluminio
}, "servicos", "corrimao"));
viewModel.Servicos.Add(new Servico("Guarda-corpo / Mezanino", "Descricao do Guarda-corpo / Mezanino", "3.jpg", new List <Materiais> {
acoInox, acoCarbono, aluminio, vidro
}, "servicos", "GuardaCorpo_Mezanino"));
viewModel.Servicos.Add(new Servico("Pergolado", "Descricao do Guarda-corpo / Mezanino", "4.jpg", new List <Materiais> {
acoInox, acoCarbono, aluminio
}, "servicos", "Pergolado"));
return(View(viewModel));
}
public ActionResult AssociaMateriais()
{
List <Materiais> materiais = db.Materiais.ToList();
if (cooperativa == null)
{
string id = User.Identity.GetUserId();
cooperativa = db.Cooperativas.Find(id);
}
foreach (var mc in cooperativa.MateriaisComercializados)
{
Materiais m = materiais.Find(x => x.materialId == mc.materialId);
if (m != null)
{
materiais.Remove(m);
}
}
return(View(materiais));
}
private void btnSalvarMaterial_Click(object sender, EventArgs e)
{
decimal quantidade = 0.0M;
Decimal.TryParse(txtQuantidade.Text, out quantidade);
if (String.IsNullOrEmpty(txtDetalhes.Text))
{
MessageBox.Show("Digite a descrição.", "Alerta", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else if (String.IsNullOrEmpty(txtUnidadeMedida.Text))
{
MessageBox.Show("Digite a unidade de medida.", "Alerta", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else if (quantidade <= 0)
{
MessageBox.Show("Quandidade inválida.", "Alerta", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else if (indexItemMaterialEditando < 0)
{
Materiais.Add(new EncomendaMaterial
{
Detalhes = txtDetalhes.Text
,
Quantidade = quantidade
,
UnidadeMedida = txtUnidadeMedida.Text
});
}
else
{
Materiais.ElementAt(indexItemMaterialEditando).Detalhes = txtDetalhes.Text;
Materiais.ElementAt(indexItemMaterialEditando).Quantidade = quantidade;
Materiais.ElementAt(indexItemMaterialEditando).UnidadeMedida = txtUnidadeMedida.Text;
indexItemMaterialEditando = -1;
}
AtualizarGridMateriais();
LimparFormMaterial();
}
public async Task <IActionResult> Edit(int id, Materiais materiais)
{
if (!ModelState.IsValid)
{
return(View(materiais));
}
if (id != materiais.Id)
{
return(RedirectToAction(nameof(Error), new { message = "Ids não correspondem." }));
}
try
{
await _materiaisService.UpdateAsync(materiais);
return(RedirectToAction(nameof(Index)));
}
catch (ApplicationException e)
{
return(RedirectToAction(nameof(Error), new { message = e.Message }));
}
}
public void cadastrarPedido(SolicitacaoMateriais objSolicitacao, string materiaisFornecedores)
{
PedidoDAO objPedidoDAO = FactoryDAO.criarPedidoDAO();
Collection <Materiais> objMateriaisColecao = new Collection <Materiais>();
//Obtem cada item e seu fornecedor
string[] arrLinhas = materiaisFornecedores.Split('§');
for (int i = 0; i < arrLinhas.Length; i++)
{
//Obtem o fornecedor e item
string[] arrItemFornecedor = arrLinhas[i].Split('|');
Materiais objMateriais = FactoryClasses.criarMateriais();
objMateriais.Codigo = Convert.ToInt32(arrItemFornecedor[0]);
Fornecedor objFornecedor = FactoryClasses.criarFornecedor();
objFornecedor.Codigo = Convert.ToInt32(arrItemFornecedor[1]);
objMateriais.Fornecedor = objFornecedor;
objMateriaisColecao.Add(objMateriais);
}
objSolicitacao.Materiais = objMateriaisColecao;
objPedidoDAO.cadastrarPedido(objSolicitacao);
}
public void Vender()
{
if (totalPayV > 0)
{
currentMoneyV += totalPayV;
LojaController.GetComponent <LojaConstroller>().currentMoney = currentMoneyV;
LojaController.GetComponent <LojaConstroller> ().Citem1 -= QuanItem1V;
LojaController.GetComponent <LojaConstroller> ().Citem2 -= QuanItem2V;
LojaController.GetComponent <LojaConstroller> ().Citem3 -= QuanItem3V;
LojaController.GetComponent <LojaConstroller> ().Citem4 -= QuanItem4V;
LojaController.GetComponent <LojaConstroller> ().Citem5 -= QuanItem5V;
LojaController.GetComponent <LojaConstroller> ().Citem6 -= QuanItem6V;
playerSafe = new PlayerP(fakeExp, currentMoneyV);
playerJson = JsonMapper.ToJson(playerSafe);
File.WriteAllText((Application.persistentDataPath + "/Player.json"), playerJson.ToString());
saveMaterial = new Materiais(LojaController.GetComponent <LojaConstroller> ().Citem1,
LojaController.GetComponent <LojaConstroller> ().Citem2,
LojaController.GetComponent <LojaConstroller> ().Citem3,
LojaController.GetComponent <LojaConstroller> ().Citem4,
LojaController.GetComponent <LojaConstroller> ().Citem5,
LojaController.GetComponent <LojaConstroller> ().Citem6);
playerJson = JsonMapper.ToJson(saveMaterial);
File.WriteAllText((Application.persistentDataPath + "/Materiais.json"), playerJson.ToString());
currentCashV.GetComponent <TextMesh> ().text = currentMoneyV.ToString();
AtualCash.GetComponent <TextMesh> ().text = currentMoneyV.ToString();
ZeraItens();
ValorGastar();
currentMoneyV = LojaController.GetComponent <LojaConstroller>().currentMoney;
}
else
{
LojaController.GetComponent <LojaConstroller> ().warnning2();
}
}
public void Materiais_load()
{
//VERIFICAR SE O ARQUIVO EXISTE
if (File.Exists(Application.persistentDataPath + "/Materiais.json"))
{
Debug.Log("Materiais.json exist");
}
else
{
Debug.Log("Materiais.json do not exist");
mate1qnt = 0;
mate2qnt = 0;
mate3qnt = 0;
mate4qnt = 0;
mate5qnt = 0;
mate6qnt = 0;
Materiais = new Materiais(mate1qnt, mate2qnt, mate3qnt, mate4qnt, mate5qnt, mate6qnt);
playerJson = JsonMapper.ToJson(Materiais);
//File.WriteAllText(Application.dataPath + "/lastMonster.json", playerJson.ToString());
File.WriteAllText((Application.persistentDataPath + "/Materiais.json"), playerJson.ToString());
}
}
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;
}
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 excluirMaterial(Materiais objMaterial)
{
db = ServidorSingleton.obterServidor().OpenClient();
try
{
IObjectSet leitor = db.QueryByExample(objMaterial);
if (leitor.HasNext())
{
db.Delete((Materiais)leitor.Next());
db.Commit();
return true;
}
else
{
return false;
}
}
catch
{
db.Rollback();
return false;
}
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 Boolean cadastrarMaterial(Materiais objMaterial)
{
return objMaterialDAO.cadastrarMaterial(objMaterial);
}
// Insert
public async Task InsertAsync(Materiais obj)
{
_context.Add(obj);
await _context.SaveChangesAsync();
}
public Boolean excluirMaterial(Materiais objMaterial)
{
return objMaterialDAO.excluirMaterial(objMaterial);
}
public Boolean alterarMaterial(Materiais objMaterialAtualizar)
{
return objMaterialDAO.alterarMaterial(objMaterialAtualizar);
}
public Materiais editarMaterial(Materiais objMaterial)
{
return objMaterialDAO.editarMaterial(objMaterial);
}