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);
}
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));
}
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));
}
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));
}
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);
}
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"));
}
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);
}
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));
}
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));
}
}
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));
}
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"));
}
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);
}
public IActionResult Atualizar(int id, MedicoViewModel json)
{
_medicoRepository.Atualizar(id, json);
return(Ok("Atualizado"));
}
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);
}
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");
}
public ActionResult Pesquisar(MedicoViewModel medico)
{
var servicoCrudMedico = new ServicoCRUDMedico(_session, _medicos);
return(View(servicoCrudMedico.ConsultaMedicoPorTrechoDoNome(medico.Nome)));
}