public MedicoViewModel PesquisarMedicoPorCRMEEstado(MedicoViewModel medicoViewModel, ISession session,IMedicos medicos)
        {
                                        
                Medico medico = medicos.PesquisarMedicoPorCRMEEstado(medicoViewModel.CRM, medicoViewModel.Estado);

                return new MedicoViewModel {CRM = medico.CRM, Estado = medico.Estado, Nome = medico.Nome};    

        }
        // GET: Medico/Details/5
        public ActionResult Pesquisar(MedicoViewModel medicoViewModel)
        {
         
                ServicoDePersistenciaDeMedico servicoDePersistenciaDeMedico = new ServicoDePersistenciaDeMedico();
                var medico = servicoDePersistenciaDeMedico.PesquisarMedicoPorCRMEEstado(medicoViewModel, session, _medicos);

                return View(medico);
           
        }
Beispiel #3
0
        public IActionResult Novo(MedicoViewModel medicoViewModel)
        {
            if (!ModelState.IsValid)
            {
                return(View(medicoViewModel));
            }

            var medico = _mapper.Map <Medico>(medicoViewModel);

            _contexto.Medicos.Add(medico);
            _contexto.SaveChanges();

            return(RedirectToAction(nameof(Detalhes), medico.MedicoId));
        }
        public ActionResult Alterar(int id)
        {
            //var medico = db.Medicos.Where(x => x.Id == id).FirstOrDefault();

            var medico = _repositorio.Obter(x => x.Id == id);

            var model = new MedicoViewModel();

            model.Id            = medico.Id;
            model.Nome          = medico.Nome.ToUpper();
            model.Crm           = medico.Crm;
            model.Email         = medico.Email;
            model.Especialidade = medico.Especialidade;
            return(View(model));
        }
Beispiel #5
0
        public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            if (ModelState.IsValid)
            {
                EmpresaSecurity <App_DominioContext> security = new EmpresaSecurity <App_DominioContext>();
                try
                {
                    MedicoModel     associadoModel     = new MedicoModel();
                    MedicoViewModel associadoViewModel = associadoModel.getAssociadoByLogin(model.UserName, security);

                    if (associadoViewModel != null && associadoViewModel.associadoId < 0)
                    {
                        throw new DbEntityValidationException();
                    }

                    #region Autorizar
                    Validate result = security.Autorizar(model.UserName, model.Password, _sistema_id(), associadoViewModel != null ? associadoViewModel.associadoId.ToString() : "0", associadoViewModel != null && associadoViewModel.avatar != null ? associadoViewModel.avatar : null);
                    if (result.Code > 0)
                    {
                        throw new ArgumentException(result.Message);
                    }
                    #endregion

                    string sessaoId = result.Field;

                    return(RedirectToAction("index", "Home"));
                }
                catch (ArgumentException ex)
                {
                    Error(ex.Message);
                }
                catch (App_DominioException ex)
                {
                    Error("Erro na autorização de acesso. Favor entre em contato com o administrador do sistema");
                }
                catch (DbEntityValidationException ex)
                {
                    Error("Não foi possível autorizar o seu acesso. Favor entre em contato com o administrador do sistema");
                }
                catch (Exception ex)
                {
                    Error("Erro na autorização de acesso. Favor entre em contato com o administrador do sistema");
                }
            }

            // If we got this far, something failed, redisplay form
            return(View(model));
        }
Beispiel #6
0
        public ActionResult Edit(int id)
        {
            ViewBag.Autenticado = User.Identity.IsAuthenticated;
            var medico = _context.Medicos.Single(x => x.ID == id);

            var vm = new MedicoViewModel
            {
                Id            = id,
                Medicos       = _context.Medicos.Where(x => x.Deletado == false).ToList(),
                Nome          = medico.Nome,
                Especialidade = medico.Especialidade,
                Heading       = "Editar Médico",
                Botao         = "Editar"
            };

            return(View("Create", vm));
        }
        public IActionResult Cadastrar(MedicoViewModel medico)
        {
            try
            {
                UsuarioRepository          usuarioRepository        = new UsuarioRepository();
                EnderecosMedicosRepository enderecoMedicoRepository = new EnderecosMedicosRepository();
                MedicosRepository          medicoRepository         = new MedicosRepository();

                Usuarios usuario = new Usuarios();
                //atribuindo as informações do view model ao usuário
                usuario.IdTipoUsuarios = medico.IdTipoUsuarios;
                usuario.Email          = medico.Email;
                usuario.Senha          = medico.Senha;
                //cadastrando o usuário
                usuarioRepository.Cadastrar(usuario);

                EnderecosMedicos endereco = new EnderecosMedicos();
                //atribuindo as informações do view model ao endereço
                endereco.Estado     = medico.Estado;
                endereco.Cidade     = medico.Cidade;
                endereco.Bairro     = medico.Bairro;
                endereco.Logradouro = medico.Logradouro;
                endereco.Endereco   = medico.Endereco;
                endereco.Cep        = medico.Cep;
                //cadastrando endereço
                enderecoMedicoRepository.Cadastrar(endereco);

                Medicos medicocad = new Medicos();
                medicocad.Crm           = medico.Crm;
                medicocad.Nome          = medico.Nome;
                medicocad.Telefone      = medico.Telefone;
                medicocad.IdAreaClinica = medico.IdAreaClinica;
                medicocad.IdEndereco    = endereco.Id;
                medicocad.IdUsuario     = usuario.Id;

                //cadastrando prontuario/paciente
                medicoRepository.Cadastrar(medicocad);

                return(Ok("Médico cadastrado com sucesso!"));
            }
            catch
            {
                return(BadRequest("Algo deu errado :/"));
            }
        }
        public ActionResult Editar(MedicoViewModel medicoViewModel)
        {
            if (ModelState.IsValid)
            {
                MedicoBL.AtualizaMedico(medicoViewModel);
                return(RedirectToAction("Index"));
            }

            //Cidades
            var allCidades = MedicoBL.BuscaCidades();
            //Especialidades
            var allEspecialidades = MedicoBL.BuscaEspecialidades();

            ViewBag.IDCidade        = new SelectList(allCidades, "IDCidade", "Nome", medicoViewModel.IDCidade);
            ViewBag.IDEspecialidade = new SelectList(allEspecialidades, "IDEspecialidade", "Nome", medicoViewModel.IDEspecialidade);

            return(View(medicoViewModel));
        }
Beispiel #9
0
        public static void AtualizaMedico(MedicoViewModel medicoViewModel)
        {
            var config = new MapperConfiguration(cfg =>
            {
                cfg.CreateMap <MedicoViewModel, Medico>();
            });
            var mapper = config.CreateMapper();
            var medico = mapper.Map <MedicoViewModel, Medico>(medicoViewModel);

            medico.Especialidade = new Especialidade {
                IDEspecialidade = medicoViewModel.IDEspecialidade
            };
            medico.Cidade = new Cidade {
                IDCidade = medicoViewModel.IDCidade
            };

            MedicoDTO.AtualizaMedico(medico);
        }
Beispiel #10
0
        public IActionResult CadastrarMedico(MedicoStandaloneViewModel medicoModel)
        {
            try
            {
                MedicoViewModel medico = MedicoRepository.RetornarMedicoViewModel(medicoModel);

                UsuarioRepository.CadastrarMedico(medico);

                return(Ok());
            }
            catch (Exception ex)
            {
                return(BadRequest(new
                {
                    mensagem = "Erro: " + ex
                }));
            }
        }
        public async Task <IActionResult> Create(MedicoViewModel medicoViewModel)
        {
            if (!ModelState.IsValid)
            {
                return(View(medicoViewModel));
            }

            var medico = _mapper.Map <Medico>(medicoViewModel);
            await _medicoService.Adicionar(medico);

            if (!OperacaoValida())
            {
                return(View(medicoViewModel));
            }

            TempData["Sucesso"] = "Médico cadastrado com sucesso!";

            return(RedirectToAction("Index"));
        }
Beispiel #12
0
        public void CadastrarMedico(MedicoViewModel medicoModel)
        {
            using (SPMedGroupContext ctx = new SPMedGroupContext())
            {
                CadastrarUsuario(medicoModel.UsuarioViewModel);

                // Pega o último registro cadastrado no banco de dados, por isso foi necessário salvar as alterações antes.
                Usuarios usuario = ctx.Usuarios.Last();

                // Atribui o usuario Id à proprieadade usuarioId do Medico.
                medicoModel.Medico.IdUsuario = usuario.Id;

                // Cadastra o médico.
                ctx.Medicos.Add(medicoModel.Medico);

                // Salva as alterações no banco;
                ctx.SaveChanges();
            }
        }
        public static void InserirMedico(MedicoViewModel medicoViewModel)
        {
            var config = new MapperConfiguration(cfg =>
            {
                cfg.CreateMap <MedicoViewModel, Medico>();
            });
            var mapper = config.CreateMapper();
            var medico = mapper.Map <MedicoViewModel, Medico>(medicoViewModel);

            medico.Especialidade = new Especialidade {
                IDEspecialidade = medicoViewModel.IDEspecialidade
            };
            medico.Cidade = new Cidade {
                IDCidade = medicoViewModel.IDCidade
            };

            MedicoAPI.Post(medico, "api/medico");
            // MedicoDTO.InserirMedico(medico);
        }
Beispiel #14
0
        public ActionResult Create(MedicoViewModel vm)
        {
            if (!ModelState.IsValid)
            {
                vm.Medicos = _context.Medicos.Where(x => x.Deletado == false).ToList();
                vm.Heading = "Adicionar Médico";
                vm.Botao   = "Adicionar";
                return(View(vm));
            }

            var medico = new Medico
            {
                Nome          = vm.Nome,
                Especialidade = vm.Especialidade
            };

            _context.Medicos.Add(medico);
            _context.SaveChanges();
            return(RedirectToAction("Create", "Medico"));
        }
        public List <MedicoViewModel> Listar()
        {
            using (ClevelandContext ctx = new ClevelandContext())
            {
                var y          = ctx.Medicos.Include(x => x.EspecialidadeNavigation).ToList();
                var listafinal = new List <MedicoViewModel>();
                foreach (var item in y)
                {
                    var z = new MedicoViewModel();

                    z.Crm            = item.Crm;
                    z.Nome           = item.Nome;
                    z.DataNascimento = item.DataNascimento;
                    z.Ativo          = Convert.ToBoolean(item.Ativo);
                    z.Especialidade  = item.EspecialidadeNavigation.Nome;
                    listafinal.Add(z);
                }
                return(listafinal);
            }
        }
        public async Task <Medico> ToMedicoAsync(MedicoViewModel model, string path, bool isNuevo)
        {
            var medico = new Medico
            {
                Agendas      = model.Agendas,
                Registro     = model.Registro,
                Aniversario  = model.Aniversario,
                Historicos   = model.Historicos,
                Direccion    = model.Direccion,
                Lugar        = model.Lugar,
                Id           = isNuevo ? 0 : model.Id,
                ImageUrl     = path.Trim(),
                Name         = model.Name.Trim(),
                Visitador    = await _dataContext.Visitadores.FindAsync(model.VisitadorId),
                Especialidad = await _dataContext.Especialidades.FindAsync(model.EspecialidadId),
                Remarks      = model.Remarks
            };

            return(medico);
        }
        public async Task <IActionResult> EditMedico(MedicoViewModel model)
        {
            if (ModelState.IsValid)
            {
                var path = model.ImageUrl;

                if (model.ImageFile != null)
                {
                    path = await _imageHelper.UploadImageAsync(model.ImageFile);
                }

                var medico = await _converterHelper.ToMedicoAsync(model, path, false);

                _datacontext.Medicos.Update(medico);
                await _datacontext.SaveChangesAsync();

                return(RedirectToAction($"Details/{model.VisitadorId}"));
            }
            model.Especialidades = _combosHelper.GetComboEspecialidades();
            return(View(model));
        }
Beispiel #18
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));
            }
        }
Beispiel #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));
        }
        public async Task <IActionResult> Edit(Guid id, MedicoViewModel medicoViewModel)
        {
            if (id != medicoViewModel.Id)
            {
                return(NotFound());
            }

            if (!ModelState.IsValid)
            {
                return(View(medicoViewModel));
            }

            var medico = _mapper.Map <Medico>(medicoViewModel);
            await _medicoService.Atualizar(medico);

            if (!OperacaoValida())
            {
                return(View(medicoViewModel));
            }

            return(RedirectToAction("Index"));
        }
        public async Task <IActionResult> AddMedico(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }
            var visitador = await _datacontext.Visitadores.FindAsync(id.Value);

            if (visitador == null)
            {
                return(NotFound());
            }

            var model = new MedicoViewModel
            {
                Aniversario    = DateTime.Today,
                VisitadorId    = visitador.Id,
                Especialidades = _combosHelper.GetComboEspecialidades()
            };

            return(View(model));
        }
Beispiel #22
0
        public async Task <IActionResult> Create(MedicoViewModel medicoViewModel)
        {
            if (!ModelState.IsValid)
            {
                return(View(medicoViewModel));
            }

            medicoViewModel.CPF      = medicoViewModel.CPF.ApenasNumeros();
            medicoViewModel.Telefone = medicoViewModel.Telefone.ApenasNumeros();
            var medico = _mapper.Map <Medico>(medicoViewModel);

            if ((await _medicoRepository.Buscar(m => Equals(m.CPF, medicoViewModel.CPF))).Any())
            {
                ModelState.AddModelError(string.Empty, "CPF já cadastrado!");
            }

            if ((await _medicoRepository.ObtenhaMedicoPorCRM(medico.CRM) != null))
            {
                ModelState.AddModelError(string.Empty, "CRM já cadastrado!");
            }

            if (ModelState.ErrorCount > 0)
            {
                return(View(medicoViewModel));
            }

            var usuarioIdentity = await _usuarioService.CadastrarMedico(medicoViewModel.Email, medicoViewModel.Email, medicoViewModel.Senha);

            if (usuarioIdentity == null)
            {
                ModelState.AddModelError(string.Empty, "Email já em utilização!");
                return(View(medicoViewModel));
            }

            medico.UsuarioId = Guid.Parse(usuarioIdentity.Id);
            await _medicoRepository.Adicionar(medico);

            return(RedirectToAction("Index"));
        }
Beispiel #23
0
        public async Task <IActionResult> Edit(Guid id, MedicoViewModel medicoViewModel)
        {
            if (id != medicoViewModel.Id)
            {
                return(NotFound());
            }

            if (!ModelState.IsValid)
            {
                return(View(medicoViewModel));
            }

            medicoViewModel.CPF      = medicoViewModel.CPF.ApenasNumeros();
            medicoViewModel.Telefone = medicoViewModel.Telefone.ApenasNumeros();

            if ((await _consultaRepository.ObtenhaConsultasMedico(id)).Any(c => c.Data > DateTime.Now))
            {
                ModelState.AddModelError(string.Empty, "Não é possível editar pois existem consultas futuras na jornada de trabalho alterada.");
                return(View(medicoViewModel));
            }

            if (!await _usuarioService.AtualizeEmail(medicoViewModel.UsuarioId, medicoViewModel.Email))
            {
                ModelState.AddModelError(string.Empty, "Não foi possível atualizar o email.");
                return(View(medicoViewModel));
            }

            if (!await _usuarioService.AtualizeSenha(medicoViewModel.UsuarioId, medicoViewModel.SenhaAntiga, medicoViewModel.Senha))
            {
                ModelState.AddModelError(string.Empty, "Não foi possível atualizar a senha.");
                return(View(medicoViewModel));
            }

            var medico = _mapper.Map <Medico>(medicoViewModel);
            await _medicoRepository.Atualizar(medico);

            return(RedirectToAction("Index"));
        }
        public ActionResult Alterar(MedicoViewModel medicoVm)
        {
            try
            {
                //db.Entry(medico).State = EntityState.Modified;
                //db.SaveChanges();
                var model = new Medico();
                model.Id            = medicoVm.Id;
                model.Nome          = medicoVm.Nome.ToUpper();
                model.Crm           = medicoVm.Crm;
                model.Email         = medicoVm.Email;
                model.Especialidade = medicoVm.Especialidade;
                _repositorio.Atualizar(model);
                _contexto.Commit();

                return(RedirectToAction("Index"));
            }
            catch (Exception e)
            {
                _contexto.Rollback();
                throw new Exception(e.Message);
            }
        }
        public MedicoViewModel RetornarMedicoViewModel(MedicoStandaloneViewModel medicoModel)
        {
            MedicoViewModel medico = new MedicoViewModel()
            {
                UsuarioViewModel = new CadastrarUsuarioViewModel()
                {
                    Nome          = medicoModel.Nome,
                    Email         = medicoModel.Email,
                    Senha         = medicoModel.Senha,
                    Telefone      = medicoModel.Telefone,
                    FotoPerfil    = medicoModel.FotoPerfil,
                    IdTipoUsuario = medicoModel.IdTipoUsuario,
                    IdClinica     = medicoModel.IdClinica
                },

                Medico = new Medicos()
                {
                    IdEspecialidade = medicoModel.IdEspecialidade,
                    Crm             = medicoModel.Crm
                }
            };

            return(medico);
        }
Beispiel #26
0
 public IActionResult Atualizar(int id, MedicoViewModel json)
 {
     _medicoRepository.Atualizar(id, json);
     return(Ok("Atualizado"));
 }
Beispiel #27
0
        public override Medico ExecProcess(RegisterViewModel value, Crud operation)
        {
            EmpresaSecurity <SecurityContext> empresaSecurity = new EmpresaSecurity <SecurityContext>();

            int _empresaId         = int.Parse(System.Configuration.ConfigurationManager.AppSettings["empresaId"]);
            int _sistemaId         = int.Parse(System.Configuration.ConfigurationManager.AppSettings["sistemaId"]);
            int _areaAtendimentoId = int.Parse(System.Configuration.ConfigurationManager.AppSettings["secretariaId"]);

            #region Incluir o usuário
            UsuarioRepository usuarioRepository = new UsuarioRepository()
            {
                login            = value.login.ToLower(),
                nome             = value.nome.ToUpper(),
                empresaId        = _empresaId,
                dt_cadastro      = DateTime.Now,
                situacao         = "D",
                isAdmin          = "N",
                senha            = value.senha,
                uri              = value.uri,
                confirmacaoSenha = value.confirmacaoSenha
            };

            usuarioRepository = empresaSecurity.SetUsuario(usuarioRepository);
            if (usuarioRepository.mensagem.Code > 0)
            {
                throw new ArgumentException(usuarioRepository.mensagem.Message);
            }
            #endregion

            #region Vincular médico ao usuário
            value.cpf   = value.cpf.Replace(".", "").Replace("-", "");
            value.ufCRM = value.ufCRM.ToUpper();
            value.login = value.login.ToLower();
            MedicoViewModel medicoViewModel = (from med in db.Medicos
                                               where (med.CRM == value.CRM && med.ufCRM == value.ufCRM) ||
                                               med.cpf == value.cpf ||
                                               med.email1 == value.login
                                               select new MedicoViewModel()
            {
                associadoId = med.associadoId,
                CRM = med.CRM,
                ufCRM = med.ufCRM,
                cpf = med.cpf,
                nome = med.nome
            }).FirstOrDefault();

            value.associadoId = medicoViewModel.associadoId;

            Medico medico = Find(value);

            medico.CRM       = value.CRM;
            medico.ufCRM     = value.ufCRM;
            medico.cpf       = value.cpf;
            medico.usuarioId = usuarioRepository.usuarioId;
            medico.email1    = value.login;

            db.Entry(medico).State = EntityState.Modified;
            #endregion

            #region Insere o chamado para a secretaria
            chamadoViewModel = new ChamadoViewModel()
            {
                associadoId       = value.associadoId.Value,
                areaAtendimentoId = _areaAtendimentoId,
                dt_chamado        = DateTime.Now,
                assunto           = "Solicitação de ativação do usuário " + (usuarioRepository.nome.Length >= 15 ? usuarioRepository.nome.Substring(0, 15) : usuarioRepository.nome.Substring(0, usuarioRepository.nome.Length)),
                situacao          = "A"
            };
            chamadoViewModel.mensagemOriginal  = "<h4>Liberação de acesso ao sistema para um novo usuário</h4>";
            chamadoViewModel.mensagemOriginal += "<hr>";
            chamadoViewModel.mensagemOriginal += "<p><b>Nome do Usuário: </b>" + value.nome + "</p>";
            chamadoViewModel.mensagemOriginal += "<p><b>Nome Associado: </b>" + medicoViewModel.nome + "</p>";
            chamadoViewModel.mensagemOriginal += "<p><b>Login: </b>" + value.login + "</p>";
            chamadoViewModel.mensagemOriginal += "<p><b>CRM: </b>" + value.CRM + "</p>";
            chamadoViewModel.mensagemOriginal += "<p><b>UF CRM: </b>" + value.ufCRM + "</p>";
            chamadoViewModel.mensagemOriginal += "<p><b>CPF: </b>" + value.cpf + "</p>";
            chamadoViewModel.mensagemOriginal += "<hr>";
            chamadoViewModel.mensagemOriginal += "<p><a href=\"../Associado/Edit?associadoId=" + value.associadoId.ToString() + "\">Clique aqui</a> para acessar o cadastro do respectivo associado</p>";
            chamadoViewModel.uri = value.uri;

            ChamadoModel chamadoModel = new ChamadoModel();
            chamadoModel.db = db;
            Chamado chamado = chamadoModel.ExecProcess(chamadoViewModel, Crud.INCLUIR);
            #endregion

            return(medico);
        }
Beispiel #28
0
        public override Validate Validate(RegisterViewModel value, Crud operation)
        {
            EmpresaSecurity <SecurityContext> empresaSecurity = new EmpresaSecurity <SecurityContext>();

            value.mensagem = new Validate()
            {
                Code = 0, Message = MensagemPadrao.Message(0).ToString(), MessageType = MsgType.SUCCESS
            };

            #region Valida CPF
            if (!Funcoes.ValidaCpf(value.cpf.Replace(".", "").Replace("-", "")))
            {
                value.mensagem.Code        = 29;
                value.mensagem.Message     = MensagemPadrao.Message(29, value.login).ToString();
                value.mensagem.MessageBase = "CPF informado está incorreto.";
                value.mensagem.MessageType = MsgType.WARNING;
                return(value.mensagem);
            }
            #endregion

            #region Verifica se o login já existe
            int empresaId         = int.Parse(System.Configuration.ConfigurationManager.AppSettings["empresaId"]);
            UsuarioRepository usu = empresaSecurity.getUsuarioByLogin(value.login, empresaId);
            if (usu != null)
            {
                value.mensagem.Code        = 41;
                value.mensagem.Message     = MensagemPadrao.Message(41, value.login).ToString();
                value.mensagem.MessageBase = "Login já exsitente nos registros da empresa.";
                value.mensagem.MessageType = MsgType.WARNING;
                return(value.mensagem);
            }
            #endregion

            #region Verifica se existe o CPF ou CRM e caso exista, verifica se o usuário já está vinculado
            value.cpf = value.cpf.Replace(".", "").Replace("-", "");
            MedicoViewModel medico = (from med in db.Medicos
                                      where (med.CRM == value.CRM && med.ufCRM == value.ufCRM) ||
                                      med.cpf == value.cpf ||
                                      med.email1 == value.login
                                      select new MedicoViewModel()
            {
                usuarioId = med.usuarioId,
                associadoId = med.associadoId,
                CRM = med.CRM,
                ufCRM = med.ufCRM,
                cpf = med.cpf,
                nome = med.nome
            }).FirstOrDefault();

            if (medico != null)
            {
                if (medico.usuarioId.HasValue)
                {
                    value.mensagem.Code        = 19;
                    value.mensagem.Message     = MensagemPadrao.Message(19).ToString();
                    value.mensagem.MessageBase = "Este CRM/CPF já está vinculado a um usuário.";
                    value.mensagem.MessageType = MsgType.WARNING;
                    return(value.mensagem);
                }

                // Verifica se o CPF e CRM informados estão iguais ao existente no banco de dados
                if ((medico.CRM != null && medico.CRM != "" && medico.CRM != value.CRM) ||
                    (medico.ufCRM != null && medico.ufCRM != "" && medico.ufCRM != value.ufCRM.ToUpper()) ||
                    (medico.cpf != null && medico.cpf != "" && medico.cpf != value.cpf.Replace(".", "").Replace("-", "")) ||
                    (medico.email1 != null && medico.email1 != "" && medico.email1 != value.login))
                {
                    value.mensagem.Code        = 50;
                    value.mensagem.Message     = MensagemPadrao.Message(50).ToString();
                    value.mensagem.MessageBase = "Dados do associado não conferem com os valores existentes nos registros da empresa.";
                    value.mensagem.MessageType = MsgType.WARNING;
                    return(value.mensagem);
                }
            }
            else
            {
                value.mensagem.Code        = 20;
                value.mensagem.Message     = MensagemPadrao.Message(20).ToString();
                value.mensagem.MessageBase = "Dados de Identificação não encontrado.";
                value.mensagem.MessageType = MsgType.WARNING;
                return(value.mensagem);
            }
            #endregion

            return(value.mensagem);
        }
        //private static List<Medico> ListaMedicos()
        //{
        //    List<Medico> medicos = new List<Medico>();
        //    medicos.Add(new Medico {Id = 1, Nome = "João", Crm = "11111"});
        //    medicos.Add(new Medico {Id = 2, Nome = "zé", Crm = "11111"});
        //    medicos.Add(new Medico {Id = 3, Nome = "mario", Crm = "11111"});
        //    medicos.Add(new Medico {Id = 4, Nome = "Maira", Crm = "11111"});
        //    medicos.Add(new Medico {Id = 5, Nome = "Sergio", Crm = "11111"});
        //    return medicos;
        //}
        public ActionResult Incluir()
        {
            var model = new MedicoViewModel();

            return(View(model));
        }
        public ActionResult Editar(MedicoViewModel viewModel)
        {
            if (!this.ModelState.IsValid)
            {
                return this.View(viewModel);
            }

            var medico = this._servico.GetMedico(viewModel.Id);
            if (medico == null)
            {
                return this.HttpNotFound();
            }

            medico.Nome = viewModel.Nome;
            medico.Documento = viewModel.Documento;
            medico.DataNascimento = viewModel.DataNascimento;
            medico.Crm = viewModel.Crm;
            medico.CrmUf = viewModel.CrmUf;
            medico.Especialidade = viewModel.Especialidade;
            medico.DataAtualizacao = DateTimeOffset.UtcNow;

            this._servico.AtualizarMedico(medico);
            this.LogAcao(medico.Id);

            return this.RedirectToAction("Index");
        }
Beispiel #31
0
        public ActionResult Pesquisar(MedicoViewModel medico)
        {
            var servicoCrudMedico = new ServicoCRUDMedico(_session, _medicos);

            return(View(servicoCrudMedico.ConsultaMedicoPorTrechoDoNome(medico.Nome)));
        }