public IHttpActionResult PostProcedimiento(Procedimiento procedimiento)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Procedimiento.Add(procedimiento);
try
{
db.SaveChanges();
}
catch (DbUpdateException)
{
if (ProcedimientoExists(procedimiento.codigoCUP))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = procedimiento.codigoCUP }, procedimiento));
}
public async Task <IActionResult> Edit(int id, [Bind("procedimientoID,procedimiento,precio,areaID")] Procedimiento proc)
{
if (id != proc.procedimientoID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(proc);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProcedimientoExists(proc.procedimientoID))
{
return(NotFound());
}
else
{
throw;
}
}
return(Json(new { SAVE = "Y" }));
}
ViewData["areaID"] = new SelectList(_context.Area, "AreaID", "areaNom", proc.areaID);
return(PartialView("Edit", proc));
}
public void guardarMetodos(ParseTreeNode raiz, ParseTreeNode raizCompleta)
{
foreach (ParseTreeNode hijo in raiz.ChildNodes)
{
if (hijo.Term.Name.Equals("PROCEDIMIENTO"))
{
Simbolo procedimiento = new Simbolo("", hijo);
Procedimiento nuevo = getProcedimientoCompleto(procedimiento.id, raizCompleta);
Boolean estado = Form1.sistemaArchivos.setMetodo(nuevo);
if (!estado)
{
agregarError("Semantico", "El procedimiento " + hijo.ChildNodes[0].Token.Text + " ya existe", hijo.Span.Location.Line, hijo.Span.Location.Column);
}
}
else if (hijo.Term.Name.Equals("FUNCION"))
{
Simbolo procedimiento = new Simbolo("", hijo);
Procedimiento nuevo = getProcedimientoCompleto(procedimiento.id, raizCompleta);
Boolean estado = Form1.sistemaArchivos.setMetodo(nuevo);
if (!estado)
{
agregarError("Semantico", "La funcion " + hijo.ChildNodes[0].Token.Text + " ya existe", hijo.Span.Location.Line, hijo.Span.Location.Column);
}
}
}
}
public async Task <IActionResult> Post([FromBody] Reserva r)
{
if (!ConexionOracle.Activa)
{
ConexionOracle.Open();
if (!ConexionOracle.Activa)
{
return(StatusCode(504, ConexionOracle.NoConResponse));
}
}
Procedimiento p = new Procedimiento(ConexionOracle.Conexion, "SP_ID_RESERVA");
p.Parametros.Add("id_reserva", OracleDbType.Int32, ParameterDirection.Output);
await p.Ejecutar();
int idf = Convert.ToInt32((decimal)(OracleDecimal)(p.Parametros["id_reserva"].Value));
r.Multa_pagado = 0;
r.Multa_total = 0;
r.Id_reserva = idf;
r.Valor_pagado = 0;
r.Fecha = DateTime.Now;
r.Id_estado = 1;
if (await cmd.Insert(r, false))
{
return(Ok(r));
}
return(BadRequest());
}
// GET: Procedimiento/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (!id.HasValue)
{
ViewData["Error"] = await ErrorAsync("Procedimiento", "Edit", "No se ingreso el Id", 400);
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var result = await GetAsync("api/Procedimiento/" + id.Value);
Procedimiento procedimiento = null;
if (result.IsSuccessStatusCode)
{
var resultdata = result.Content.ReadAsStringAsync().Result;
procedimiento = JsonConvert.DeserializeObject <Procedimiento>(resultdata);
}
if (procedimiento == null)
{
ViewData["Error"] = await ErrorAsync("Procedimiento", "Edit", "Error al consultar api", 404);
return(HttpNotFound());
}
return(View(procedimiento));
}
public IHttpActionResult PutProcedimiento(Procedimiento procedimiento)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Entry(procedimiento).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ProcedimientoExists(procedimiento.codigoCUP))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public ActionResult DeleteConfirmed(int id)
{
Procedimiento procedimientos = db.Procedimientos.Find(id);
db.Procedimientos.Remove(procedimientos);
db.SaveChanges();
return(RedirectToAction("Procedimientos"));
}
public void declararProcedimiento(string nombre, Procedimiento procedimiento, int linea, int columna)
{
Debug.WriteLine("Nombre Entorno -> " + this.nombre.ToString() + " Funcion -> " + procedimiento.nombre);
this.linea.Add(nombre, linea);
this.columna.Add(nombre, columna);
this.procedimiento.Add(nombre, procedimiento);
this.reporte.nuevoSimbolo(nombre, "Procedimiento", this.nombre, linea, columna);
}
public ActionResult AgregarNivel(int?id)
{
ViewBag.id = id;
Procedimiento procedimientos = db.Procedimientos.Find(id);
ViewBag.nombre_procedimiento = procedimientos.nombre;
return(View());
}
public async Task <ActionResult> DeleteConfirmed(long id)
{
Procedimiento procedimiento = await db.Procedimiento.FindAsync(id);
db.Procedimiento.Remove(procedimiento);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Auth([FromHeader(Name = "User-Agent")] String userAgent, [FromBody] Usuario usuario)
{
if (!ConexionOracle.Activa)
{
ConexionOracle.Open();
if (!ConexionOracle.Activa)
{
return(StatusCode(504, ConexionOracle.NoConResponse));
}
}
var p = new Procedimiento(ConexionOracle.Conexion, "SP_AUTENTICAR");
int resultado = 3;
String msg = "";
p.Parametros.Add("usr", OracleDbType.Varchar2, usuario.Username, ParameterDirection.Input);
p.Parametros.Add("pwd", OracleDbType.Varchar2, Tools.Encriptar(usuario.Clave), ParameterDirection.Input);
p.Parametros.Add("rol", OracleDbType.Int32, ParameterDirection.Output);
p.Parametros.Add("resultado", OracleDbType.Int32, resultado, ParameterDirection.Output);
p.Parametros.Add("msg", OracleDbType.Varchar2, msg, ParameterDirection.Output);
try
{
await p.Ejecutar();
resultado = Convert.ToInt32((decimal)(OracleDecimal)(p.Parametros["resultado"].Value));
switch (resultado)
{
case 0: //Usuario no existe.
return(BadRequest(new { error = "Usuario no existe." }));
case 1: //Contraseña incorrecta.
return(BadRequest(new { error = "Contraseña incorrecta." }));
case 2: //Inicio exitoso.
usuario = await cmd.Get <Usuario>(usuario.Username);
Persona persona = await cmd.Get <Persona>(usuario.Rut);
if (userAgent.Equals("TurismoRealDesktop"))
{
if (usuario.Id_rol > 1)
{
return(StatusCode(401, new { Error = "Acceso Denegado." }));
}
}
return(Ok(SesionsManager.Sesiones.Registrar(Tools.GenerarToken(usuario, persona))));
default:
return(StatusCode(502));
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(StatusCode(500, new { error = e, msg = p.Parametros["msg"].Value.ToString() }));
}
//return StatusCode(418);
}
public Procedimiento Agregar(Procedimiento procedimientoA)
{
using (var cnx = Conexion.Open)
{
cnx.Procedimiento.InsertOnSubmit(procedimientoA);
cnx.SubmitChanges();
}
return(procedimientoA);
}
private List <Procedimiento> recorrerProcedimiento(ParseTreeNode raiz)
{
List <Procedimiento> listaProcedimientos = new List <Procedimiento>();
// Primero verificamos de que existan procedimientos
if (raiz.ChildNodes.Count > 0)
{
foreach (ParseTreeNode nodo in raiz.ChildNodes[0].ChildNodes)
{
String tipo = "";
Procedimiento nuevoProc = new Procedimiento("", "");
//= new Procedimiento()
if (nodo.ChildNodes.Count == 9)
{
tipo = nodo.ChildNodes[6].Token.Text;
}
if (nodo.ChildNodes.Count == 6) // No tiene retorno
{
nuevoProc = new Procedimiento(nodo.ChildNodes[2].ChildNodes[0].Token.Text.Replace("\"", ""), "");
}
else if (nodo.ChildNodes.Count == 9) // tiene retorno
{
nuevoProc = new Procedimiento(nodo.ChildNodes[2].ChildNodes[0].Token.Text.Replace("\"", ""), nodo.ChildNodes[6].Token.Text.Replace("\"", ""));
}
nuevoProc.codigoFuente = nodo.ChildNodes[4].Token.Text;
/*Generamos el arbol de la funcion*/
/*Ahora vamos a cargar los parametros*/
foreach (ParseTreeNode nodoParametro in nodo.ChildNodes[4].ChildNodes)
{
if (nodoParametro.ChildNodes[0].Token.Text.Replace("\"", "").ToLower().Equals
(nodoParametro.ChildNodes[2].Token.Text.Replace("\"", "").ToLower()))
{
Parametro parametro = new Parametro(nodoParametro.ChildNodes[0].Token.Text.Replace("\"", ""), nodoParametro.ChildNodes[1].ChildNodes[0].Token.Text.Replace("\"", ""));
nuevoProc.nombre.Replace(".", "$");
nuevoProc.id = nuevoProc.nombre;
nuevoProc.listaParametros.Add(parametro);
}
else
{
Error error = new Error("Semantico", "Procedimiento " + nuevoProc.nombre + " Error en esta etiqueta", nodoParametro.ChildNodes[0].Token.Location.Line
, +nodoParametro.ChildNodes[0].Token.Location.Column);
Form1.errores.Add(error);
Form1.Mensajes.Add(error.getMensaje());
}
}
nuevoProc.nombre = nuevoProc.nombre.Replace(".", "$");
nuevoProc.id = nuevoProc.nombre;
nuevoProc.codigoFuente = nuevoProc.codigoFuente.Replace("~", "");
nuevoProc.tipoRetorno = tipo;
listaProcedimientos.Add(nuevoProc);
}
}
return(listaProcedimientos);
}
public Resultado ejecutar(ParseTreeNode raiz)
{
Resultado resultado = null;
List <Resultado> valores = getvalParametros(raiz.ChildNodes[1]);
String id = getId(raiz.ChildNodes[0].Token.Text, valores);
//Simbolo metodo = Interprete.metodos.getSimboloId(id);
Procedimiento metodo = Form1.sistemaArchivos.getMetodo(id);
if (metodo != null)
{
TablaSimbolo aux = Interprete.tabla;
Interprete.tabla = new TablaSimbolo();
Interprete.tabla.anterior = getGlobal(aux);
ParseTreeNode nodoMetodo = (ParseTreeNode)metodo.getRaiz();
for (int i = 0; i < nodoMetodo.ChildNodes[1].ChildNodes.Count; i++)
{
Declaracion decla = new Declaracion();
decla.declaracionParametros(nodoMetodo.ChildNodes[1].ChildNodes[i], valores[i]);
}
if (nodoMetodo.Term.Name.Equals("PROCEDIMIENTO"))
{
resultado = interprete.ejecutar(nodoMetodo.ChildNodes[2]);
if (resultado != null)
{
agregarError("Semantico", "Los procedimientos no devuelven ningun valor", raiz.Span.Location.Line, raiz.Span.Location.Column);
resultado = new Resultado("", null);
}
}
else if (nodoMetodo.Term.Name.Equals("FUNCION"))
{
resultado = interprete.ejecutar(nodoMetodo.ChildNodes[3]);
if (resultado == null)
{
agregarError("Semantico", "La funcion " + metodo.nombre + " debe retornar algun valor ", raiz.Span.Location.Line, raiz.Span.Location.Column);
resultado = new Resultado("Error", null);
}
else
if (!resultado.tipo.Equals(metodo.tipoRetorno))
{
agregarError("Semantico", "La funcion " + metodo.nombre + " no es de tipo " + resultado.tipo, raiz.Span.Location.Line, raiz.Span.Location.Column);
resultado = new Resultado("Error", null);
}
}
Interprete.tabla = aux;
}
else
{
agregarError("Semantico", "El metodo " + id + " no existe", raiz.Span.Location.Line, raiz.Span.Location.Column);
}
return(resultado);
//return new Resultado("Error",null);
}
public static object Login(Dictionary <string, object> Parameter)
{
#region Declaración de variables
Resultado Result = new Resultado {
sCode = false
};
Procedimiento ProcedimientoValidar = new Procedimiento();
Paquete Paquete = new Paquete();
#endregion
try
{
objConexion.setNombreConexion("CadenaConexion");
ProcedimientoValidar = new Procedimiento("[dbo].[PA_ValidarLogin]");
ProcedimientoValidar.agregarParametro(new Parametro("@sUsuario", SqlDbType.VarChar, Base64Decode(Parameter["sUsuario"].ToString()), ParameterDirection.Input));
ProcedimientoValidar.agregarParametro(new Parametro("@sPassword", SqlDbType.VarChar, Base64Decode(Parameter["sPassword"].ToString()), ParameterDirection.Input));
Paquete = objConexion.ejecutar(ProcedimientoValidar);
if (!Paquete.Error)
{
if (!Paquete.esVacio())
{
HttpCookie hCookie = HttpContext.Current.Request.Cookies["User"];
if (hCookie == null)
{
hCookie = new HttpCookie("User");
}
hCookie["NombreCompleto"] = Paquete.Datos.Rows[0]["NombreCompleto"].ToString();
hCookie["RolName"] = Paquete.Datos.Rows[0]["RolUsuario"].ToString();
hCookie["Usuario"] = Paquete.Datos.Rows[0]["Usuario"].ToString();
hCookie["IdUsuario"] = Paquete.Datos.Rows[0]["IdUsuario"].ToString();
hCookie["sJsonUsuario"] = JsonConvert.SerializeObject(Paquete.Datos);
HttpContext.Current.Response.Cookies.Add(hCookie);
}
else
{
Result.sCode = true;
Result.sMessage = "Usuario no existe en el sistema...";
}
}
else
{
Result.sCode = true;
Result.sMessage = "Error al validar login...\n" + Paquete.Mensaje;
}
}
catch (Exception ex)
{
Result.sCode = true;
Result.sMessage = "Error al validar login...\n" + ex.Message;
}
return(JsonConvert.SerializeObject(Result));
}
public ActionResult EditarProcedimiento([Bind(Include = "id,nombre,creacion,modificacion")] Procedimiento procedimientos)
{
if (ModelState.IsValid)
{
db.Entry(procedimientos).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Procedimientos"));
}
return(View(procedimientos));
}
public ProcedimientoRegistro(Procedimiento proced)
{
Paciente = proced.Paciente;
Codigo = proced.Codigo;
Procedimiento1 = proced.Procedimiento1;
UbicacionAnatomica = proced.UbicacionAnatomica;
Fecha = proced.Fecha;
Motivo = proced.Motivo;
Detalle = proced.Detalle;
}
public ActionResult Edit([Bind(Include = "Id,Codigo,Nombre,Descripción,IdAutorizacion,ValorAproximado,ValorReal,ValorAsociación,IdTipoTecnologiaSalud")] Procedimiento procedimiento)
{
if (ModelState.IsValid)
{
db.Entry(procedimiento).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.IdTipoTecnologiaSalud = new SelectList(db.TipoTecnologiaSaluds, "Id", "Descripción", procedimiento.IdTipoTecnologiaSalud);
return(View(procedimiento));
}
public async Task <IActionResult> editarProce(int id, string precio, string desc, int idArea)
{
Procedimiento p = new Procedimiento();
p.procedimientoID = id;
p.precio = float.Parse(precio, System.Globalization.CultureInfo.InvariantCulture);
p.procedimiento = desc;
p.areaID = idArea;
return(await procedimientoesController.Edit(id, p));
}
public IHttpActionResult GetProcedimiento(int id)
{
Procedimiento procedimiento = db.Procedimiento.Find(id);
if (procedimiento == null)
{
return(NotFound());
}
return(Ok(procedimiento));
}
public ActionResult Create([Bind(Include = "id,nombre,creacion,modificacion")] Procedimiento procedimientos)
{
if (ModelState.IsValid)
{
db.Procedimientos.Add(procedimientos);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(procedimientos));
}
private void Llenar()
{
Negocios = new Gestor();
Proc = new Procedimiento();
Proc = Negocios.Mostrar_Procedimiento_Unico(Id_Procedimiento);
this.txt_id_procedimiento.Text = Proc.Id_Procedimiento.ToString();
this.txt_descripcion.Text = Proc.Descripcion_Procedimiento;
this.txt_nombre.Text = Proc.Nombre_Procedimiento;
this.lbl_id_procedimiento.Visible = true;
this.txt_id_procedimiento.Visible = true;
}
public async Task <IActionResult> Create([Bind("procedimientoID,procedimiento,precio,areaID")] Procedimiento proc)
{
if (ModelState.IsValid)
{
_context.Add(proc);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["areaID"] = new SelectList(_context.Area, "AreaID", "areaNom", proc.areaID);
return(View(proc));
}
public async Task <ActionResult> Edit([Bind(Include = "Id,Cita,Ambito,Codigo,Finalidad,FechaRealiza")] Procedimiento procedimiento)
{
if (ModelState.IsValid)
{
db.Entry(procedimiento).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.Cita = new SelectList(db.Cita, "Id", "Tipo", procedimiento.Cita);
return(View("/Views/Administrativas/Procedimientos/Edit.cshtml", procedimiento));
}
public bool Update(Procedimiento entity)
{
try
{
DB.ActualizarProcedimiento(entity.Id, entity.ExpedienteId, entity.EmpleadoId, entity.Nombre_Procedimiento, entity.Descripcion);
return(true);
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult CrearProcedimiento([Bind(Include = "id,nombre")] Procedimiento procedimientos)
{
if (ModelState.IsValid)
{
procedimientos.creacion = DateTime.Now;
procedimientos.modificacion = DateTime.Now;
db.Procedimientos.Add(procedimientos);
db.SaveChanges();
return(RedirectToAction("Procedimientos"));
}
return(View(procedimientos));
}
public ActionResult EditarProcedimiento(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Procedimiento procedimientos = db.Procedimientos.Find(id);
if (procedimientos == null)
{
return(HttpNotFound());
}
return(View(procedimientos));
}
public static int?TarifaCliente(int idCliente)
{
var proc = new Procedimiento
{
ListaParametros = new List <ParametroProc>(),
NombreProcedimiento = "Ventas.LeerTarifaCliente"
};
var pp = new ParametroProc("@idCliente", DbType.Int32, idCliente, TTipoParametro.Entrada);
proc.ListaParametros.Add(pp);
var r = Program.ProxyDSW.EjecutarProcedimientoEscalar(proc);
return(r != null ? (int?)r : null);
}
public Procedimiento Insert(Procedimiento entity)
{
try
{
var id = DB.InsertarProcedimiento(entity.ExpedienteId, entity.EmpleadoId, entity.Nombre_Procedimiento, entity.Descripcion).SingleOrDefault().Column1;
var ProcedimientoResult = DB.BuscarProcedimiento(Convert.ToInt32(id)).SingleOrDefault();
var Procedimiento = mapper.Map <BuscarProcedimientoResult, Procedimiento>(ProcedimientoResult);
return(Procedimiento);
}
catch (Exception ex)
{
throw ex;
}
}
public IHttpActionResult DeleteProcedimiento(int id)
{
Procedimiento procedimiento = db.Procedimiento.Find(id);
if (procedimiento == null)
{
return(NotFound());
}
db.Procedimiento.Remove(procedimiento);
db.SaveChanges();
return(Ok(procedimiento));
}
