public Medico Update(Medico medico)
 {
     DbEntityEntry entry = context.Entry(medico);
     entry.State = EntityState.Modified;
     context.SaveChanges();
     return medico;
 }
Example #2
0
        private void button1_Click(object sender, EventArgs e)
        {
            try
            {
                if (validaCampos())
                {
                    Endereco endereco = new Endereco(textBox2.Text, int.Parse(textBox3.Text), textBox4.Text, textBox17.Text,
                    textBox5.Text, int.Parse(textBox7.Text), comboBox1.Text);

                    Medico medico = new Medico(textBox15.Text, textBox16.Text, endereco, textBox1.Text,
                        int.Parse(textBox11.Text), int.Parse(textBox9.Text),
                        especialidades);

                    StringBuilder dadosMedico = new StringBuilder();
                    dadosMedico.AppendLine(medico.Nome + " cadastrado com sucesso!");
                    dadosMedico.AppendLine("\tEspecialidades:\n"+medico.listarEspecialidades());
                    MessageBox.Show(dadosMedico.ToString(), "Médico cadastrado");

                    limpaCampos();

                }
                else
                    MessageBox.Show("Preencha todos os campos.");
            }catch(FormatException fe){

                MessageBox.Show("Digite um número válido", "Valor inválido");

            }
        }
        public void CreateAInvalidMedicoEspecialidadeTest()
        {
            Medico medico = new Medico();
            medico.Especialidade = "Pediatra";

            Validator.Validate(medico);
        }
        public Medico Create(Medico medico)
        {
            Validator.Validate(medico);

            var savedMedico = _medicoRepository.Save(medico);

            return savedMedico;
        }
        public Medico Update(Medico medico)
        {
            Validator.Validate(medico);

            var updatedMedico = _medicoRepository.Update(medico);

            return updatedMedico;
        }
        public void CreateAInvalidMedicoTest()
        {
            Medico medico = new Medico();
            medico.Nome = "Pedro";
            medico.Especialidade = "Pediatra";
            medico.Residente = "Nossa Senhora dos Prazeres";

            Validator.Validate(medico);
        }
        public static Medico GetMedico()
        {
            Medico medico = new Medico();
            medico.Nome = "Pedro";
            medico.Especialidade = "Pediatra";
            medico.Residente = "Nossa Senhora dos Prazeres";

            return medico;
        }
Example #8
0
        public ActionResult Excluir(Medico Medico)
        {
            if (Request.IsAuthenticated)
            {
                medicoRepositorio.Excluir(Medico);
                return View("Index", medicoRepositorio.SelecionarTodos());
            }

            ViewBag.MensagemErro = "Desculpe, você não está autenticado no sistema. Página restrita.";
            return View("Error");
        }
        private static Medico VerificaMedico(int medicoId, string medicoName)
        {
            var entities = new Entities();

            var medicos = from m in entities.Medico
                          where m.Codigo == medicoId.ToString()
                          select m;

            if (!medicos.Any())
            {
                var novoMedico = new Medico { Codigo = medicoId.ToString(), Nome = medicoName };
                entities.Medico.AddObject(novoMedico);
                entities.SaveChanges();
                return novoMedico;
            }

            return medicos.First();
        }
Example #10
0
        public void Salvar(Medico medico)
        {
            try
            {
                var sql = "INSERT INTO medico(nome, idEspecialidade, crm, dtCadastro)" +
                          "VALUES(@nome, @idEspecialidade, @crm, CURRENT_TIMESTAMP())";

                command = new MySqlCommand(sql, connection);
                command.Parameters.AddWithValue("@nome", medico.Nome);
                command.Parameters.AddWithValue("@idEspecialidade", medico.IdEspecialidade);
                command.Parameters.AddWithValue("@crm", medico.Crm);

                command.ExecuteNonQuery();
            }
            catch (Exception erro)
            {
                throw new Exception("Erro ao registrar dado " + erro.Message + erro.ToString());
            }
            finally
            {
            }
        }
Example #11
0
        public List <Medico> listarMedico()
        {
            try
            {
                SqlConnection cnx = cn.conectar();

                cm = new SqlCommand("Medic", cnx);
                cm.Parameters.AddWithValue("@b", 3);
                cm.Parameters.AddWithValue("@IdMedico", "");
                cm.Parameters.AddWithValue("@NombreMedico", "");
                cm.Parameters.AddWithValue("@Telefono_Celular", "");
                cm.Parameters.AddWithValue("@IdEspecialidad", "");

                cm.CommandType = CommandType.StoredProcedure;
                cnx.Open();
                dr          = cm.ExecuteReader();
                listaMedico = new List <Medico>();

                while (dr.Read())
                {
                    Medico md = new Medico();
                    md.IdMedico         = Convert.ToInt32(dr["IdMedico"].ToString());
                    md.NombreMedico     = dr["NombreMedico"].ToString();
                    md.Telefono_Celular = Convert.ToInt32(dr["Telefono_Celular"].ToString());
                    md.IdEspecialidad   = Convert.ToInt32(dr["IdEspecialidad"].ToString());
                    listaMedico.Add(md);
                }
            }
            catch (Exception e)
            {
                e.Message.ToString();
                listaMedico = null;
            }
            finally
            {
                cm.Connection.Close();
            }
            return(listaMedico);
        }
Example #12
0
        public Medico GetMedicoPorDni(int DNI)
        {
            SqlConnection conexion   = new SqlConnection(cadenaConexion);
            SqlCommand    cmdMedicos = new SqlCommand("SELECT DNI_m, especialidad, fecha_ingreso, monto_especialidad, estado from MEDICO where DNI_m=" + DNI + "ORDER BY DNI_m", conexion);

            conexion.Open();
            SqlDataReader drMedicos = cmdMedicos.ExecuteReader();
            Medico        medico    = new Medico();


            while (drMedicos.Read())
            {
                medico.Dni               = Int32.Parse(drMedicos["DNI_m"].ToString());
                medico.Especialidad      = drMedicos["especialidad"].ToString();
                medico.FechaIngreso      = Convert.ToDateTime(drMedicos["fecha_ingreso"].ToString());
                medico.MontoEspecialidad = Int32.Parse(drMedicos["monto_especialidad"].ToString());
                medico.Estado            = drMedicos["estado"].ToString();
            }//while
            conexion.Close();

            return(medico);
        }
        public ActionResult ValidarToken(TokenViewModel tokenViewModel)
        {
            if (tokenViewModel.Valido())
            {
                // Validação do Token.
                string tokenBase64 = Utils.Base64Encode(tokenViewModel.Token);
                TokenAtendimento token = this.TokenAtendimentoRepository.Obter(tokenBase64, tokenViewModel.NumeroAtendimento.Value);

                if (token == default(TokenAtendimento))
                    return Json("Token inválido.");

                if (!token.Valido())
                    return Json("Token inválido.");

                token.ConfirmarToken();
                token = this.TokenAtendimentoRepository.ConfirmarToken(token.CodigoTokenAtendimento);

                // Envia e-mail para médico informando que a consulta foi autenticada com sucesso

                Atendimento atendimento = this.AtendimentoRepository.Obter(tokenViewModel.NumeroAtendimento.Value);

                if (atendimento == default(Atendimento))
                    return Json("Atendimento não encontrado.");

                atendimento.Token = tokenBase64;
                this.AtendimentoRepository.AlterarToken(atendimento);

                Medico medico = this.MedicoRepository.Obter(atendimento.CodigoMedico);

                if (medico == default(Medico))
                    return Json("Médico não encontrado.");

                Utils.SendEmail(medico.Email, $"Olá {medico.NomeGuerra}, o atendimento #{atendimento.NumeroAtendimento} realizado às {atendimento.DataAtendimento.ToString("HH:mm tt")} do dia {atendimento.DataAtendimento.ToString("dd/MM/yyyy")} foi autenticado com sucesso.", "Atendimento autenticado por Token com sucesso!");

                return RedirectToAction("Index", "Atendimento");
            }

            return View();
        }
Example #14
0
        private void BtnGravar_Click(object sender, EventArgs e)
        {
            try
            {
                if (listacon.Count > 0)
                {
                    int id;
                    int.TryParse(ID_medico.Text, out id);
                    Medico medico = new Medico();
                    medico.Crm      = CRM_medico.Text;
                    medico.Fonecel1 = Fone1_medico.Text;
                    medico.Fonecel2 = Fone2_medico.Text;
                    medico.Id       = id;
                    medico.Nome     = Nome_medico.Text;///verificar como passar o id 0 ou id do medico a alterar
                    medico.Id       = MySqlMedicoRepository.Gravar(medico);

                    for (int i = 0; i < listacon.Count; i++)
                    {
                        MedicoConvenio mc = new MedicoConvenio();
                        mc.Medico   = medico;
                        mc.Convenio = listacon.ElementAt(i);
                        MedicoConvenio m = MySqlMedicoConvenioRepository.GetByMedicoConvenio(mc);
                        if (m == null)
                        {
                            MySqlMedicoConvenioRepository.Gravar(mc);
                        }
                    }
                    MessageBox.Show("Gravado com sucesso");
                }
                else
                {
                    MessageBox.Show("Selecione um convenio");
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("Erro ao gravar médico: " + ex.ToString());
            }
        }
        //pega os campos e procura o medico no banco, retornando erro caso não encontre
        private void buttonPesquisar_Click(object sender, EventArgs e)
        {
            if (textBox1.Text != "")
            {
                Medico m = MedicoController.MedicoC.search(textBox1.Text);

                if (m != null)
                {
                    Program.closeMedicoSearch();
                    Program.openMedico(m, checkBox1.Checked);
                    ClearBoxes();
                }
                else
                {
                    MessageBox.Show("Registro não encontrado!", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
            }
            else
            {
                MessageBox.Show("Nenhum campo pode estar vazio!", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
Example #16
0
        public ValidationResult Cadastrar(MedicoAdicionar medicoAdicionar)
        {
            if (!medicoAdicionar.IsValid())
            {
                return(medicoAdicionar.Validation);
            }

            medicoAdicionar.Validation = new MedicoVerification(_unitOfWork).Validate(medicoAdicionar);

            if (medicoAdicionar.Validation.IsValid)
            {
                var usuario = new Usuario(medicoAdicionar.Email, medicoAdicionar.Senha);
                _unitOfWork.RepositoryUsuario.Adicionar(usuario);

                var medico = new Medico(medicoAdicionar.Nome, medicoAdicionar.Crm, usuario.Id);
                _unitOfWork.RepositoryMedico.Adicionar(medico);

                _unitOfWork.Commit();
            }

            return(medicoAdicionar.Validation);
        }
Example #17
0
        private void btnCRM_Click(object sender, RoutedEventArgs e)
        {
            MedicoController medicoController = new MedicoController();
            string           crm = txtCRM.Text;

            dgMedicosCRM.ItemsSource = medicoController.ListarPorCRM(crm);

            med = medicoController.BuscarPorCRM(crm);

            try
            {
                txtNome.Text          = med.nome;
                txtEspecialidade.Text = med.especialidade;
                txtEndereco.Text      = med.endereco;
            }
            catch (Exception ex)
            {
                MessageBox.Show("Usuário não existe");
            }

            btnSalvar.Visibility = Visibility.Collapsed;
        }
Example #18
0
        public void Deletar(int Id)
        {
            Usuario usuario = ctx.Usuarios.Find(Id);

            Prontuario prontuario = ctx.Prontuarios.FirstOrDefault(p => p.IdUsuario == Id);

            Medico medico = ctx.Medicos.FirstOrDefault(m => m.IdUsuario == Id);

            if (medico != null)
            {
                ctx.Medicos.Remove(medico);
            }

            if (prontuario != null)
            {
                ctx.Prontuarios.Remove(prontuario);
            }

            ctx.Usuarios.Remove(usuario);

            ctx.SaveChanges();
        }
Example #19
0
        public IActionResult Cadastro(int id)
        {
            MedicoViewModel viewMedico = new MedicoViewModel();

            viewMedico.ListaCidade = ListaCidade();

            if (id != 0)
            {
                Medico medico = myContexto.Medico.Where(c => c.Codigo == id).FirstOrDefault();
                viewMedico.Codigo        = medico.Codigo;
                viewMedico.Nome          = medico.Nome;
                viewMedico.Endereco      = medico.Endereco;
                viewMedico.Bairro        = medico.Bairro;
                viewMedico.Numero        = medico.Numero;
                viewMedico.CidadeCodigo  = medico.CidadeCodigo;
                viewMedico.Telefone      = medico.Telefone;
                viewMedico.Email         = medico.Email;
                viewMedico.Especialidade = medico.Especialidade;
            }

            return(View(viewMedico));
        }
Example #20
0
        public ActionResult DetailsMe(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            Medico medico = db.Medico.Find(id);

            if (medico.estado == 1)
            {
                medico.estado_String = "Activo";
            }
            if (medico.estado == 2)
            {
                medico.estado_String = "Inactivo";
            }
            if (medico == null)
            {
                return(HttpNotFound());
            }
            return(View(medico));
        }
        public async Task <IActionResult> Adicionar(CadastrarMedicoViewModel medicoViewModel)
        {
            if (!ModelState.IsValid)
            {
                return(CustomResponse(ModelState));
            }

            var especialidades = MontaEspecialidades(medicoViewModel.Especialidades);
            var medico         = new Medico(Guid.NewGuid(), medicoViewModel.Nome, medicoViewModel.Cpf, medicoViewModel.Crm, especialidades);

            var retornoId = await _medicoService.Cadastrar(medico);

            if (!OperacaoValida())
            {
                return(CustomResponse());
            }

            return(Ok(new
            {
                id = retornoId
            }));
        }
        private void Cargar_fecha(Medico medico, Especialidad especialidad)
        {
            this.HM = null;
            this.HM = new HorarioMedico();


            this.HM.dni     = medico.dni;
            this.HM.id_espe = especialidad.id;

            this.HM.horarios = HMN.LeerHorario(HM.dni, HM.id_espe);



            cbxFecha.DataSource = null;

            cbxFecha.DataSource = TN.ListaFechas(this.HM);

            if (cbxFecha.Items.Count > 0)
            {
                cbxFecha.SelectedIndex = 0;
            }
        }
Example #23
0
        public bool Alterar(Medico obj)
        {
            bool valida = false;

            foreach (var item in Select())
            {
                if (item.ID == obj.ID)
                {
                    using (var contexto = new ConecaoContext())
                    {
                        item.nome          = obj.nome;
                        item.CRM           = obj.CRM;
                        item.Situacao      = obj.Situacao;
                        item.AreaDeAtuacao = obj.AreaDeAtuacao;
                        contexto.Medico.Update(item);
                        contexto.SaveChanges();
                        valida = true;
                    }
                }
            }
            return(valida);
        }
Example #24
0
        public void AddMedico(Medico medico)
        {
            SqlConnection conexion = new SqlConnection();

            conexion.ConnectionString = ConfiguracionDataAccess.GetInstance().CadenaConexion;
            SqlCommand comando = new SqlCommand();

            comando.Connection  = conexion;
            comando.CommandText = ProcAdd.ADD_MEDICO;
            comando.CommandType = CommandType.StoredProcedure;
            comando.Parameters.AddWithValue("@nombre", medico.Nombre);
            comando.Parameters.AddWithValue("@primerApellido", medico.PrimerApellido);
            comando.Parameters.AddWithValue("@segundoApellido", medico.SegundoApellido);
            comando.Parameters.AddWithValue("@colegiatura", medico.Colegiatura);
            comando.Parameters.AddWithValue("@especialidad", medico.Especialidad);
            comando.Parameters.AddWithValue("@habil", medico.Habil);

            comando.Connection.Open();
            comando.ExecuteNonQuery();
            conexion.Close();
            comando.Dispose();
        }
Example #25
0
 public List <Consulta> Minhas(int idUsuario, int role)
 {
     if (role == 2)
     {
         Paciente PacienteBuscado = ctx.Pacientes.FirstOrDefault(c => c.IdUsuario == idUsuario);
         //Buscar as consultas do paciente atraves do id do paciente
         return(ctx.Consultas
                .Where(c => c.IdPaciente == PacienteBuscado.IdPaciente)
                .Include(p => p.IdMedicoNavigation)
                .ToList());
     }
     if (role == 3)
     {
         Medico MedicoBuscado = ctx.Medicos.FirstOrDefault(c => c.IdUsuario == idUsuario);
         //Buscar as consultas do medico atraves do id do medico
         return(ctx.Consultas
                .Where(c => c.IdMedico == MedicoBuscado.IdMedico)
                .Include(p => p.IdPacienteNavigation)
                .ToList());
     }
     return(null);
 }
Example #26
0
        public List <Medico> ListaMedico()
        {
            MySqlConnection msc = new MySqlConnection("server=localhost; uid=root; pwd=123456789; database=bd_clinicare");

            msc.Open();

            MySqlDataAdapter msda = new MySqlDataAdapter("LISTAR_MEDICO", msc);

            msda.SelectCommand.CommandType = CommandType.StoredProcedure;

            DataSet ds = new DataSet();

            msda.Fill(ds);

            msc.Close();

            List <Medico> lista = new List <Medico>();

            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                Medico item = new Medico();

                item.COD_MED      = int.Parse(dr["COD_MED"].ToString());
                item.NOME_MED     = dr["NOME_MED"].ToString();
                item.TEL_MED      = int.Parse(dr["TEL_MED"].ToString());
                item.CEL_MED      = int.Parse(dr["CEL_MED"].ToString());
                item.EMAIL_MED    = dr["EMAIL_MED"].ToString();
                item.CPF_MED      = dr["CPF_MED"].ToString();
                item.CRM          = dr["CRM"].ToString();
                item.VALIDADE_CRM = DateTime.Parse(dr["VALIDADE_CRM"].ToString());
                item.SEXO_MED     = dr["SEXO_MED"].ToString();
                item.COD_ESPEC    = int.Parse(dr["COD_ESPEC"].ToString());
                item.COD_CARGO    = int.Parse(dr["COD_CARGO"].ToString());

                lista.Add(item);
            }

            return(lista);
        }
        public async Task <ActionResult> DeleteConfirmed(int id)
        {
            try
            {
                Medico medico = await db.Medicos.FindAsync(id);

                //Paciente paciente = await db.Pacientes.FirstOrDefaultAsync(t => t.ObraSocialId == obraSocial.Id);
                //if (paciente != null)
                //{
                //    TempData[Application.MessageViewBagName] = new GenericMessageViewModel
                //    {
                //        Message = "No se puede eliminar el registro relacionado.",
                //        MessageType = GenericMessages.danger
                //    };
                //    return RedirectToAction("Index");
                //}

                TempData[Application.MessageViewBagName] = new GenericMessageViewModel
                {
                    Message     = "Registro eliminado exitosamente.",
                    MessageType = GenericMessages.success
                };

                db.Medicos.Remove(medico);
                await db.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }
            catch (Exception ex)
            {
                var err = $"No se puede eliminar el registro: {ex.Message}";
                TempData[Application.MessageViewBagName] = new GenericMessageViewModel
                {
                    Message     = err,
                    MessageType = GenericMessages.danger
                };
                return(RedirectToAction("Index"));
            }
        }
Example #28
0
        public void cadastrarMedico()
        {
            try {
                if (validarFormMedico())
                {
                    var medico = new Medico()
                    {
                        Nome           = contextoCadastro.txtNomeMed.Text,
                        Sobrenome      = contextoCadastro.txtSobrenomeMed.Text,
                        DataNascimento = contextoCadastro.dtpDataNascPaciente.Text,
                        Sexo           = (contextoCadastro.rdbSexoFMed.Checked ? "F" : "M"),
                        Cpf            = contextoCadastro.txtCpfMed.Text,
                        Rg             = contextoCadastro.txtRgMed.Text,
                        OrgaoEmissor   = contextoCadastro.txtOrgaoEmiMed.Text,
                        Endereco       = contextoCadastro.txtEnderecoMed.Text,
                        Numero         = contextoCadastro.txtNumeroEndMed.Text,
                        Complemento    = contextoCadastro.txtComplementoMed.Text,
                        Cep            = contextoCadastro.txtCepMed.Text,
                        Bairro         = contextoCadastro.txtBairroMed.Text,
                        Estado         = contextoCadastro.cbxUFMed.Text,
                        Cidade         = contextoCadastro.cbxCidadeMed.Text,
                        Telefone       = contextoCadastro.txtTelefoneMed.Text,
                        Celular        = contextoCadastro.txtCelularMed.Text,
                        Email          = contextoCadastro.txtEmailMed.Text,
                        Especialidade  = contextoCadastro.cbxEspecialidadeMed.Text,
                        Crm            = contextoCadastro.txtCrm.Text
                    };

                    var dao = new MedicoDAO();

                    dao.Save(medico);

                    MessageBox.Show("Médico Cadastrado com Sucesso");
                }
            } catch (Exception e) {
                var erro = new ExceptionsHelper(e, "Erro ao cadastrar o Médico no banco de dados");
                erro.lancaException();
            }
        }
Example #29
0
        public IActionResult Put(int id, MedicoViewModel medicoAtualizado)
        {
            try
            {
                Medico medicoBuscado = _medicoRepository.BuscarPorId(id);

                if (medicoBuscado != null)
                {
                    if (medicoBuscado.Crm == medicoAtualizado.Crm)
                    {
                        return(BadRequest("O médico que está sendo atualizado já possui este CRM!"));
                    }

                    if (_medicoRepository.BuscarPorCrm(medicoAtualizado.Crm) != null)
                    {
                        return(BadRequest("Já existe um médico cadastrado com este CRM!"));
                    }

                    Medico medico = new Medico
                    {
                        IdEspecialidade = medicoAtualizado.IdEspecialidade,
                        IdUsuario       = medicoAtualizado.IdUsuario,
                        IdClinica       = medicoAtualizado.IdClinica,
                        Nome            = medicoAtualizado.Nome,
                        Crm             = medicoAtualizado.Crm
                    };

                    _medicoRepository.Atualizar(id, medico);

                    return(StatusCode(204));
                }

                return(NotFound("Médico não encontrado"));
            }
            catch (Exception exception)
            {
                return(BadRequest(exception));
            }
        }
Example #30
0
 public static ICollection <Medico> Get(string url, int id = 0)
 {
     using (var httpClient = new HttpClient())
     {
         string baseUrl = "http://localhost:51186/";
         httpClient.BaseAddress = new Uri(baseUrl);
         if (id == 0)
         {
             HttpResponseMessage response = httpClient.GetAsync(url).Result;
             Medico[]            data     = JsonConvert.DeserializeObject <Medico[]>(response.Content.ReadAsStringAsync().Result);
             return(data);
         }
         else
         {
             HttpResponseMessage response = httpClient.GetAsync(url + "/" + id).Result;
             Medico   obj  = JsonConvert.DeserializeObject <Medico>(response.Content.ReadAsStringAsync().Result);
             Medico[] data = new Medico[1];
             data[0] = obj;
             return(data);
         }
     }
 }
Example #31
0
        public ActionResult AddEdit(Medico medico)
        {
            if (ModelState.IsValid)
            {
                if (medico.Id == 0)
                {
                    _context.Medicos.Add(medico);
                }
                else
                {
                    _context.Entry(medico).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
                }
                _context.SaveChanges();

                return(RedirectToAction("Index"));
            }

            var especialidades = _context.Medicos.Include("Especialidade").ToList();

            ViewBag.Especialidades = especialidades;
            return(View(medico));
        }
Example #32
0
 //Procura e preenche o medico
 private void button3_Click(object sender, EventArgs e)
 {
     if (textBox2.Text != "")
     {
         Medico m = MedicoController.MedicoC.search(textBox2.Text);
         if (m != null)
         {
             textBox2.Text     = m.CRM + " - " + m.Nome;
             medico            = m;
             textBox2.ReadOnly = true;
             button3.Enabled   = false;
         }
         else
         {
             MessageBox.Show("Médico não encontrado!", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
         }
     }
     else
     {
         MessageBox.Show("Nenhum campo pode estar vazio!", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
     }
 }
Example #33
0
        public IActionResult Post(Medico medico)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            _medicoRepository.BeginTransaction();

            // cadastrando
            medico = _medicoService.Post(medico);

            if (_notification.Any)
            {
                _medicoRepository.RollbackTransaction();
                return(BadRequest());
            }

            _medicoRepository.CommitTransaction();

            return(Created(medico));
        }
        public void popolaLista()
        {
            //svuoto subito la lista
            this.svuotaLista();

            string          query  = " SELECT * FROM Medici";
            List <string[]> reader = SQLiteManager.eseguiSelect(query);

            if (reader.Count > 0)
            {
                foreach (string[] record in reader)
                {
                    bool     Sesso;
                    String   Nome          = record[1].ToString();
                    String   Cognome       = record[2].ToString();
                    String   date          = record[3].ToString();
                    DateTime DataDiNascita = Convert.ToDateTime(date);
                    String   Email         = record[4].ToString();
                    String   Telefono      = record[5].ToString();
                    String   sex           = record[6].ToString();
                    if (sex.Length == 0)
                    {
                        Sesso = true;
                    }
                    else
                    {
                        Sesso = false;
                    }

                    String earn             = record[7].ToString();
                    int    Stipendio        = Convert.ToInt32(earn);
                    String Specializzazione = record[8].ToString();
                    Medico medico           = new Medico(Nome, Cognome, DataDiNascita, Email, Telefono, Sesso, Stipendio, Specializzazione);
                    String identity         = record[0];
                    medico.Id = Convert.ToInt32(identity);
                    this.listaMedici.Add(medico);
                }
            }
        }
Example #35
0
        public Medico DetalhesMedico(int COD_MED)
        {
            MySqlConnection msc = new MySqlConnection("server=localhost; uid=root; pwd=123456789; database=bd_clinicare");

            msc.Open();

            MySqlDataAdapter msda = new MySqlDataAdapter("select * from tb_medico where COD_MED = " + COD_MED, msc);
            //    MySqlDataAdapter msda = new MySqlDataAdapter("CONSULTAR_MEDICO" + COD_MED, msc);
            //    msda.SelectCommand.CommandType = CommandType.StoredProcedure;


            DataSet ds = new DataSet();

            msda.Fill(ds);

            msc.Close();

            List <Medico> lista = new List <Medico>();

            Medico item = new Medico();

            if (ds.Tables[0].Rows.Count > 0)
            {
                item.COD_MED      = int.Parse(ds.Tables[0].Rows[0]["COD_MED"].ToString());
                item.NOME_MED     = ds.Tables[0].Rows[0]["NOME_MED"].ToString();
                item.TEL_MED      = int.Parse(ds.Tables[0].Rows[0]["TEL_MED"].ToString());
                item.CEL_MED      = int.Parse(ds.Tables[0].Rows[0]["CEL_MED"].ToString());
                item.EMAIL_MED    = ds.Tables[0].Rows[0]["EMAIL_MED"].ToString();
                item.CPF_MED      = int.Parse(ds.Tables[0].Rows[0]["CPF_MED"].ToString());
                item.CRM          = ds.Tables[0].Rows[0]["CRM"].ToString();
                item.VALIDADE_CRM = DateTime.Parse(ds.Tables[0].Rows[0]["VALIDADE_CRM"].ToString());
                item.COD_ESPEC    = int.Parse(ds.Tables[0].Rows[0]["COD_ESPEC"].ToString());
                item.COD_CARGO    = int.Parse(ds.Tables[0].Rows[0]["COD_CARGO"].ToString());
                item.LOGIN_MED    = ds.Tables[0].Rows[0]["LOGIN_MED"].ToString();
                item.SENHA_MED    = ds.Tables[0].Rows[0]["SENHA_MED"].ToString();
            }

            return(item);
        }
        public bool Cargar()
        {
            try
            {
                StreamReader r = new StreamReader(@"C:\Desarrollador\CSV2\Medico.json");

                string        json    = r.ReadToEnd();
                List <Medico> medicos = JsonConvert.DeserializeObject <List <Medico> >(json);



                foreach (var medico in medicos)
                {
                    Medico m1 = new Medico();
                    m1.Address           = medico.Address;
                    m1.Age               = medico.Age;
                    m1.City              = medico.City;
                    m1.Country           = medico.Country;
                    m1.Distrito          = medico.Distrito;
                    m1.dni               = medico.dni;
                    m1.Email             = medico.Email;
                    m1.Gender            = medico.Gender;
                    m1.Imagen            = medico.Imagen;
                    m1.LastName_Maternal = medico.LastName_Maternal;
                    m1.LastName_Paternal = medico.LastName_Paternal;
                    m1.Name              = medico.Name;
                    m1.Phone             = m1.Phone;


                    context.Add(m1);
                    context.SaveChanges();
                }
            }
            catch (System.Exception)
            {
                return(false);
            }
            return(true);
        }
        public void DeletarUsuarioMedicoSemAgendamentoTest()
        {
            // given
            var endereco1 = new Endereco(new Guid("1EF2F5CB-A04B-4761-3C44-08D78CC135ED"), "29500-000", "Rua nova", "123", "Casa", "Centro", "Alegre", "ES");

            var medico = new Medico(new Guid("16E16A8D-469F-4286-A470-08D78CC0F920"), "Marcos", "123.456.789-12", "12.345.678-1", 1234567, new DateTime(1980, 2, 5), "M", "(34)98543-3241", "*****@*****.**", endereco1.IdEndereco);

            var usuarioMedico = new Usuario(new Guid("1A7C25A0-896F-49DF-A75E-EE7DD53AECB9"), "*****@*****.**", "25d55ad283aa400af464c76d713c07ad", "Médico", medico, null);

            this.usuarioRepositoryMock.Setup(u => u.ObterUsuarioPorId(usuarioMedico.IdUsuario)).Returns(usuarioMedico);
            this.usuarioRepositoryMock.Setup(u => u.DeletarUsuario(usuarioMedico)).Returns(true);
            this.agendamentoRepositoryMock.Setup(a => a.QuantidadeAgendamentosMedico(medico.IdMedico)).Returns(0);
            this.medicoRepositoryMock.Setup(m => m.DeletarMedico(medico)).Returns(true);

            var usuarioService = new UsuarioService(usuarioRepositoryMock.Object, atendenteRepositoryMock.Object, medicoRepositoryMock.Object, agendamentoRepositoryMock.Object);

            // when
            var mensagem = usuarioService.DeletarUsuario(usuarioMedico.IdUsuario.ToString());

            // then
            Assert.True(mensagem.Id == 1);
        }
Example #38
0
        public void guardarMedicoNuevo()
        {
            Medico medico = new Medico();

            medico.Nombre    = TbxNombre.Text;
            medico.Apellido  = TbxApellido.Text;
            medico.Documento = int.Parse(TbxDocumento.Text);
            medico.Matricula = TbxMatricula.Text;
            medico.EMail     = TbxEmail.Text;
            Direccion direccion = new Direccion();

            direccion.Calle     = TbxCalle.Text;
            direccion.Numero    = TbxAltura.Text;
            direccion.Piso      = TbxPiso.Text;
            direccion.Localidad = TbxLocalidad.Text;
            medico.Domicilio    = direccion;
            medico.Celular      = TbxCelular.Text;
            medico.Legajo       = int.Parse(TbxLegajo.Text);
            medico.Matricula    = TbxMatricula.Text;
            medico.Consulta     = double.Parse(TbxConsulta.Text);
            MedicoNego.guardarMedico(medico);
        }
Example #39
0
        private void btnSalvar_Click(object sender, EventArgs e)
        {
            try
            {
                Medico medico = new Medico();
                {
                    medico.Md_nome     = textNome.Text.Trim();
                    medico.Md_crm      = textCrm.Text.Trim();
                    medico.Md_telefone = maskedTextBox1.Text;
                    medico.Md_email    = textEmail.Text.Trim();
                }

                Fachada fachadaMedico = new Fachada();
                fachadaMedico.CadastraMedico(medico);
                MessageBox.Show("Médico cadastrado com sucesso");
                LimparCampos();
            }
            catch (Exception ex)
            {
                MessageBox.Show("Erro ao cadastrar " + ex.Message);
            }
        }
 public Laudo(Medico medicoAnalise, string resultado)
 {
     MedicoAnalise = medicoAnalise;
     Resultado = resultado;
 }
 public Medico Save(Medico medico)
 {
     var newMedico = context.Medicos.Add(medico);
     context.SaveChanges();
     return newMedico;
 }
        public void CreateAInvalidMedicoNameTest()
        {
            Medico medico = new Medico();

            Validator.Validate(medico);
        }