//------------------------------- Fim Funções AD ------------------------------------------//
//------------------------------- Funções Controller ------------------------------------------//
// GET: Computadores
public ActionResult Index()
{
Computador computador = new Computador();
var list = new List <Computador>();
return(View(list.OrderBy(u => u.NomeComputador)));
}
private void btnSalvar_Click(object sender, EventArgs e)
{
var novo = indexarDados();
if (this.Computador == null)
{
this.Computador = novo;
this.Dispose();
}
else
{
using (var ctx = new BalcaoContext())
{
var current = ctx.ComputadorDao.Find(this.Computador.IdComputador);
current.Update(novo);
this.Computador.Update(novo);
if (ctx.ComputadorDao.Update(current))
{
this.Dispose();
}
}
}
}
public ActionResult Create(Computador computador, int GabineteId, int ProcessadorId, int PlacaMaeId, int RamId, int qtdram, int GPUId, int qtdgpu, int FonteId, int HDId, int qtdhd)
{
computador.Gabinete = db.Gabinetes.Find(GabineteId);
computador.Processador = db.Processadors.Find(ProcessadorId);
computador.Placamae = db.PlacaMaes.Find(PlacaMaeId);
computador.Ram = db.Rams.Find(RamId);
computador.QtdRam = qtdram;
computador.Gpu = db.GPUs.Find(GPUId);
computador.QtdGpu = qtdgpu;
computador.Fonte = db.Fontes.Find(FonteId);
computador.Hd = db.HDs.Find(HDId);
computador.QtdHd = qtdhd;
computador.Preço = computador.Gabinete.Preco + computador.Processador.Preco + computador.Placamae.Preco
+ (computador.Ram.Preco * computador.QtdRam) + (computador.Gpu.Preco * computador.QtdGpu)
+ computador.Fonte.Preco + (computador.Hd.Preco * computador.QtdHd);
if (!ModelState.IsValid)
{
db.Computadores.Add(computador);
db.SaveChanges();
return(RedirectToAction("Index"));
}
CarregarListas();
return(View(computador));
}
private Computador indexarDados(Computador pc)
{
if (pc != null)
{
txtPlacaMae.Text = pc.NomePlacaMae;
txtProcessador.Text = pc.Processador;
txtMemRam.Text = pc.MemoriaRam;
txtHd.Text = pc.Hd;
var pcs = new List <SistemaOperacional>();
pcs.Add(pc.SistemaOperacional);
var so = pc.SistemaOperacional;
if (so != null)
{
txtSO.Text = so.NomeSistema;
cbArq.AddItem <SistemaOperacional>(so);
}
txtNomePc.Text = pc.NomeComputador;
txtGrupoTrabalho.Text = pc.GrupoTrabalho;
}
return(pc);
}
public ActionResult EnviarMensagem([FromBody] Computador request)
{
var factory = new ConnectionFactory()
{
HostName = _appSettings.Host, Port = 5672
};
var mensagem = $"O notebook {request.Marca} contém as configurações: {request.Configuracoes}.";
using (var connection = factory.CreateConnection())
{
using (var channel = connection.CreateModel())
{
//Usar o código comentado abaixo somente quando for criar uma queue (fila).
//channel.QueueDeclare(queue: _appSettings.Queue,
// durable: false,
// exclusive: false,
// autoDelete: false,
// arguments: null);
var body = Encoding.UTF8.GetBytes(mensagem);
channel.BasicPublish(exchange: "",
routingKey: _appSettings.Queue,
basicProperties: null,
body: body);
}
}
return(Ok($"Mensagem '{mensagem}' enviada com sucesso!"));
}
public void ComputadorAppService_BuscarComputadorPorDescricao_RetornoValido()
{
// Arrange
var vm = new ConsultarComputadorViewModel();
vm.Descricao = "C001";
var computador = new Computador("C001", "A01");
var repo = new Mock <IComputadorRepositorio>();
repo.Setup(x => x.BuscarPorDescricao(vm.Descricao)).Returns(computador);
var servico = new Mock <IComputadorServico>();
servico.Setup(x => x.BuscarPorDescricao(vm.Descricao)).Returns(computador);
var appServico = new ComputadorAppServico(servico.Object);
// Act
var resultado = appServico.BuscarPorDescricao(vm.Descricao);
// Assert
Assert.NotNull(resultado);
Assert.Equal(computador.Descricao, resultado.Descricao);
Assert.Equal(computador.Andar, resultado.Andar);
Assert.Equal(computador.Ativo, resultado.Ativo);
Assert.Equal(computador.Ocorrencias, resultado.Ocorrencias);
Assert.Equal("OK", resultado.ResultadoTransacao);
}
public void ComputadorService_ConsultarPorAndar_ValidarResultado()
{
// Arrange
var lista = new List <Computador>();
var c1 = new Computador("C001", "A01");
lista.Add(c1);
var c2 = new Computador("C002", "A01");
lista.Add(c2);
var c3 = new Computador("C003", "A01");
lista.Add(c3);
var c4 = new Computador("C004", "A01");
lista.Add(c4);
var repositorio = new Mock <IComputadorRepositorio>();
repositorio.Setup(x => x.BuscarTodosPorAndar("A01")).Returns(lista);
repositorio.Setup(x => x.BuscarTodosPorAndar("A02")).Returns(new List <Computador>());
var servico = new ComputadorServico(repositorio.Object);
// Act
var listaA01 = servico.BuscarTodosPorAndar("A01");
var listaA02 = servico.BuscarTodosPorAndar("A02");
// Assert
Assert.True(listaA01 != null);
Assert.Equal(4, listaA01.ToList().Count);
Assert.True(listaA02 != null);
Assert.Equal(0, listaA02.ToList().Count);
}
public Computador GetCompPrecoAVista(int id)
{
Computador compDesconto = pcDAO.GetFind(id);
compDesconto.preco = ((compDesconto.preco * 90) / 100);
return(compDesconto);
}
//método para listar as Computadores por data e por usuario..
public List <Computador> Find(string empresa)
{
OpenConnection();
string query = " select * from Computador where IdUsuario = (select IdUsuario from Usuario where Empresa = @Empresa) ";
cmd = new SqlCommand(query, con);
cmd.Parameters.AddWithValue("@Empresa", empresa);
dr = cmd.ExecuteReader(); //executando e lendo..
//criando uma lista de computadores..
List <Computador> lista = new List <Computador>();
while (dr.Read()) //percorrendo os registros do SqlDataReader..
{
Computador c = new Computador();
c.Usuario = new Usuario();
c.IdComputador = Convert.ToInt32(dr["IdComputador"]);
c.Marca = Convert.ToString(dr["Marca"]);
c.Modelo = Convert.ToString(dr["Modelo"]);
c.PlacaMae = Convert.ToString(dr["PlacaMae"]);
c.MemoriaRAM = Convert.ToInt32(dr["Mram"]);
c.HdArmazenamento = Convert.ToInt32(dr["Hd"]);
c.HdMarca = Convert.ToString(dr["HdMarca"]);
c.VelocidadeProcessador = Convert.ToString(dr["Vprocessador"]);
c.Foto = Convert.ToString(dr["Foto"]);
c.Usuario.IdUsuario = Convert.ToInt32(dr["IdUsuario"]);
lista.Add(c); //adicionar na lista..
}
CloseConnection();
return(lista);
}
protected void BtnCadastro_Click(object sender, EventArgs e)
{
if (ValidarCampos())
{
try
{
//Pegando id da URL
int id = int.Parse(Request.QueryString["id"]);
//Instalando objetos
ComputadorBusiness business = new ComputadorBusiness();
Computador c = new Computador();
//alimentando o objeto
c.Marca = txtMarca.Text;
c.Modelo = txtModelo.Text;
c.PlacaMae = txtPmae.Text;
c.MemoriaRAM = int.Parse(txtRam.Text);
c.HdArmazenamento = int.Parse(txtHd.Text);
c.HdMarca = txtmhd.Text;
}
catch (Exception ex)
{
lblMensagem.Text = ex.Message;
}
}
}
public Computador Put <V>(Computador obj) where V : AbstractValidator <Computador>
{
Validate(obj, Activator.CreateInstance <V>());
repository.Update(obj);
return(obj);
}
public ActionResult CriarComputador(ComputadorViewModelCria computadorViewModelCria)
{
try
{
Computador computador = new Computador();
computador.IDUsuario = User.Identity.GetUserId();
//computador.DataCriacao = DateTime.Now;
computador.Fonte = Mapper.Map <Fonte>(computadorViewModelCria);
computador.HD = Mapper.Map <HD>(computadorViewModelCria);
computador.MemoriaRAM = Mapper.Map <MemoriaRAM>(computadorViewModelCria);
computador.PlacaMae = Mapper.Map <PlacaMae>(computadorViewModelCria);
computador.Processador = Mapper.Map <Processador>(computadorViewModelCria);
servicoComputador.Inserir(computador);
TempData["MensagemSucesso"] = "Computador cadastrado com sucesso!";
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ViewBag.MensagemErro = "Ocorreu um erro, tente novamente ou entre em contato com nosso suporte. Detalhe do erro: " + ex.Message;
return(View());
}
}
public void Create_ComputadorItemInvalido()
{
Assert.Throws <IdBadException>(() =>
{
Item _item = new Computador(-123);
});
}
public void Create_ComputadorItemIps()
{
Computador _item = new Computador(123);
// Adiciona um ip e verifica se ficou
_item.IpInsere("127.0.0.1");
Assert.IsTrue(_item.IpExiste("127.0.0.1"));
// Tem de ter um ip
Assert.AreEqual(_item.IpCount, 1);
// Tenta adicionar o mesmo ip têm de dar exepção
Assert.Throws <ArgumentException>(() =>
{
_item.IpInsere("127.0.0.1");
});
// Tem de continuar com 1 ip
Assert.AreEqual(_item.IpCount, 1);
// Remove o ip adicionado
_item.IpRemove("127.0.0.1");
Assert.IsFalse(_item.IpExiste("127.0.0.1"));
Assert.AreEqual(_item.IpCount, 0);
// Tenta remover um ip que nao existe têm de dar exption
Assert.Throws <ArgumentException>(() =>
{
_item.IpRemove("127.0.0.2");
});
// Tenta adicionar um ip inválido
Assert.Throws <ArgumentException>(() =>
{
_item.IpInsere("INVALIDO");
});
}
public void ComputadorItemAddtoInventoryByIdDuplicate()
{
int idinventario = 100;
int itemid = 100;
// Limpa o inventário
Inventario.getInstance(idinventario).RemoveAll();
// Cria um item com o id itemid
Item _item = new Computador(itemid);
(_item as Computador).RamInsere(23);
(_item as Computador).DiscoInsere(1024);
// Diz ao item para se adicionar ao inventário com instancia idinventario 2 vezes
_item.AddToInventario(idinventario);
Assert.Throws <ArgumentException>(() =>
{
_item.AddToInventario(idinventario);
});
Item _item2 =
(Item)Inventario
.getInstance(idinventario)
.GetItemById(itemid);
Assert.AreEqual(_item2.Id, itemid);
}
private void CadastrarComputador(Computador computador)
{
computadorC.Cadastrar(computador);
computador.codUsuario = computador.codUsuario;
computador.RAM.codUsuario = computador.codUsuario;
computador.RAM.codComputador = computador.codComputador;
computador.processadores.codUsuario = computador.codUsuario;
computador.processadores.codComputador = computador.codComputador;
computador.OS.codComputador = computador.codComputador;
computador.OS.codUsuario = computador.codUsuario;
foreach (Armazenamento armazenamento in computador.armazenamentos)
{
armazenamento.codUsuario = computador.codUsuario;
armazenamento.codComputador = computador.codComputador;
}
processadorC.Cadastrar(computador.processadores);
historicoEstado.Cadastrar(computador.RAM);
foreach (Armazenamento armazenamento in computador.armazenamentos)
{
armazenamentoC.Cadastrar(armazenamento);
}
sistemaOperacionalC.Cadastrar(computador.OS);
}
void listarDisponibilidade()
{
using (DataClassesDataContext db = new DataClassesDataContext())
{
Computador c = new Computador();
var idLab = c.pegarIdLaboratorio(dplLabs.SelectedItem.Text);
var horarios = from p in db.tb_Horarios select p;
foreach (var item in horarios)
{
var agendamento = from p in db.tb_Agendamentos
where p.dt_agendamento == DateTime.Parse(txtData.Text) &&
p.id_Horario == item.id_Horario && p.id_laboratorio == idLab
select p;
if (agendamento.Count() == 0)
{
dplHorarioInicial.Items.Add(Convert.ToString(item.hr_HorarioInicial));
}
dplHorarioInicial.DataBind();
}
}
}
public ActionResult DeletarComputador(ComputadorViewModelExclui computadorViewModelExclui)
{
try
{
Computador computador = Mapper.Map <Computador>(computadorViewModelExclui);
Fonte fonte = Mapper.Map <Fonte>(computadorViewModelExclui);
HD hd = Mapper.Map <HD>(computadorViewModelExclui);
MemoriaRAM memoriaRAM = Mapper.Map <MemoriaRAM>(computadorViewModelExclui);
PlacaMae placaMae = Mapper.Map <PlacaMae>(computadorViewModelExclui);
Processador processador = Mapper.Map <Processador>(computadorViewModelExclui);
servicoComputador.Deletar(computador);
servicoFonte.Deletar(fonte);
servicoHD.Deletar(hd);
servicoMemoriaRAM.Deletar(memoriaRAM);
servicoPlacaMae.Deletar(placaMae);
servicoProcessador.Deletar(processador);
TempData["MensagemSucesso"] = "Computador deletado com sucesso!";
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ViewBag.MensagemErro = "Ocorreu um erro, tente novamente ou entre em contato com nosso suporte. Detalhe do erro: " + ex.Message;
return(View());
}
}
public Computador FindById(int id)
{
OpenConnection();
string query = "select * from Computador where IdComputador = @IdComputador";
cmd = new SqlCommand(query, con);
cmd.Parameters.AddWithValue("@IdComputador", id);
dr = cmd.ExecuteReader();
Computador c = null;
if (dr.Read())
{
c = new Computador();
c.IdComputador = Convert.ToInt32(dr["IdComputador"]);
c.Marca = Convert.ToString(dr["Marca"]);
c.Modelo = Convert.ToString(dr["Modelo"]);
c.PlacaMae = Convert.ToString(dr["PlacaMae"]);
c.MemoriaRAM = Convert.ToInt32(dr["Mram"]);
c.HdArmazenamento = Convert.ToInt32(dr["Hd"]);
c.HdMarca = Convert.ToString(dr["HdMarca"]);
c.VelocidadeProcessador = Convert.ToString(dr["Vprocessador"]);
c.Foto = Convert.ToString(dr["Foto"]);
}
CloseConnection();
return(c);
}
public void ComputadorAppService_InformarLiberacaoDoComputador_ComputadorNaoExiste()
{
// Arrange
var vm = new LiberarComputadorViewModel();
vm.DescricaoComputador = "C001";
var computador = new Computador("C001", "A01");
computador.Ocorrencias.Add(Ocorrencia.OcorrenciaFabrica.ComputadorEmUso());
var repo = new Mock <IComputadorRepositorio>();
repo.Setup(x => x.Atualizar(computador));
var servico = new Mock <IComputadorServico>();
servico.Setup(x => x.BuscarPorDescricao(vm.DescricaoComputador));
servico.Setup(x => x.Atualizar(computador));
var appServico = new ComputadorAppServico(servico.Object);
// Act
vm = appServico.LiberarComputador(vm);
// Assert
Assert.Equal(string.Format("O computador {0} não existe.", vm.DescricaoComputador), vm.Resultado);
Assert.Equal("Computador não existe", appServico.BuscarPorDescricao(vm.DescricaoComputador).ResultadoTransacao);
}
public static Computador getInfoComputador(string _hostname)
{
Computador pc = new Computador();
using (SqlConnection cnn = new SqlConnection(ConfigurationManager.ConnectionStrings["psConnectionString"].ToString()))
{
SqlCommand cmm = cnn.CreateCommand();
cmm.CommandText = "SELECT * FROM [hspmPs].[dbo].[vw_impressora_computador] WHERE nome_computador = '" + _hostname + "'";
try
{
cnn.Open();
SqlDataReader dr1 = cmm.ExecuteReader();
if (dr1.Read())
{
pc.id_computador = dr1.GetInt32(0);
pc.nome_computador = dr1.GetString(1);
pc.descricao_computador = dr1.GetString(2);
pc.ip_computador = dr1.IsDBNull(3) ? "" : dr1.GetString(3);
pc.id_impressora_fk = dr1.GetInt32(4);
pc.id_impressora = dr1.GetInt32(5);
pc.tipo = dr1.IsDBNull(6) ? "" : dr1.GetString(6);
pc.nome_impressora = dr1.GetString(7);
pc.descricao_impressora = dr1.GetString(8);
pc.ip_impressora = dr1.IsDBNull(9) ? "" : dr1.GetString(9);
}
cnn.Close();
}
catch (Exception ex)
{
string error = ex.Message;
}
}
return(pc);
}
public void ComputadorAppService_InformarUtilizacao_RetornarComputadorDesativadoException()
{
// Arrange
var vm = new UtilizarComputadorViewModel();
vm.Descricao = "C001";
var computador = new Computador("C001", "A01");
computador.Ocorrencias.Add(Ocorrencia.OcorrenciaFabrica.PrimeiraOcorrencia());
var repo = new Mock <IComputadorRepositorio>();
repo.Setup(x => x.Atualizar(computador));
var servico = new Mock <IComputadorServico>();
servico.Setup(x => x.BuscarPorDescricao(vm.Descricao)).Returns(computador);
servico.Setup(x => x.Atualizar(computador))
.Throws(new ComputadorDesativadoException());
var appServico = new ComputadorAppServico(servico.Object);
// Act & Assert
var ex = Assert.Throws <ComputadorDesativadoException>(() => appServico.UtilizarComputador(vm));
Assert.NotNull(ex);
Assert.Equal("Computador desativado. Não é possível utilizar este computador!", ex.Message);
}
public void ComputadorAppService_InformarLiberacaoDoComputador_ComputadorLiberado()
{
// Arrange
var vm = new LiberarComputadorViewModel();
vm.DescricaoComputador = "C001";
var computador = new Computador("C001", "A01");
computador.Ocorrencias.Add(Ocorrencia.OcorrenciaFabrica.ComputadorEmUso());
var repo = new Mock <IComputadorRepositorio>();
repo.Setup(x => x.Atualizar(computador));
var servico = new Mock <IComputadorServico>();
servico.Setup(x => x.BuscarPorDescricao(vm.DescricaoComputador)).Returns(computador);
servico.Setup(x => x.Atualizar(computador));
var appServico = new ComputadorAppServico(servico.Object);
// Act
vm = appServico.LiberarComputador(vm);
// Assert
Assert.NotNull(vm);
Assert.Equal(string.Format("O computador {0} foi liberado.", vm.DescricaoComputador), vm.Resultado);
Assert.True(appServico.BuscarPorDescricao(vm.DescricaoComputador).PegarUltimaOcorrencia().Liberado);
}
private void btnMontar_Click(object sender, RoutedEventArgs e)
{
try
{
Computador pc = new Computador();
pc.PlacamaeID = int.Parse(ComboBoxPlacaMae.SelectedValue.ToString());
pc.ProcessadorID = int.Parse(ComboBoxProcessador.SelectedValue.ToString());
// Tamo ferrado
pc.HDID = int.Parse(ComboBoxHd.SelectedValue.ToString());
pc.MemoriaID = int.Parse(ComboBoxMemoria.SelectedValue.ToString());
pc.FonteID = int.Parse(ComboBoxMemoria.SelectedValue.ToString());
ComputadorController montarPC = new ComputadorController();
montarPC.Salvar(pc);
MessageBox.Show("Computador salvo com exito!");
this.Close();
}
catch (Exception ex)
{
MessageBox.Show("Erro ao salvar computador (" + ex.Message + ")");
}
}
public void ComputadorAppService_InformarUtilizacao_RetornoValido()
{
// Arrange
var vm = new UtilizarComputadorViewModel();
vm.Descricao = "C001";
var computador = new Computador("C001", "A01");
computador.Ocorrencias.Add(Ocorrencia.OcorrenciaFabrica.PrimeiraOcorrencia());
var repo = new Mock <IComputadorRepositorio>();
repo.Setup(x => x.Atualizar(computador));
var servico = new Mock <IComputadorServico>();
servico.Setup(x => x.BuscarPorDescricao(vm.Descricao)).Returns(computador);
servico.Setup(x => x.Atualizar(computador));
var appServico = new ComputadorAppServico(servico.Object);
// Act
vm = appServico.UtilizarComputador(vm);
// Assert
Assert.True(!appServico.BuscarPorDescricao(vm.Descricao).VerificarDisponibilidade());
Assert.Equal(false, appServico.BuscarPorDescricao(vm.Descricao).PegarUltimaOcorrencia().Liberado);
Assert.Equal("Agora este computador está em uso.", vm.Resultado);
}
public int Inserir(Computador computador)
{
computador.RegistroAtivo = true;
context.Computadores.Add(computador);
context.SaveChanges();
return(computador.Id);
}
static void Main(string[] args)
{
try
{
Computador ComputadorJuanPablo = new Computador();
//ComputadorJuanPablo.Pantalla = new Pantalla();
ComputadorJuanPablo.Pantalla.Color = "Negro";
ComputadorJuanPablo.Pantalla.Marca = "HP";
ComputadorJuanPablo.Pantalla.Tamaño = 15;
ComputadorJuanPablo.Cpu = new Cpu()
{
Marca = "Intel",
Procesador = 3.20,
Ram = 16,
TieneGpu = true
};
Console.WriteLine("Juan Pablo tiene un computador con "
+ ComputadorJuanPablo.Cpu.Procesador + " de PROCESADOR y "
+ ComputadorJuanPablo.Cpu.Ram + " de RAM");
Console.WriteLine("Juan pablo tiene un toro de PC ;)");
}
catch (Exception ex)
{
Console.WriteLine("Ups! ha ocurrido un error. Error:" + ex.Message);
}
Console.ReadKey();
}
public static void Main(string[] args)
{
int option = 1;
Console.Clear();
Console.WriteLine(" Escolha seu Modo de Jogo");
Console.WriteLine(" ");
Console.WriteLine(" (1) 2 jogadores");
Console.WriteLine(" ");
Console.WriteLine(" (2) Versus PC");
Console.WriteLine(" ");
option = Convert.ToInt32(Console.ReadLine());
if (option == 1)
{
Console.Clear();
Tabuleiro.ImprimirTabuleiro();
Tabuleiro.PreencherTabuleiro();
Jogadas.Jogador1();
}
if (option == 2)
{
Console.Clear();
Tabuleiro.ImprimirTabuleiro();
Tabuleiro.PreencherTabuleiro();
Computador.Player();
}
}
static void Main(string[] args)
{
Computador Accer = new Computador();
Computador Asus = new Computador("X1KL6555");
Computador Samsung = new Computador(2500, "preto");
Computador Lenovo = new Computador("X254LM", "branco");
/*****************************************************************/
Estudante Carlos = new Estudante();
Estudante Daniel = new Estudante("Daniel");
Estudante Jesus = new Estudante(17, "47-99245-1683");
Estudante David = new Estudante("Carlos", 17);
Estudante Rodrigo = new Estudante("rodrigo@gmail", "47-99565-7895");
/*****************************************************************/
Veiculo Celta = new Veiculo("Caminhão");
Veiculo Agile = new Veiculo("Carro", 2005);
Veiculo Gol = new Veiculo(2010);
Veiculo Saveiro = new Veiculo("Prata", "Confortline");
Veiculo Cb300 = new Veiculo("Vermelha", "Esport", 2020, "Moto");
}
public void ComputadorAppService_BuscarComputadorPorId_ValidarRetorno()
{
// Arrange
var computador = new Computador("C001", "A01");
computador.Id = "123";
computador.Ocorrencias.Add(Ocorrencia.OcorrenciaFabrica.PrimeiraOcorrencia());
var repo = new Mock <IComputadorRepositorio>();
repo.Setup(x => x.Buscar(computador.Id)).Returns(computador);
var servico = new Mock <IComputadorServico>();
servico.Setup(x => x.Buscar(computador.Id)).Returns(computador);
var appServico = new ComputadorAppServico(servico.Object);
// Act
var resultado = appServico.Buscar(computador.Id);
// Assert
Assert.NotNull(resultado);
Assert.Equal(computador.Id, resultado.Id);
Assert.Equal("OK", resultado.ResultadoTransacao);
Assert.True(!string.IsNullOrEmpty(resultado.Descricao.Trim()));
Assert.True(!string.IsNullOrEmpty(resultado.Andar.Trim()));
Assert.True(resultado.Ocorrencias.Count > 0);
}
private void btnGravar_Click(object sender, EventArgs e)
{
computadorApp = new ServicoDeComputador();
objComputador = new Computador();
lbMensagem.Visible = false;
bool result = true;
if (!String.IsNullOrEmpty(txtDescricao.Text))
{
if (iCodigo == 0)
{
objComputador.Descricao = txtDescricao.Text;
result = computadorApp.Adicionar(objComputador);
}
else
{
objComputador = computadorApp.GetById(iCodigo);
objComputador.Descricao = txtDescricao.Text;
result = computadorApp.Alterar(objComputador);
}
if (result)
{
EstadoInicial();
AlterarMsg("Gravado com sucesso!", false);
}
else
AlterarMsg("Erro ao gravar os dados", true);
}
else
AlterarMsg("Nome é obrigatório!", true);
computadorApp.Dispose();
}
public bool Alterar(Computador computador)
{
_db.Entry(computador).State = EntityState.Modified;
return _db.SaveChanges() > 0;
}
public bool Adicionar(Computador computador)
{
_db.Computadores.Add(computador);
return _db.SaveChanges() > 0;
}
private void btnExcluir_Click(object sender, EventArgs e)
{
computadorApp = new ServicoDeComputador();
objComputador = new Computador();
lbMensagem.Visible = false;
if (MessageBox.Show("Deseja excluir esse computador?", "Excluir", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
if (iCodigo > 0)
{
objComputador = computadorApp.GetById(iCodigo);
if (computadorApp.Excluir(objComputador.Id))
{
EstadoInicial();
AlterarMsg("Excluido com sucesso!", false);
}
else
{
AlterarMsg("Erro ao excluir os dados!", true);
}
}
else
AlterarMsg("Nenhum aluno para excluir!", true);
}
computadorApp.Dispose();
}
