public List <Procedimento> Procedimentos()
{
List <Procedimento> lista = new List <Procedimento>();
SqlCommand cmd = new SqlCommand();
cmd.Connection = connection;
cmd.CommandText = "SELECT * FROM v_procedimentos";
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
Procedimento v = new Procedimento();
Procedimento p = new Procedimento();
p.Id = (int)reader["Id"];
p.Descricao = (string)reader["Descricao"];
p.Valor = (decimal)reader["Valor"];
lista.Add(p);
lista.Add(v);
}
return(lista);
}
//
// GET: /Procedimentos/Editar/5
public ActionResult Editar(int id)
{
Procedimento procedimento = context.Procedimentos.Single(x => x.ProcedimentoId == id);
ViewBag.PossibleTiposAtendimentos = context.TiposAtendimentos;
return(View(procedimento));
}
public ActionResult Cadastrar()
{
if (Session["usuario"] == null || Session["usuario"].ToString() == "")
{
return(RedirectToAction("Login", "Home").Mensagem("Faça o login para entrar"));
}
Procedimento procedimento = new Procedimento();
ViewBag.procedimentoLista = new SelectList(
procedimento.listaProcedimentos(),
"Id",
"Nome"
);
Funcionario funcionario = new Funcionario();
ViewBag.funcionarioLista = new SelectList(
funcionario.listaFuncionarios(),
"IdFuncionario",
"Nome"
);
return(View());
}
public async Task <IActionResult> PutProcedimento(int id, Procedimento procedimento)
{
if (id != procedimento.Id)
{
return(BadRequest());
}
_context.Entry(procedimento).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProcedimentoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <Procedimento> > PostProcedimento(Procedimento procedimento)
{
_context.Procedimentos.Add(procedimento);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetProcedimento", new { id = procedimento.Id }, procedimento));
}
public static Sprite SpriteOf(Procedimento procedimento)
{
var list = Instance.procedimentosSprites;
var element = list.Find(x => x.procedimento == procedimento);
return(element.sprite);
}
protected void gridBuscaAvancada_RowCommand(object sender, GridViewCommandEventArgs e)
{
if (e.CommandName.Equals("sel"))
{
int index = Convert.ToInt32(e.CommandArgument);
long id = Convert.ToInt64(gridBuscaAvancada.DataKeys[index].Value);
Procedimento proc = null; // ProcedimentoFacade.Instancia.Carregar(id);
for (int i = 0; i < cboEspecialidade.Items.Count; i++)
{
if (CUtil.Geral.RetiraAcentos(cboEspecialidade.Items[i].Text.ToUpper()) == CUtil.Geral.RetiraAcentos(proc.Especialidade.ToUpper()))
{
cboEspecialidade.SelectedIndex = i;
cboEspecialidade_SelectedIndexChanged(null, null);
pnlDivProcedimentos.Visible = true;
break;
}
}
cboProcedimento.SelectedValue = proc.ID.ToString();
gridBuscaAvancada.DataSource = null;
gridBuscaAvancada.DataBind();
pnlBuscaAvancada.Visible = false;
//for (int i = 0; i < cboProcedimento.Items.Count; i++)
//{
// if (cboProcedimento.Items[i].Text.ToUpper() == proc.Nome.ToUpper())
//}
}
}
public static string SalvarNovaConsulta(Consulta c)
{
string msg;
try
{
using (ConsultorioContext ctx = new ConsultorioContext())
{
Cliente a = ctx.Clientes.Find(c.Cliente.Id);
Procedimento p = ctx.Procedimentos.Find(c.Procedimento.Id);
c.Cliente = a;
c.Procedimento = p;
ctx.Consultas.Add(c);
ctx.SaveChanges();
msg = "Salva nova consulta";
}
}
catch
{
msg = "Ocorreu um Erro e a consulta NÂO pode ser salva!";
}
return(msg);
}
private void btnGravar_Click(object sender, RoutedEventArgs e)
{
if (!string.IsNullOrWhiteSpace(txtProcedimento.Text))
{
procedimento = new Procedimento
{
NomeProcedimento = txtProcedimento.Text,
Valor = Convert.ToDouble(txtValor.Text)
};
if (ProcedimentoDAO.Cadastrar(procedimento))
{
MessageBox.Show("Procedimento cadastrado!", "Vendas WPF",
MessageBoxButton.OK, MessageBoxImage.Information);
LimparFormulario();
}
else
{
MessageBox.Show("Esse Procedimento já existe!", "Vendas WPF",
MessageBoxButton.OK, MessageBoxImage.Error);
}
}
else
{
MessageBox.Show("Preencha o campo Procedimento!!!", "Vendas WPF",
MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public ActionResult Cadastrar(Procedimento procdigitado)
{
Procedimento procNome = new Procedimento();
if (procNome.existeNome(procdigitado.Nome))
{
ModelState.AddModelError("Nome", "Esse nome já está cadastrado");
}
Procedimento procedimento = new Procedimento();
if (ModelState.IsValid)
{
procedimento.cadastrar(procdigitado);
if (procedimento.erro == "")
{
return(RedirectToAction("Index", "Procedimento").Mensagem("Procedimento cadastrado com sucesso!", "Cadastro realizado"));
}
else
{
return(View(procdigitado).Mensagem(procedimento.erro));
}
}
return(View(procdigitado));
}
protected void btnPesquisar_Click(object sender, EventArgs e)
{
string codigoProcedimento = tbxCodigoProcedimento.Text;
string nomeProcedimento = tbxNomeProcedimento.Text;
IList<Vida.Model.Procedimento> procedimentos = new List<Vida.Model.Procedimento>();
Vida.Model.Procedimento procedimento = new Procedimento();
if (!nomeProcedimento.Equals(""))
procedimentos = Factory.GetInstance<IProcedimento>().BuscarPorNome<Vida.Model.Procedimento>(nomeProcedimento);
if (!codigoProcedimento.Equals(""))
{
procedimento = Factory.GetInstance<IProcedimento>().BuscarPorCodigo<Vida.Model.Procedimento>(codigoProcedimento);
if (procedimento != null)
procedimentos.Add(procedimento);
}
if (procedimentos.Count == 0)
{
ScriptManager.RegisterClientScriptBlock(this, typeof(String), "critica", "alert('Não existe Procedimento com os dados passados!');", true);
return;
}
IList<InfoProcedimento> infoProcedimentos = new List<InfoProcedimento>();
infoProcedimentos = Factory.GetInstance<IInfoProcedimento>().BuscarPorProcedimento<InfoProcedimento>(procedimentos[0].Codigo);
if (infoProcedimentos.Count == 0)
{
ScriptManager.RegisterClientScriptBlock(this, typeof(String), "critica", "alert('Não existe informação para o procedimento informado!');", true);
return;
}
PanelProcedimentos.Visible = true;
GridViewProcedimentos.DataSource = infoProcedimentos;
GridViewProcedimentos.DataBind();
}
public async Task <IActionResult> Edit(Guid id, [Bind("Nome,Valor,Id")] Procedimento procedimento)
{
if (id != procedimento.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(procedimento);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProcedimentoExists(procedimento.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(procedimento));
}
public static string CadastroDeNovoProcedimento(Procedimento procedimento)
{
try
{
using (ConsultorioContext ctx = new ConsultorioContext())
{
var a = new List <Produto>(procedimento.Produtos);
procedimento.Produtos.Clear();
foreach (Produto auxP in a)
{
procedimento.Produtos.Add(ctx.Produtos.First(aux => aux.Id == auxP.Id));
}
foreach (var item in procedimento.Produtos)
{
ctx.Entry(item).State = EntityState.Modified;
}
ctx.Procedimentos.Add(procedimento);
ctx.SaveChanges();
return("Salvo novo Procedimento!");
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return("error" + e.Message);
}
}
public static List <Procedimento> LeituraCSV()
{
List <Procedimento> procedimentos = new List <Procedimento>();
try
{
using (var reader = new StreamReader(@"C:\\Users\\Hugo\\Desktop\\Laser\\1803a.csv"))
{
Console.WriteLine("Starting CSV parse\n");
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
var data = line.Split(';');
Paciente paciente = new Paciente(data[0], data[1]);
Procedimento procedimento = new Procedimento(paciente, TimeSpan.Parse(data[2]));
procedimentos.Add(procedimento);
}
Console.WriteLine("File successfully read.\n");
}
return(procedimentos);
}
catch (Exception ex)
{
Console.WriteLine(" \n**************************** Error - " + ex.Message);
return(null);
}
}
public ProcedimentoBD(Procedimento procedimento)
{
Acoes = procedimento.AcoesFeitasNoProcedimento.Select(acao => new AcaoBD(acao)).ToArray();
PercentualPermitido = procedimento.PercentualPermitido;
IdTipo = procedimento.Tipo.Id;
DataDaOcorrencia = procedimento.DataDaOcorrencia;
}
/// <summary>
/// Inserir procedimento
/// </summary>
/// <param name="procedimento"></param>
public string Insert(Procedimento procedimento)
{
cmd.Connection = conn;
cmd.CommandText = $"INSERT INTO procedimento (nomeProcedimento,dsProcedimento,idTipoProcedimento) values (@nomeProcedimento,@dsProcedimento,@idTipoProcedimento)";
cmd.Parameters.AddWithValue("@nomeProcedimento", procedimento.Nome);
cmd.Parameters.AddWithValue("@dsProcedimento", procedimento.DescricaoProcedimento);
cmd.Parameters.AddWithValue("@idTipoProcedimento", procedimento.TipoProcedimento.Id);
try
{
conn.Open();
cmd.ExecuteNonQuery();
return("Procedimento cadastrado com sucesso!");
}
catch (Exception ex)
{
if (ex.Message.Contains("Duplicate"))
{
return("Procedimento já cadastrado.");
}
else
{
return("Erro no Banco de dados. Contate o administrador.");
}
}
finally
{
conn.Dispose();
}
}
public Procedimento GetProcedimentoIdTipo(int idTipoProcedimento)
{
cmd.Connection = conn;
cmd.CommandText = $"SELECT * FROM procedimento WHERE idTipoProcedimento = {idTipoProcedimento}";
cmd.Parameters.AddWithValue("@ID", idTipoProcedimento);
try
{
conn.Open();
MySqlDataReader reader = cmd.ExecuteReader();
Procedimento temp = new Procedimento();
while (reader.Read())
{
temp.TipoProcedimento = new TipoProcedimento();
temp.Id = Convert.ToInt32(reader["idProcedimento"]);
temp.Nome = Convert.ToString(reader["nomeProcedimento"]);
temp.DescricaoProcedimento = Convert.ToString(reader["dsProcedimento"]);
temp.TipoProcedimento.Id = Convert.ToInt32(reader["idTipoProcedimento"]);
}
return(temp);
}
catch (Exception)
{
throw new Exception("Erro no Banco de dados.Contate o administrador.");
}
finally
{
conn.Dispose();
}
}
public async Task <IActionResult> Edit(int id, Procedimento procedimento)
{
if (id != procedimento.ProcedimentoId)
{
_logger.LogError("Procedimento não encontrado");
return(NotFound());
}
if (ModelState.IsValid)
{
_logger.LogInformation("Atualizando procedimento");
await _procedimentoRepositorio.Atualizar(procedimento);
_logger.LogInformation("Procedimento atualizado");
TempData["Mensagem"] = "Atualizado com sucesso";
return(RedirectToAction(nameof(Index)));
}
ViewData["SexoId"] = new SelectList(new[] {
new { ID = "Masculino", Name = "Masculino" },
new { ID = "Feminino", Name = "Feminino" },
new { ID = "Ambos", Name = "Ambos" },
}, "ID", "Name");
ViewData["GrupoFaturamentoId"] = new SelectList(_context.GrupoFaturamentos, "GrupoFaturamentoId", "Descricao", procedimento.GrupoFaturamentoId);
return(View(procedimento));
}
/// <summary>
/// retorna lista com todos os Procedimentos
/// </summary>
/// <returns></returns>
public List <Procedimento> GetAll()
{
cmd.Connection = conn;
cmd.CommandText = "SELECT * FROM procedimento";
try
{
conn.Open();
MySqlDataReader reader = cmd.ExecuteReader();
List <Procedimento> procedimentos = new List <Procedimento>();
while (reader.Read())
{
Procedimento temp = new Procedimento();
temp.TipoProcedimento = new TipoProcedimento();
temp.Id = Convert.ToInt32(reader["idProcedimento"]);
temp.Nome = Convert.ToString(reader["nomeProcedimento"]);
temp.DescricaoProcedimento = Convert.ToString(reader["dsProcedimento"]);
temp.TipoProcedimento.Id = Convert.ToInt32(reader["idTipoProcedimento"]);
procedimentos.Add(temp);
}
return(procedimentos);
}
catch (Exception)
{
throw new Exception("Erro no Banco de dados.Contate o administrador.");
}
finally
{
conn.Dispose();
}
}
public ActionResult Editar(int id)
{
if (Session["usuario"] == null || Session["usuario"].ToString() == "")
{
return(RedirectToAction("Login", "Home").Mensagem("Faça o login para entrar"));
}
Sessao sessao = new Sessao();
sessao = sessao.buscar(id);
Procedimento procedimento = new Procedimento();
ViewBag.procedimentoLista = new SelectList(
procedimento.listaProcedimentos(),
"Id",
"Nome",
sessao.Id_procedimento
);
Funcionario funcionario = new Funcionario();
ViewBag.funcionarioLista = new SelectList(
funcionario.listaFuncionarios(),
"IdFuncionario",
"Nome",
sessao.Id_funcionario
);
return(View(sessao));
}
public FinalizacaoConsultaViewModel(int idConsulta, out bool procedimentoDaListaDeOrcamento, out string procedimentoDaListaDeOrcamentoNome)
{
TodosOsProcedimentos = ConsultasData.ListarTodosOsProcedimentos();
Consulta = ConsultasData.SelecionarConsulta(idConsulta);
var idProcedimentoDaConsulta = Consulta.Procedimento.Id;
Consulta.Fim = DateTime.Now;
ProcedimentosEmOrcamento = CarregarProcedimentosDeOrcamento();
ListaProdutosUtilizadoNaConsulta = new ObservableCollection <ProdutoUtilizadoEmConsulta>();
CarregarProdutosDaConsulta();
ProcedimentoSelecionado = ProcedimentosEmOrcamento.FirstOrDefault(a => a.Id == idProcedimentoDaConsulta);
procedimentoDaListaDeOrcamento = false;
if (ProcedimentoSelecionado != null)
{
procedimentoDaListaDeOrcamento = true;
}
else
{
ProcedimentoSelecionado = TodosOsProcedimentos.First(_ => _.Id == idProcedimentoDaConsulta);
}
procedimentoDaListaDeOrcamentoNome = ProcedimentoSelecionado.Nome;
LimparlistaDeProdutos();
}
//Atualizar um registro existente
public string Update(Procedimento procedimento)
{
StringBuilder erros = new StringBuilder();
if (string.IsNullOrWhiteSpace(procedimento.Nome))
{
erros.AppendLine("O nome do procedimento deve ser informada.");
}
if (string.IsNullOrWhiteSpace(procedimento.DescricaoProcedimento))
{
erros.AppendLine("A descrição do procedimento deve ser informada.");
}
if (!string.IsNullOrWhiteSpace(procedimento.DescricaoProcedimento))
{
if (procedimento.DescricaoProcedimento.Length > 60)
{
erros.AppendLine("A descrição do procedimento não pode conter mais que 60 caracteres.");
}
}
if (erros.Length != 0)
{
return(erros.ToString());
}
string respostaDB = dal.Update(procedimento);
return(respostaDB);
}
public ActionResult Editar(Sessao sessaoEdit, string procedimentoLista, string funcionarioLista)
{
Cliente cliente = new Cliente();
if (!cliente.existeCpf(sessaoEdit.Cpf_cliente))
{
ModelState.AddModelError("Cpf_cliente", "CPF não encontrado");
}
if (procedimentoLista == "")
{
ModelState.AddModelError("Id_procedimento", "Campo não pode ficar em branco");
}
else
{
sessaoEdit.Id_procedimento = int.Parse(procedimentoLista);
}
if (funcionarioLista == "")
{
ModelState.AddModelError("Id_funcionario", "Campo não pode ficar em branco");
}
else
{
sessaoEdit.Id_funcionario = int.Parse(funcionarioLista);
}
Sessao sessao = new Sessao();
if (ModelState.IsValid)
{
sessaoEdit.buscarIdClientePeloCpf();
sessao.editar(sessaoEdit);
if (sessao.erro == "")
{
return(RedirectToAction("Index", "Sessao").Mensagem("Sessão alterada com sucesso!", "Alteração realizada"));
}
}
Procedimento procedimento = new Procedimento();
ViewBag.procedimentoLista = new SelectList(
procedimento.listaProcedimentos(),
"Id",
"Nome",
sessao.Id_procedimento
);
Funcionario funcionario = new Funcionario();
ViewBag.funcionarioLista = new SelectList(
funcionario.listaFuncionarios(),
"IdFuncionario",
"Nome",
sessao.Id_funcionario
);
return(View(sessaoEdit).Mensagem(sessao.erro));
}
public void TestarAtualizarDescricaoTamanhoExcedido()
{
Procedimento test = new Procedimento(1, "Arrancamento de penas", tipoProcedimento, "013245678901324567890132456789013245678901324567890132456789013245678901324567890132456789", atendimentos);
str = bll.Update(test);
Assert.AreEqual(str, "A descrição do procedimento não pode conter mais que 60 caracteres.\r\n");
}
public void TestarAtualizarDescricaoVazio()
{
Procedimento test = new Procedimento(1, "Arrancamento de penas", tipoProcedimento, "", atendimentos);
str = bll.Update(test);
Assert.AreEqual(str, "A descrição do procedimento deve ser informada.\r\n");
}
public void TestarAtualizarProcedimento()
{
Procedimento test = new Procedimento(1, "Arrancamento de penas", tipoProcedimento, "blabla", atendimentos);
str = bll.Update(test);
Assert.AreEqual(str, "Procedimento atualizado com êxito!");
}
private void DefinirProcedimentos(Procedimento p1, Procedimento p2, Procedimento p3)
{
Debug.Log("Procedimentos: " + p1 + ", " + p2 + " e " + p3);
planejamento.DefinirProcedimentoMomento1(p1);
planejamento.DefinirProcedimentoMomento2(p2);
planejamento.DefinirProcedimentoMomento3(p3);
}
public void TestarInsertLogradouro()
{
Procedimento test = new Procedimento(1, "Arrancamento de penas", tipoProcedimento, "blabla", atendimentos);
str = bll.Insert(test);
Assert.AreEqual(str, "Procedimento cadastrado com sucesso!");
}
public ActionResult ConfirmarExclusao(int id)
{
Procedimento procedimento = context.Procedimentos.Single(x => x.ProcedimentoId == id);
context.Procedimentos.Remove(procedimento);
context.SaveChanges();
return(RedirectToAction(nameof(ProcedimentosController.Indice)));
}
public void Selecionar(Procedimento procedimento)
{
var nodo = disponiveis.Find(procedimento);
if (nodo != null)
{
Selecionar(nodo);
}
}
//-----------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------*********Botoes**********--------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------*********Metodos**********-------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------------
private void CarregarListaDeProdutos()
{
if (ProcedimentoSelecionado != null)
{
Procedimento procedimentoSelecionadoComProdutos = ListaDeProcedimentoData.CarregarProdutosDoProcedimento(ProcedimentoSelecionado);
ListaDeProdutosParaExibir = new ObservableCollection <Produto>(procedimentoSelecionadoComProdutos.Produtos);
}
}
public void IncluirProcedimentoAPaciente(string procedimento, string data, string pacienteId)
{
if (string.IsNullOrEmpty(pacienteId) || string.IsNullOrEmpty(procedimento) || string.IsNullOrEmpty(data)) return;
var paciente = _pacientes.Obter<Paciente>(int.Parse(pacienteId));
var tipoProcedimento = _tipoProcedimentos.Obter<TipoProcedimento>(int.Parse(procedimento));
var procediment = new Procedimento { DataProcedimento = DateTime.Parse(data), TipoProcedimento = tipoProcedimento };
paciente.Adicionar(procediment);
_pacientes.Adicionar(paciente);
}
private static Paciente PacienteMatheus()
{
var admissaos = new Admissaos();
var admissao = admissaos.Obter<Admissao>(1);
var admissao2 = admissaos.Obter<Admissao>(2);
var alergias = new Alergias();
var alergia = alergias.Obter<Alergia>(1);
var tipoProcedimentos = new TipoProcedimentos();
var tipoProcedimento = tipoProcedimentos.Obter<TipoProcedimento>(1);
var tipoProcedimento2 = tipoProcedimentos.Obter<TipoProcedimento>(2);
var admissaoHospital = new AdmissaoHospital
{
DataAdmissao = new DateTime(2012, 5, 20),
DataSaida = new DateTime(2012, 6, 20),
Registro = "21545",
Hospital = new Hospital { Id = 1 },
//Admissao = new Admissao { Id = 2 }
};
admissaoHospital.Adicionar(admissao);
admissaoHospital.Adicionar(admissao);
var procedimento = new Procedimento { DataProcedimento = new DateTime(2012, 5, 20), TipoProcedimento = tipoProcedimento };
var procedimento2 = new Procedimento { DataProcedimento = new DateTime(2012, 5, 25), TipoProcedimento = tipoProcedimento2 };
var paciente = new Paciente
{
CPF = "02145253625",
Nome = "Matheus",
Nascimento = DateTime.Parse("20/09/1998"),
DataUltimaAtualizacao = DateTime.UtcNow,
Sexo = new TipoSexo { Id = 1 },
TipoDiagnostico = new TipoDiagnostico { Id = 1 },
TipoPaciente = new TipoPaciente { Id = 1 }
};
paciente.Adicionar(procedimento);
paciente.Adicionar(procedimento2);
paciente.Adicionar(admissaoHospital);
paciente.DadosGerais.Adicionar(alergia);
return paciente;
}
private void HabilitaAprazarProcedimento(Procedimento procedimento)
{
//Procedimento procedimento = Factory.GetInstance<IProcedimento>().BuscarPorCodigo<Procedimento>(co_procedimento);
OnClick_CancelarProcedimentoAprazamento(new object(), new EventArgs());
this.DropDownList_ProcedimentoAprazar.Items.Clear();
DropDownList_ProcedimentoAprazar.Items.Add(new ListItem(procedimento.Nome, procedimento.Codigo.ToString()));
DropDownList_ProcedimentoAprazar.SelectedValue = procedimento.Codigo.ToString();
}
