public ActionResult Excluir(Especialidade Especialidade)
{
if (Request.IsAuthenticated)
{
especialidadeRepositorio.Excluir(Especialidade);
return RedirectToAction("Index", "Especialidade");
}
ViewBag.MensagemErro = "Desculpe, você não está autenticado no sistema. Página restrita.";
return View("Error");
}
public async Task <IActionResult> Create(Especialidade especialidade)
{
if (ModelState.IsValid)
{
_logger.LogInformation("Adicionando Especialidade");
await _especialidadeRepositorio.Inserir(especialidade);
_logger.LogInformation("Especialidade Médica Adicionada");
TempData["Mensagem"] = "Adicionado com sucesso";
return(RedirectToAction(nameof(Index)));
}
_logger.LogError("Especialidade médica não esta valida");
return(View(especialidade));
}
//Adquirir valor do combobox Especialidade da thread principal
private Especialidade GetEspecialidade()
{
Especialidade especialidade = null;
Invoke(new MethodInvoker(delegate()
{
if (!comboBox1.IsDisposed)
{
especialidade = ((BindingList <Especialidade>)comboBox1.DataSource)
.ElementAt(comboBox1.SelectedIndex);
}
}));
return(especialidade);
}
private void validationInsertUpdate(Especialidade Especialidade)
{
try
{
Especialidade.Nome = txtNome.Text.ValidarTextoVazio("Nome");
Especialidade.ValorConsulta = txtValorConsulta.Text.ValidarDecimal();
Especialidade.RemuneracaoConvenio = txtRemuneracaoConvenio.Text.ValidarPorcentagemDecimal();
Especialidade.RemuneracaoParticular = txtRemuneracaoParticular.Text.ValidarPorcentagemDecimal();
Especialidade.TempoConsulta = cbTempoConsulta.ValidarItemSelecionado("Tempo de Consulta");
}
catch (Exception)
{
throw;
}
}
public async Task <bool> UpdateAsync(int id, Especialidade especialidade)
{
Especialidade = _context.Especialidade.SingleOrDefault(x => x.Id == id);
if (Especialidade == null)
{
return(false);
}
Especialidade.Descricao = especialidade.Descricao;
await _context.SaveChangesAsync();
return(true);
}
public ActionResult Editar(Especialidade model)
{
if (model.Id == 0)
{
EspecialidadeService.Instance.Create(model);
}
else
{
EspecialidadeService.Instance.Update(model);
}
AddMessageSuccess("Especialidade salva com sucesso.");
return(RedirectToAction("Index", "Especialidade"));
}
// GET: Especialidades/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Especialidade especialidade = db.Especialidades.Find(id);
if (especialidade == null)
{
return(HttpNotFound());
}
ViewBag.Id_Cede = new SelectList(db.Cedes, "Id_Cede", "CedeNombre", especialidade.Id_Cede);
return(View(especialidade));
}
public ActionResult ConfirmacaoExclusao(int id)
{
Especialidade especialidade = db.Especialidade.Find(id);
Medico medico = db.Medico.Where(p => p.EspecialidadeId == id).FirstOrDefault();
if (medico != null)
{
ModelState.AddModelError("", "A especialidade não pode ser excluída pois está sendo usada");
return(View(especialidade));
}
db.Especialidade.Remove(especialidade);
db.SaveChanges();
return(RedirectToAction("Listar"));
}
public void When_RepositoryReturnsNull_Then_ResultNull()
{
var repoMock = new Mock <IRepository <Especialidade> >();
Especialidade expected = null;
repoMock.Setup(x => x.Find(It.IsAny <Guid>())).Returns(expected);
var mapper = new MapperConfiguration(config => config.AddProfile <MappingProfiles>()).CreateMapper();
var busMock = new Mock <IBus>();
var service = new EspecialidadeService(repoMock.Object, mapper, busMock.Object);
var result = service.Get(Guid.NewGuid());
Assert.IsNull(result);
}
public IActionResult Post(Especialidade novaEspecialidade)
{
//tratamento de excessao
try
{
_especialidadeRepository.Cadastrar(novaEspecialidade);
return(StatusCode(201));
}
catch (Exception ex)
{
// retorna um BadReques (StatusCode 400)
return(BadRequest(ex));
}
}
public Especialidade Update(Especialidade especialidade)
{
string updateQuery = @"update tbl_especialidade
SET
[Atualizado] = GETDATE(),
[Descricao] = @Descricao
WHERE Id = @Id";
using (var conn = new SqlConnection(_connection))
{
conn.ExecuteScalar <int>(updateQuery, new { Descricao = especialidade.Descricao, Id = especialidade.Id });
}
return(GetEspecialidade(especialidade.Id));
}
public void Delete(Especialidade entity)
{
try
{
entity.DateAlteracao = DateTime.UtcNow;
entity.Status = 9;
entity.Ativo = false;
_repository.Update(entity);
}
catch (Exception e)
{
throw new EspecialidadeException("Não foi possível desativar a especialidade informada.", e);
}
}
public async Task <IViewComponentResult> InvokeAsync(int PrestadorId)
{
Especialidade especialidade = new Especialidade();
var innerjoin = await(from e in _contexto.Especialidades
join ep in _contexto.PrestadoresEspecialidades
on e.EspecialidadeId equals ep.EspecialidadeId
join p in _contexto.Prestadores
on ep.PrestadorId equals p.PrestadorId
where p.PrestadorId == PrestadorId
select e).ToListAsync();
ViewData["PrestadorId"] = PrestadorId;
ViewData["EspecialidadeId"] = new SelectList(_contexto.Especialidades, "EspecialidadeId", "Descricao");
return(View(innerjoin));
}
// GET: Posts/Delete/5
//[Authorize(Roles = "Administrador")]
public ActionResult Excluir(int id)
{
if (id == 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Especialidade especialidade = db.Especialidade.Find(id);
if (especialidade == null)
{
return(HttpNotFound());
}
return(View(especialidade));
}
public IActionResult Create([FromBody] Models.Medico medico)
{
var insert = _medicoRepository.Add(new Repositories.Model.Medico
{
Nome = medico.Nome,
Cpf = medico.Cpf,
Crm = medico.Crm
});
var especialidades = _especialidadeRepository.GetAll().ToList();
var especialidadesMedico = new List <EspecialidadeMedico>();
var especialidadesNaoCadastradas = new List <string>();
var especialidadesCadastradas = especialidades.Where(x => medico.Especialidades.Any(y => y.ToLower() == x.Nome.ToLower())).ToList();
if (especialidadesCadastradas.Any())
{
especialidadesNaoCadastradas = medico.Especialidades.Where(x => especialidadesCadastradas.Any(y => y.Nome.ToLower() != x.ToLower())).ToList();
}
else
{
especialidadesNaoCadastradas = medico.Especialidades.ToList();
}
foreach (var item in especialidadesNaoCadastradas)
{
var itemEspecialidade = new Especialidade {
Nome = item
};
var idEspecialidade = _especialidadeRepository.Add(itemEspecialidade);
especialidadesCadastradas.Add(new Especialidade {
Id = new Guid(idEspecialidade), Nome = item
});
}
foreach (var item in especialidadesCadastradas)
{
especialidadesMedico.Add(new EspecialidadeMedico {
EspecialidadeId = item.Id, MedicoId = new Guid(insert)
});
}
_especialidadeMedicoRepository.AddRange(especialidadesMedico);
return(Ok(insert));
}
// GET: Especialidades/Edit/5
public ActionResult Edit(int?id)
{
UpdateBag();
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Especialidade especialidade = _especialidadeService.GetById(id.Value);
if (especialidade == null)
{
return(HttpNotFound());
}
return(View(especialidade));
}
public void Atualizar(int id, Especialidade especialidadeAtualizada)
{
Especialidade especialidadeBuscada = ctx.Especialidade.Find(id);
if (especialidadeBuscada != null)
{
if (especialidadeAtualizada != null)
{
especialidadeBuscada.NomeEspecialidade = especialidadeAtualizada.NomeEspecialidade;
}
ctx.Especialidade.Update(especialidadeBuscada);
ctx.SaveChanges();
}
}
public void salvar(Especialidade especialidade)
{
try{
command = new MySqlCommand();
var sql = "insert into especialidade(descricao, dtCadastro)" +
"values(@descricao, current_timestamp())";
command = new MySqlCommand(sql, connection);
command.Parameters.AddWithValue("@descricao", especialidade.Descricao);
command.ExecuteNonQuery();
}catch (Exception erro) {
throw new Exception("Erro ao registrar dado " + erro.Message + erro.ToString());
}finally{
}
}
public IActionResult Post(Especialidade especialidade)
{
try
{
EspecialidadeRepositorio.Cadastrar(especialidade);
return(Ok(new
{
mensagem = "Especialidade Cadastrada"
}));
}
catch
{
return(BadRequest());
}
}
public ActionResult Create(Especialidade especialidade)
{
try
{
if (!ModelState.IsValid)
{
return(View());
}
especialidade.AddEspecialidade(especialidade);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public IActionResult Put(int id, Especialidade especialidadeUpdate)
{
try
{
//faz a chamada para o metodo
_especialidadeRepository.Atualizar(id, especialidadeUpdate);
//retorna um statuscode
return(StatusCode(204));
}
catch (Exception ex)
{
//retorna um status code 400
return(BadRequest(ex));
}
}
public ActionResult Edit(Especialidade Eespecialidade)
{
try
{
if (!ModelState.IsValid)
{
return(View("NotFount"));
}
//Chama o método da classe Especialidades que atualizar o registro no banco de dados especialidade.UpdateEspecialidade(pespecialidade);
especialidade.UpdateEspecialidade(Eespecialidade);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public ActionResult Edit(Especialidade especialidade)
{
UpdateBag();
especialidade.DataAlteracao = DateTime.Now;
especialidade.UsuarioAlteracao = ViewBag.UsuarioLogin;
ModelState.Clear();
TryValidateModel(especialidade);
if (ModelState.IsValid)
{
_especialidadeService.Update(especialidade);
return(RedirectToAction("Index"));
}
return(View(especialidade));
}
public void InserirEspecialidade(Especialidade espec)
{
Especialidade result = BuscarEspecialidade(espec.Nome);
if (result == null)
{
// sabe deus para que eles precisam disso....
model.TblEspecialidades.Add(espec);
}
else
{
throw new ERPException("Especialidade já cadastrada.");
}
model.SaveChanges();
finClient.cadastraEspecialidade(espec.Id, espec.Nome);
}
public void Atualizar(int id, Especialidade especialidadeAtualizada)
{
// busca uma especialidade pelo seu id
Especialidade especialidadeBuscado = ctx.Especialidades.Find(id);
// verifica se o nome da classe foi informado
if (especialidadeAtualizada.NomeEspecialidade != null)
{
// atribui os novos valores aos campos existentes
especialidadeBuscado.NomeEspecialidade = especialidadeAtualizada.NomeEspecialidade;
}
// atualiza a clinica que foi buscada
ctx.Especialidades.Update(especialidadeBuscado);
// salva a alteração no banco
ctx.SaveChanges();
}
public IActionResult GetById(int id)
{
try
{
Especialidade especialidadeBuscada = _especialidadeRepository.BuscarPorId(id);
if (especialidadeBuscada == null)
{
return(NotFound("Nenhuma especialidade encontrada!"));
}
return(Ok(especialidadeBuscada));
}
catch (Exception codErro)
{
return(BadRequest(codErro));
}
}
public bool Atualizar(int id, Especialidade especialidadeAtualizado)
{
Especialidade especialidadeBuscada = BuscarPorId(id);
Especialidade especialidadeBuscar = ctx.Especialidades.FirstOrDefault(x => x.nomeEspecialidade == especialidadeAtualizado.nomeEspecialidade);
if (especialidadeAtualizado.nomeEspecialidade != null && especialidadeBuscar == null)
{
especialidadeBuscada.nomeEspecialidade = especialidadeAtualizado.nomeEspecialidade;
ctx.Especialidades.Update(especialidadeBuscada);
ctx.SaveChanges();
return(true);
}
return(false);
}
public IActionResult Put(int id, Especialidade especialidadeAtualizada)
{
try
{
if (_especialidadeRepository.BuscarPorId(id) != null)
{
_especialidadeRepository.Atualizar(id, especialidadeAtualizada);
return(StatusCode(204));
}
return(NotFound("Especialidade não encontrada!"));
}
catch (Exception exception)
{
return(BadRequest(exception));
}
}
public void Atualizar(Especialidade especialidadeAtualizada, int id)
{
//Instância a especialidade buscada, busca o id
Especialidade especialidadeBuscada = ctx.Especialidades.Find(id);
//Verifica se é existente
if (especialidadeAtualizada.Tipos != null)
{
//Atribui valores para a atualização
especialidadeBuscada.Tipos = especialidadeAtualizada.Tipos;
}
//Executa o método atribuido
ctx.Especialidades.Update(especialidadeBuscada);
//Salva as alteraçõs
ctx.SaveChanges();
}
public void Atualizar(int id, Especialidade EspecialidadeAtualizada)
{
//busca uma classe através do Id
Especialidade EspecialidadeBuscada = ctx.Especialidades.Find(id);
//verifica se o nome da classe foi informada
if (EspecialidadeAtualizada.Nome != null)
{
//atribui o valor ao campo existente
EspecialidadeBuscada.Nome = EspecialidadeAtualizada.Nome;
}
//atualiza o campo buscado
ctx.Especialidades.Update(EspecialidadeBuscada);
//salva as alterações para serem salvas no banco de dados
ctx.SaveChanges();
}
public ActionResult Create()
{
PopulateEstabelecimentosDropDownList();
PopulatePetiscosDropDownList();
var e = new Especialidade
{
Caracteristicas = new List <string>
{
"",
"",
"",
"",
""
}
};
return(View(e));
}
public async Task DeveDeletarRegistroNoBanco()
{
//Arrange
var especialidade = new Especialidade {
Descricao = "Urologista"
};
await this.especialidadeRepository.Save(especialidade);
//Action
await this.especialidadeRepository.Delete(especialidade);
var especialidadeDeletada = await this.especialidadeRepository.FindById(especialidade.Id);
//Assert
Assert.IsNull(especialidadeDeletada);
}
