public IActionResult Mantenimiento([FromForm] Condicion objCondicion)
{
var jsonResponseDto = new JsonResponseDto();
try
{
var message = (objCondicion.IdCondicion == null) ? Constante.registroExitoso : Constante.actualizacionExitoso;
objCondicion.IdCondicion = (objCondicion.IdCondicion == null) ? "" : objCondicion.IdCondicion;
objCondicion.IdEmpresa = GetEmpresaPadre();
var response = _Condicion.MantenimientoCondicion(objCondicion);
if (response == 1)
{
jsonResponseDto.Type = Constante.Success.ToLower();
jsonResponseDto.IsValid = true;
jsonResponseDto.Mensaje = message;
}
else
{
jsonResponseDto.Type = Constante.Warning.ToLower();
jsonResponseDto.IsValid = false;
jsonResponseDto.Mensaje = Constante.registroError;
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
jsonResponseDto.Type = Constante.Warning.ToLower();
jsonResponseDto.IsValid = false;
jsonResponseDto.Mensaje = ex.Message.ToString();
}
return(Json(jsonResponseDto));
}
public async Task <IActionResult> PutCondicion(int id, Condicion condiciones)
{
if (id != condiciones.idCondicion)
{
return(BadRequest());// si es diferente no da un badrequest
}
_context.Entry(condiciones)
.State = EntityState.Modified; /*indicar al dbcontexr con el entity que lo que hay en condicion
* vamos a realizar una modificacion , las entidad ya tiene las propiedades
* o informacion que vamos a guardar*/
/*el manejo de erro try nos evitará tener problemas a evitar que si hay error que la api no falle*/
try
{
await _context
.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)//esto lo que hara un rollback a la operacion que se esta realizando
{
if (!CondicionExists(id))
{
return(NotFound());
}
else
{
throw;// por si desconocemos el error
}
}
return(NoContent());
}
public ActionResult Edit(Condicion condicion)
{
if (!verificarPermiso(ROLES, (Usuario)Session["usuario"]))
{
return(View(@"~\Views\Shared\AccessDenied.cshtml"));
}
try
{
if (condicion != null)
{
condicionBll.Grabar(condicion);
return(RedirectToAction("Index"));
}
else
{
ViewBag.mensaje = "condicion inexistente";
return(View(condicion));
}
}
catch
{
ViewBag.mensaje = "Error";
return(View());
}
}
public List <Condicion> getAll()
{
List <Condicion> condiciones = new List <Condicion>();
Condicion cond = null;
this.OpenConnection();
try
{
SqlCommand cmdCursos = new SqlCommand("Select * from condiciones", Con);
SqlDataReader drCondicion = cmdCursos.ExecuteReader();
while (drCondicion.Read())
{
cond = new Condicion();
cond.Id = (int)drCondicion["id_condicion"];
cond.Denominacion = (string)drCondicion["condicion"];
condiciones.Add(cond);
}
drCondicion.Close();
}
catch (SqlException Ex)
{
Exception ExcepcionManejada =
new Exception("Error al recuperar las condiciones", Ex);
}
finally
{
this.CloseConnection();
}
return(condiciones);
}
public object ejecutar(Entorno ent, AST arbol)
{
siguiente:
while ((bool)Condicion.getValorImplicito(ent, arbol))
{
// Se crea un entorno local para cada iteracion.
Entorno local = new Entorno(ent);
// Si la condicion del ciclo es verdadera, se procede a ejecutar la lista de instrucciones.
foreach (Instruccion ins in Instrucciones)
{
object result = ins.ejecutar(local, arbol);
if (result != null)
{
// Si existe un Return, se debe de retornar ese valor y conluir la ejecucion del ciclo.
return(result);
}
if (ins is Break)
{
// Si es una sentencia Break, se debe de conluir la ejecucion del ciclo.
return(null);
}
if (ins is Continue)
{
// Si es una sentencia Continue, se debe de pasar a la siguiente iteracion del ciclo.
goto siguiente;
}
}
}
return(null);
}
public Logro(string nombre, string descripcion, Condicion condicion, Movie_Logro movie_logro) {
this.nombre = nombre;
this.descripcion = descripcion;
this.desbloqueado = false;
this.condicion = condicion;
this.movie_logro = movie_logro;
}
public string Existe(Condicion cond)
{
try
{
var sql = "";
var cx = new SqlConnection();
var nombre = "";
var descripcion = "";
var ds = new DataSet();
nombre = cond.Nombre;
descripcion = cond.Descripcion;
sql = "Select * from condiciones where nombre='" + nombre;
var c = new StringConexion();
cx.ConnectionString = c.getCadena();
var da = new SqlDataAdapter(sql, cx);
da.Fill(ds, "Condiciones");
var test = ds.Tables[0].Rows[0][0].ToString();
return "Existe";
}
catch (Exception ex)
{
return "No existe";
}
}
public void Agregar(string key, object valor)
{
Condicion.ValidarParametro(key).IsNotNullOrWhiteSpace("La llave no puede ser nula o vacia.");
Condicion.ValidarParametro(valor).IsNotNull("El valor no puede ser nulo.");
var politica = new CacheItemPolicy();
_objectCache.Add(key, valor, politica);
}
public int MantenimientoCondicion(Condicion objCondicionp)
{
int r = 0;
using (SqlConnection conn = DataContext.GetConnection())
{
var listaParams = new List <SqlParameter>();
listaParams.Add(new SqlParameter("@IdCondicion", SqlDbType.VarChar)
{
Direction = ParameterDirection.Input, Value = objCondicionp.IdCondicion
});
listaParams.Add(new SqlParameter("@Nombre", SqlDbType.VarChar)
{
Direction = ParameterDirection.Input, Value = objCondicionp.Nombre
});
listaParams.Add(new SqlParameter("@IdEstado", SqlDbType.VarChar)
{
Direction = ParameterDirection.Input, Value = objCondicionp.IdEstado
});
listaParams.Add(new SqlParameter("@IdRegimen", SqlDbType.VarChar)
{
Direction = ParameterDirection.Input, Value = objCondicionp.IdRegimen
});
listaParams.Add(new SqlParameter("@IdEmpresa", SqlDbType.VarChar)
{
Direction = ParameterDirection.Input, Value = objCondicionp.IdEmpresa
});
r = SQLHelper.ExecuteNonQuery(conn, System.Data.CommandType.StoredProcedure, @"Sp_CondicionMantenimiento", listaParams.ToArray());
}
return(r);
}
public static bool EvaluarCondicion <T>(T objeto, Condicion condicion, Evaluador <T> evaluador, bool buscarEvaluadorGenerico = true)
{
return(EvaluarCondicion <T>(objeto, condicion, new List <Evaluador <T> >()
{
evaluador
}, buscarEvaluadorGenerico));
}
public void Agregar(string key, object valor, TimeSpan timeout)
{
Condicion.ValidarParametro(key).IsNotNullOrWhiteSpace("La llave no puede ser nula o vacia.");
Condicion.ValidarParametro(valor).IsNotNull("El valor no puede ser nulo.");
_objectCache.Add(key, valor, DateTime.Now.AddMinutes(timeout.Seconds));
}
protected void ValidarClave(string key)
{
int longitudClave = LongitudClave();
Condicion.ValidarParametro(key)
.IsNotNullOrWhiteSpace(Condicion.MensajeValorNulo)
.Evaluate(x => x.Length >= longitudClave, string.Format("La longitud de la clave es incorrecta. Debe ser una clave de {0} digitos.", longitudClave));
}
public ActionResult DeleteConfirmed(int id)
{
Condicion condicion = db.Condiciones.Find(id);
db.Condiciones.Remove(condicion);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public override EnteroSudoku generar(Condicion c, Ficha f)
{
EnteroSudoku entero_sudoku = new EnteroSudoku();
FichaSudoku ficha = (FichaSudoku)f;
return(entero_sudoku);
}
public void Agregar(string key, object valor)
{
Condicion.Requiere(key, "key").IsNotNullOrWhiteSpace("La llave no puede ser nula o vacia.");
Condicion.Requiere(valor, "valor").IsNotNull("El valor no puede ser nulo.");
var politica = new CacheItemPolicy();
_objectCache.Add(key, valor, politica);
}
public En_Validacion(string clase, string propiedad, Condicion condicion, TipoDato tipoDeDato, int tamanioMax, string formato)
{
Clase = clase;
Propiedad = propiedad;
Condicion = condicion;
TipoDeDato = tipoDeDato;
TamanioMax = tamanioMax;
Formato = formato;
}
public object BeforeCall(string operationName, object[] inputs)
{
foreach (var input in inputs)
{
Condicion.ValidarNotacion(input);
}
return(null);
}
public object ejecutar(Entorno ent, AST arbol)
{
if ((bool)(Condicion.getValorImplicito(ent, arbol)))
{
// Si la condicion del if se cumple, entonces ejecuto las instrucciones.
Entorno local = new Entorno(ent);
foreach (NodoAST nodo in Instrucciones)
{
/*
* Por la estructura utilizada, se debe verificar si el nodo es
* una expresion o una instruccion, ya que se manejan de diferente forma.
*/
if (nodo is Instruccion)
{
Instruccion ins = (Instruccion)nodo;
object result = ins.ejecutar(local, arbol);
if (result != null)
{
return(result);
}
}
else if (nodo is Expresion)
{
Expresion expr = (Expresion)nodo;
return(expr.getValorImplicito(local, arbol));
}
}
}
else
{
// Si la condicion del if NO se cumple, entonces ejecuto las instrucciones asociadas al Else.
Entorno local = new Entorno(ent);
foreach (NodoAST nodo in InstruccionesElse)
{
/*
* Por la estructura utilizada, se debe verificar si el nodo es
* una expresion o una instruccion, ya que se manejan de diferente forma.
*/
if (nodo is Instruccion)
{
Instruccion ins = (Instruccion)nodo;
object result = ins.ejecutar(local, arbol);
if (result != null)
{
return(result);
}
}
else if (nodo is Expresion)
{
Expresion expr = (Expresion)nodo;
return(expr.getValorImplicito(local, arbol));
}
}
}
return(null);
}
public ActionResult Edit([Bind(Include = "CondicionId,Descripcion")] Condicion condicion)
{
if (ModelState.IsValid)
{
db.Entry(condicion).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(condicion));
}
static IEnumerable <int> FiltrarY(this IEnumerable <int> numeros, Condicion condicion)
{
foreach (var numero in numeros)
{
if (condicion(numero))
{
yield return(numero);
}
}
}
public async Task <ActionResult <Condicion> > PostCondicion(Condicion condiciones)
{
_context.Condiciones
.Add(condiciones);
await _context
.SaveChangesAsync();
return(CreatedAtAction
("GetCondicion", new { id = condiciones.idCondicion }, condiciones));
}
public bool Remover(string key)
{
Condicion.ValidarParametro(key).IsNotNullOrWhiteSpace("La llave no puede ser nula o vacia.");
if (_objectCache.Contains(key))
{
_objectCache.Remove(key);
return true;
}
return false;
}
public bool Remover(string key)
{
Condicion.Requiere(key, "key").IsNotNullOrWhiteSpace("La llave no puede ser nula o vacia.");
if (_objectCache.Contains(key))
{
_objectCache.Remove(key);
return(true);
}
return(false);
}
public ActionResult Create([Bind(Include = "CondicionId,Descripcion")] Condicion condicion)
{
if (ModelState.IsValid)
{
db.Condiciones.Add(condicion);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(condicion));
}
public override Result GetC3D(Ent e, bool funcion, bool ciclo, bool isObjeto, LinkedList <Error> errores)
{
Result result = new Result();
Result rsVerdadera = Verdadera.GetC3D(e, funcion, ciclo, isObjeto, errores);
Result rsFalsa = Falsa.GetC3D(e, funcion, ciclo, isObjeto, errores);
if (Condicion is Relacional)
{
((Relacional)Condicion).Cortocircuito = true;
}
else if (Condicion is Logica)
{
((Logica)Condicion).Evaluar = true;
}
Result rsCondicion = Condicion.GetC3D(e, funcion, ciclo, isObjeto, errores);
if (rsVerdadera != null && rsFalsa != null && rsCondicion != null)
{
if (Condicion is Literal)
{
rsCondicion.EtiquetaV = NuevaEtiqueta();
rsCondicion.EtiquetaF = NuevaEtiqueta();
rsCondicion.Codigo += "ifFalse (" + rsCondicion.Valor + " == 1) goto " + rsCondicion.EtiquetaV + ";\n";
rsCondicion.Codigo += "goto " + rsCondicion.EtiquetaF + ";\n";
rsCondicion.EtiquetaV += ":\n";
rsCondicion.EtiquetaF += ":\n";
}
if (Condicion is Relacional || Condicion is Literal)
{
string copy = rsCondicion.EtiquetaF;
rsCondicion.EtiquetaF = rsCondicion.EtiquetaV;
rsCondicion.EtiquetaV = copy;
}
string etqSalida = NuevaEtiqueta();
result.Valor = NuevoTemporal();
result.Codigo += rsCondicion.Codigo;
result.Codigo += rsCondicion.EtiquetaV;
result.Codigo += rsVerdadera.Codigo;
result.Codigo += result.Valor + " = " + rsVerdadera.Valor + ";\n";
result.Codigo += "goto " + etqSalida + ";\n";
result.Codigo += rsCondicion.EtiquetaF;
result.Codigo += rsFalsa.Codigo;
result.Codigo += result.Valor + " = " + rsFalsa.Valor + ";\n";
result.Codigo += etqSalida + ":\n";
Tipo = Verdadera.GetTipo();
}
return(result);
}
public object this[string key]
{
get
{
Condicion.ValidarParametro(key).IsNotNullOrWhiteSpace("La llave no puede ser nula o vacia.");
return _objectCache[key];
}
set
{
Condicion.ValidarParametro(key).IsNotNullOrWhiteSpace("La llave no puede ser nula o vacia.");
_objectCache[key] = value;
}
}
public static IEnumerable Filtrar(this IEnumerable a, Condicion condicion)
{
var salida = new Lista();
while (a.Next)
{
if (condicion(a.Current))
{
salida.Agregar(a.Current);
}
}
return(salida);
}
public object this[string key]
{
get
{
Condicion.Requiere(key, "key").IsNotNullOrWhiteSpace("La llave no puede ser nula o vacia.");
return(_objectCache[key]);
}
set
{
Condicion.Requiere(key, "key").IsNotNullOrWhiteSpace("La llave no puede ser nula o vacia.");
_objectCache[key] = value;
}
}
// GET: Condiciones/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Condicion condicion = db.Condiciones.Find(id);
if (condicion == null)
{
return(HttpNotFound());
}
return(View(condicion));
}
/// <summary>
/// Genera el valor hash de un texto
/// </summary>
/// <param name="password">texto</param>
/// <param name="encryptionPrivateKey">llave privada de tamaño 16</param>
/// <returns>Valor hash</returns>
public static string GenerarHash(string password, string encryptionPrivateKey)
{
Condicion.ValidarParametro(encryptionPrivateKey)
.IsNotNullOrWhiteSpace(Condicion.MensajeValorNulo)
.Evaluate(x => x.Length >= 16, "La longitud de la clave es incorrecta. Debe ser una calve de 16 digitos.");
byte[] secretBytes = Encoding.ASCII.GetBytes(encryptionPrivateKey);
using (var hmac = new HMACSHA256(secretBytes))
{
byte[] dataBytes = Encoding.ASCII.GetBytes(password);
byte[] computedHash = hmac.ComputeHash(dataBytes);
return(Convert.ToBase64String(computedHash));
}
}
public ActionResult Create(CondicionModel model)
{
try
{
Condicion condicion = CondicionesFactory.CreateCondicion(model);
condicionesService.Crear(condicion);
return(RedirectToAction("Index"));
}
catch (Exception e)
{
ModelState.AddModelError("", e.Message);
setViewbag();
return(View());
}
}
public InscripcionTipoCondicional(Condicion cond)
: base("Condicional",3)
{
condicion = cond;
}
public void agregarCondicion(Condicion unaCondicion)
{
condiciones.Add(unaCondicion);
}
public string Registrar(Condicion cond)
{
try
{
var sql = "";
var cx = new SqlConnection();
var nombre = "";
var descripcion = "";
var ds = new DataSet();
nombre = cond.Nombre;
descripcion = cond.Descripcion;
sql = "Insert into Condiciones (nombre, descripcion) Values ('" + nombre + "','" + descripcion + "')";
var c = new StringConexion();
cx.ConnectionString = c.getCadena();
var da = new SqlDataAdapter(sql, cx);
da.Fill(ds, "Condiciones");
return "Guardado";
}
catch (Exception ex)
{
return "Error al Guardar";
}
}
