public Respuesta getReportes()
{
try
{
Respuesta respuesta = new Respuesta();
BeanUsuario usuarioActual = new BeanUsuario();
if (HttpContext.Current.Session != null && HttpContext.Current.Session["usuarioActual"] != null)
{
usuarioActual = (BeanUsuario)HttpContext.Current.Session["usuarioActual"];
}
else {
respuesta.idError = "errorUsuarioLogueado";
return respuesta;
}
List<BRReportes.Reporte> _data = new List<BRReportes.Reporte>();
_data = BRReportes.traerReportes(usuarioActual.usuario);
respuesta.reportes = _data;
return respuesta;
}
catch (Exception ex)
{
// logueo el error en bitacora y en ELMATH
BRLoger.LogError(ex);
throw ex;
}
}
public Respuesta agregarGrupo(string descGrupo, int[] idPermisos)
{
try
{
Respuesta _respuesta = new Respuesta();
DataSet ds = BRGrupos.buscarPorNombre(descGrupo);
if (ds.Tables[0].Rows.Count != 0)
{
_respuesta.errorNombreGrupo = true;// "El nombre del grupo ya existe";// poner ID de elemento a mostrar
}
else
{// no existe el nombre lo agrego
int idGrupo = BRGrupos.agregarGrupo(descGrupo);// tomo en id del grupo nuevo
if (idPermisos.Length != 0)
{
for (int i = 0; i < idPermisos.Length; i++)
{
// agregar de a un grupo permiso iterando sobre la coll de grupos
BRGruposPermisos.agregarPermisoAlGrupo(idGrupo, Convert.ToInt32(idPermisos[i]));
}
}
}
return _respuesta;
}
catch (Exception ex)
{
// logueo el error en bitacora y en ELMATH
BRLoger.LogError(ex);
// me voy a mostrar el error
return new Respuesta() { error = ex.Message };
}
}
public List<Respuesta> respuestasPorIDDialogo(int idDialogo)
{
List <Respuesta> listaRespuestas = new List <Respuesta>();
Respuesta respuesta = new Respuesta();
abrirBD ();
string sqlQuery =
"SELECT *"
+"FROM respuesta "
+"WHERE fkPregunta = " + idDialogo;
dbcmd.CommandText = sqlQuery;
IDataReader reader = dbcmd.ExecuteReader ();
while (reader.Read()) {
int idRespuesta = reader.GetInt32 (0);
string answer = reader.GetString (1);
string color = reader.GetString (2);
int esCorrecta=0;
if(!reader.IsDBNull(4)){
esCorrecta= reader.GetInt32(4);}
int fkPregunta = reader.GetInt32 (5);
int fkScript = reader.GetInt32 (6);
int siguientePregunta =(int) reader.GetInt32(7);
Debug.Log ("idRespuesta= " + idRespuesta
+ " respuesta= " + answer
+ " color= " + color
+ " esCorrecta= " + esCorrecta
+ " fkDialogo= " + fkPregunta
+ " fkScript= " + fkScript
+ " fkSiguienteDialogo= " + siguientePregunta
);
respuesta = new Respuesta();
respuesta.idRespuesta = idRespuesta;
respuesta.fkPregunta = idDialogo;
respuesta.respuesta=answer;
respuesta.color=color;
respuesta.esCorrecta=esCorrecta;
respuesta.fkScript=fkScript;
respuesta.siguientePregunta=siguientePregunta;
listaRespuestas.Add(respuesta);
}
reader.Close ();
reader = null;
cerrarBD ();
//Llenado de la entidad
return listaRespuestas;
}
public void accionesRespuestas(Respuesta respuesta)
{
switch (respuesta.fkScript) {
case 1:
{
//Si la respuesta referencia una nueva pregunta
siguientePregunta (respuesta.siguientePregunta);
break;
}
case 2:
{
//Cerrar dialogo
displayDialog = false;
break;
}
}
}
public Respuesta eliminarPoridGrupo(int idGrupo)
{
try
{
int idPermiso = 0;
DataSet dsPermisos = BRPermisos.buscarPorIdGrupo(idGrupo);
if (dsPermisos.Tables[0].Rows.Count != 0)
{
int nCantColumnas = dsPermisos.Tables[0].Rows.Count - 1;
Respuesta _respuesta = new Respuesta();
for (int i = 0; i <= nCantColumnas; i++)
{
idPermiso = Convert.ToInt32(dsPermisos.Tables[0].Rows[i]["id"]);
if (idPermiso == 13 && BRPermisos.esUltimoPermiso(idPermiso))
{
_respuesta.errorABMUsuario = true;
}
else if (idPermiso == 16 && BRPermisos.esUltimoPermiso(idPermiso))
{
_respuesta.errorRestore = true;
}
else if (idPermiso == 17 && BRPermisos.esUltimoPermiso(idPermiso))
{
_respuesta.errorBitacora = true;
}
}// no retono asi q borro el registro
if (_respuesta.errorBitacora || _respuesta.errorABMUsuario || _respuesta.errorRestore)
{
return _respuesta;
}
BRGrupos.eliminarPorIdGrupo(idGrupo);
}
else {
BRGrupos.eliminarPorIdGrupo(idGrupo);
}
return new Respuesta();
}
catch (Exception ex)
{
// logueo el error en bitacora y en ELMATH
BRLoger.LogError(ex);
// me voy a mostrar el error
return new Respuesta() { error = ex.Message };
}
}
public Respuesta altaUsuario(string usuario, string contrasena, string email, List<int> grupos, List<Permiso> permisos)
{
try
{
Respuesta _respuesta = new Respuesta();
// verifico que el usuario NO ESTE INGRESADO
DataSet ds = BRUsuarios.buscarPorUsuario(usuario);
if (ds.Tables[0].Rows.Count != 0)
{
//descError = "El nombre del usuario ya existe en la BD";//
_respuesta.errorNombreUsuario = true;
return _respuesta;
}
else
{
if (!BRUsuarios.enviarMailAlta(usuario, contrasena, email)) { // envio mail al usuario con la contraseña
_respuesta.errorEnviarMail = true;
return _respuesta;
}
int idUsuario = BRUsuarios.altaUsuario(usuario, contrasena, email); // alta del usuario
// agrego los grupos al usuario
foreach (int _idGrupo in grupos)
{
BRUsuarios_Grupos.agregarGrupoAlUsuario(idUsuario, _idGrupo);
}
// agrego los permisos individuales al usuario
foreach (Permiso _permiso in permisos)
{
if (_permiso.individual)
{
BRUsuariosPermisos.agregarPermisoAlUsuario(idUsuario, _permiso.idPermiso, _permiso.bloqueado);
}
}
}
return _respuesta;
}
catch (Exception ex)
{
// logueo el error en bitacora y en ELMATH
BRLoger.LogError(ex);
// me voy a mostrar el error
return new Respuesta() { error = ex.Message };
}
}
private void LblResponder_Click(object sender, EventArgs e)
{
if (txtRespuesta.Text != "")
{
var dialogAnswer = MessageBox.Show("Esta seguro que quiere enviar la respuesta?", "Atencion", MessageBoxButtons.YesNo);
if (dialogAnswer == DialogResult.Yes)
{
//Inserto la respuesta
Respuesta respuestaNueva = new Respuesta();
respuestaNueva.IdPregunta = CurrentPublicationQuestion.ID_Pregunta;
respuestaNueva.Texto = txtRespuesta.Text;
RespuestaPersistance.InsertAnswer(respuestaNueva, null);
CompleteAction = true;
Close();
}
}
else
{
MessageBox.Show("Debe ingresar un texto en la pregunta", "Atención");
}
}
public void guardarRespuesta(int idRespuesta, int idPlayer)
{
List <Respuesta> listaRespuestas = new List <Respuesta>();
Respuesta respuesta = new Respuesta();
abrirBD ();
string sqlQuery =
"SELECT t.idTest, p.idPregunta, r.idRespuesta "
+"FROM respuesta r, pregunta p, test t "
+"WHERE r.fkPregunta = p.idPregunta "
+"AND p.fkTest=t.idTest "
+"AND r.idRespuesta= " + idRespuesta;
dbcmd.CommandText = sqlQuery;
IDataReader reader = dbcmd.ExecuteReader ();
HistorialRespuesta hr = new HistorialRespuesta();
while (reader.Read()) {
int fkTest = reader.GetInt32 (0);
int fkPregunta = reader.GetInt32 (1);
int fkRespuesta = reader.GetInt32 (2);
hr.fkTest=fkTest;
hr.fkPregunta=fkPregunta;
hr.fkRespuesta=fkRespuesta;
hr.fechaYHora = System.DateTime.Now.ToString();
hr.fkPlayer = idPlayer;
}
reader.Close ();
reader = null;
string SQLInsercion = "INSERT INTO historialRespuesta (fkPregunta, fkRespuesta,fkTest, fkPlayer, fechaYHora) "
+"VALUES ("+hr.fkPregunta+","+ hr.fkRespuesta+ ","+ hr.fkTest+"," + hr.fkPlayer+",'"+ hr.fechaYHora+"')";
cerrarBD ();
abrirBD ();
dbcmd.CommandText = SQLInsercion;
dbcmd.ExecuteNonQuery ();
cerrarBD ();
}
public IActionResult AddUser(UsuarioRequest model)
{
Respuesta <object> oRespuesta = new Respuesta <object>();
try
{
using (usuariosContext db = new usuariosContext())
{
Usuarios oUsuarios = new Usuarios();
Usuarios oUsuariosSec = db.Usuarios.Find(model.Cedula);
Usuarios oUsuariosTer = db.Usuarios.Find(model.Correo);
if (oUsuariosSec != null || oUsuariosTer != null)
{
oRespuesta.Exito = 0;
oRespuesta.Mensaje = "El correo o la cedula ya estan registrados en el sistema";
return(Ok(oRespuesta));
}
else
{
oUsuarios.Cedula = model.Cedula;
oUsuarios.Nombre = model.Nombre;
oUsuarios.Apellido = model.Apellido;
oUsuarios.Correo = model.Correo;
oRespuesta.Mensaje = "Usuario Registrado";
db.Usuarios.Add(oUsuarios);
db.SaveChanges();
oRespuesta.Exito = 1;
}
}
}
catch (Exception ex)
{
oRespuesta.Mensaje = ex.Message;
}
oRespuesta.Mensaje = "Proceso Exitoso";
return(Ok(oRespuesta));
}
/// <summary>
/// Metodo encargado de eliminar una persona
/// </summary>
/// <param name="per"></param>
/// <returns></returns>
public Respuesta <Personas> deletePersona(Personas per)
{
Respuesta <Personas> respon = new Respuesta <Personas>();
try
{
using (SqlConnection conn = new SqlConnection(connection.getConnectionString()))
{
////| OP | 0 - insercion / actualizacion | 1 - borrado | 2 - seleccion |
SqlParameter _Op = new SqlParameter("@Op", SqlDbType.Int);
_Op.Value = "1";
SqlParameter _id_persona = new SqlParameter("@id_persona", SqlDbType.Int);
_id_persona.Value = per.id_persona;
SqlParameter[] parametros = { _Op, _id_persona };
DataTable dtTable = connection.correrProcAlmac(parametros, conn, "CV_CrudPersonas");
respon.Operacion = "Deleted";
respon.objeto = dtTable.AsEnumerable().Select(row => new Personas()
{
id_persona = row["id_persona"].ToString(),
Nombres = row["Nombres"].ToString(),
Apellidos = row["Apellidos"].ToString(),
Documento = row["Documento"].ToString(),
email = row["email"].ToString()
}).FirstOrDefault();
return(respon);
}
}
catch (Exception ex)
{
respon.Message = ex.Message;
return(respon);
}
}
// GET: Informe
public ActionResult Index()
{
//Creamos el ViewModel para rellenar los datos
Informe_VM informe_VM = new Informe_VM();
//Creamos una lista que rellenaremos
List <Moneda> listaMonedas = new List <Moneda>();
Respuesta respuesta = Func_Monedas.recuperarListaMonedas(listaMonedas);
//Asignamos la lista al ViewModel
informe_VM.listaMonedas = listaMonedas;
//Creamos una lista que rellenaremos y asignaremos al ViewModel
List <TiposOperaciones> listaTiposOperaciones = new List <TiposOperaciones>();
respuesta = Func_Monedas.recuperarListaTiposOperaciones(listaTiposOperaciones);
informe_VM.listaTipoOperacion = listaTiposOperaciones;
//Rellenamos la lista de operaciones en el ViewModel
List <Operaciones> listaOperaciones = new List <Operaciones>();
respuesta = Func_Monedas.recuperarListaOperaciones(listaOperaciones);
informe_VM.listaOperaciones = listaOperaciones;
List <SelectListItem> listaMovimientos = new List <SelectListItem>();
respuesta = Func_Monedas.recuperarListaMovimientos(listaMovimientos);
informe_VM.listaMovimientos = listaMovimientos;
if (respuesta.tipoRespuesta != TipoRespuesta.OK)
{
return(View("Error"));
}
//Enviamos el ViewModel a la vista con los datos necesarios
return(View(informe_VM));
}
public Task <Respuesta> RevertirConciliacion(long idPlanilla)
{
Respuesta respuesta = new Respuesta();
string _sMessage = string.Empty;
int _iRespuesta = 0;
try
{
//Llama al procedimiento
List <OracleParameter> parameters = new List <OracleParameter>();
_sMessage = string.Empty;
respuesta.Mensaje = _sMessage;
parameters.Add(new OracleParameter("P_ID_PLANILLAS", OracleDbType.Int64, idPlanilla, ParameterDirection.Input));
//Parámetro de Salida
var pResult = new OracleParameter("P_IN_RESPUESTA", OracleDbType.Int32, ParameterDirection.Output);
var pResult1 = new OracleParameter("P_VC_RESPP_IN_RESPUESTAUESTA_MENSAJE", OracleDbType.NVarchar2, 32767, OracleDbType.NVarchar2, ParameterDirection.Output);
parameters.Add(pResult);
parameters.Add(pResult1);
_connectionBase.ExecuteByStoredProcedure("RAC_CONCILIACION.REVERTIR_CONCILIACION", parameters, ConnectionBase.enuTypeDataBase.OracleConciliacion);
_iRespuesta = pResult.Value == null ? -1 : Convert.ToInt32(pResult.Value.ToString());
_sMessage = pResult1.Value == null ? string.Empty : pResult1.Value.ToString();
respuesta.Resultado = _iRespuesta;
respuesta.Mensaje = _sMessage;
}
catch (Exception ex)
{
_sMessage = string.Format("Error: {0}", ex.ToString());
respuesta.Resultado = -1;
respuesta.Mensaje = _sMessage;
}
return(Task.FromResult <Respuesta>(respuesta));
}
public async Task <Respuesta> EditarServicio(Servicio servicioEditado)
{
Respuesta respuesta;
bool yaEditada = await VerificarEdicionDeServicio(servicioEditado);
if (yaEditada)
{
bool yaExiste = await VerificarExistenciaDeServicio(servicioEditado);
if (!yaExiste)
{
var servicioExistente = await ObtenerServicioPorId(servicioEditado.IdServicio);
servicioExistente.Descripcion = servicioEditado.Descripcion;
servicioExistente.Monto = servicioEditado.Monto;
await _repositorioServicio.EditarServicio(servicioExistente);
return(respuesta = new Respuesta {
Ok = true, Mensaje = HelperMensaje.GenerarMensaje(TipoMensaje.Editado, "El servicio")
});
}
else
{
return(respuesta = new Respuesta {
Ok = false, Mensaje = HelperMensaje.GenerarMensaje(TipoMensaje.ErrorYaExiste, "El servicio")
});
}
}
else
{
return(respuesta = new Respuesta {
Ok = false, Mensaje = HelperMensaje.GenerarMensaje(TipoMensaje.ErrorEditar, "")
});
}
}
/// <summary>
/// Método para la obtención de los permisos del usuario logueado.
/// </summary>
/// <param name="par">Parametros de búsqueda.</param>
/// <param name="login">Parametros de tipo OLogin.</param>
/// <returns>Respuesta genérica de tipo OPermisos</returns>
public Respuesta <OPermisos> ObtenerPermisos(OBusquedaParametro par, OLogin login)
{
Respuesta <OPermisos> respuesta = new Respuesta <OPermisos>();
try
{
if (String.IsNullOrEmpty(par.TipoBusqueda.ToString()))
{
throw new ArgumentException(Constantes.PARAMETROVACIOONULO, par.TipoBusqueda.ToString());
}
respuesta = DGestionUsuarios.Instances.ObtenerPermisos(par, login);
}
catch (Exception ex)
{
respuesta.TipoEstatus = TipoEstatus.Error;
respuesta.ListaErrores = new List <string> {
ex.Message
};
_logError = new OLogError
{
codigoError = ex.HResult.ToString(),
error = ex.Message,
evento = "ObtenerPermisos",
formulario = "NGestionUsuarios",
ex = ex,
usuarioID = login.Usuario.UsuarioID,
ipEquipo = login.Usuario.ip
};
//Revisar por que no se ve el "Guardar"
NGestionLogError.Instances.GuardarError(_logError, login);
}
return(respuesta);
}
public String Consultar()
{
Cls_Ctrl_Operaciones Controlador = new Cls_Ctrl_Operaciones();
Respuesta Obj_Respuesta = new Respuesta();
String Json_Resultado = String.Empty;
DataTable Dt_Registros = new DataTable();
try
{
Dt_Registros = Controlador.Consulta_Proveedores(new Cls_Mdl_Proveedor());
if (Dt_Registros != null)
{
Obj_Respuesta.Mensaje = "ok";
Obj_Respuesta.Estatus = true;
var result = from Fila in Dt_Registros.AsEnumerable()
select new[] {
Fila.Field <String>("Nombre").ToString().Trim(),
Fila.Field <String>("Origen") == null ? "" : Fila.Field <String>("Origen").ToString(),
Fila.Field <String>("Telefono") == null ? "" : Fila.Field <String>("Telefono").ToString(),
Fila.Field <String>("Tipo_Proveedor").ToString().Trim(),
Fila.Field <int>("Proveedor_ID").ToString()
};
Obj_Respuesta.data = JsonConvert.SerializeObject(result, Formatting.None);
}
}
catch (Exception Ex)
{
Obj_Respuesta.Estatus = false;
Obj_Respuesta.Mensaje = "Consultar Proveedor [" + Ex.Message + "]";
}
finally
{
Json_Resultado = JsonMapper.ToJson(Obj_Respuesta);
}
return(Json_Resultado);
}
public ActionResult ValidarCodigoRestablecerPassword(string email, string codigo)
{
Respuesta R = new Respuesta();
string emailCode64 = Funcion.ConvertirBase64(email);
bool resultado = Funcion.EmailEsValido(email);
if (!resultado)
{
//Email no valido
R = Funcion.RespuestaProceso("Email_No_Valido", emailCode64, null, email + EngineData.EmailNoValido());
return(Json(R));
}
string code = Metodo.ObtenerCodigoRestablecerPassword(email).Trim();
codigo = codigo.Trim();
resultado = Funcion.CompareString(code, codigo.Trim());
if (!resultado)
{
//El codigo ingresado no coincide
R = Funcion.RespuestaProceso("Codigo_No_Match", emailCode64, Funcion.ConvertirBase64("1E-9R-2R-8O"), email + EngineData.CodigoNoCoincide());
return(Json(R));
}
int act = Metodo.UpdateResetPassword(email, codigo, true);
if (act >= 1)
{
System.Web.HttpContext.Current.Session["Email"] = email;
R = Funcion.RespuestaProceso("Exito", emailCode64, null, "Exito");
}
else
{
//Error al validar el codigo
Funcion.ConstruirSucesoLog("Error al validar codigo*Home/ValidarCodigoRestablecerPassword*" + email, Metodo);
R = Funcion.RespuestaProceso("Error", emailCode64, null, email + EngineData.ErrorInternoServidor());
}
return(Json(R));
}
public Pedido Crear(Pedido pedido)
{
long id;
Respuesta respuesta = new Respuesta();
//string sql = "insert into pedidos (fecha, usuarioId, direccion, estado, total) values (@fecha, @usuarioId, @direccion, @estado, @total)";
string sql = "insert into pedidos (usuarioId, direccion, estado, total) values (@usuarioId, @direccion, @estado, @total)";
using (MySqlConnection conexion = new MySqlConnection(CadenaConexion))
{
conexion.Open();
using (MySqlCommand comando = new MySqlCommand(sql, conexion))
{
//comando.Parameters.Add(new MySqlParameter("@fecha", pedido.Fecha));
comando.Parameters.Add(new MySqlParameter("@usuarioId", pedido.UsuarioId));
comando.Parameters.Add(new MySqlParameter("@direccion", pedido.Direccion));
comando.Parameters.Add(new MySqlParameter("@estado", pedido.Estado));
comando.Parameters.Add(new MySqlParameter("@total", pedido.Total));
id = comando.LastInsertedId;
}
sql = "insert into pedidosDetalle (pedidoId, productoId, cantidad, precio, total) values (@pedidoId, @productoId, @cantidad, @precio, @total)";
foreach (PedidoDetalle detalle in pedido.detalles)
{
using (MySqlCommand comando = new MySqlCommand(sql, conexion))
{
comando.Parameters.Add(new MySqlParameter("@pedidoId", id));
comando.Parameters.Add(new MySqlParameter("@productoId", detalle.ProductoId));
comando.Parameters.Add(new MySqlParameter("@cantidad", detalle.Cantidad));
comando.Parameters.Add(new MySqlParameter("@precio", detalle.Precio));
comando.Parameters.Add(new MySqlParameter("@total", detalle.Total));
comando.ExecuteNonQuery();
}
}
conexion.Close();
return(Obtener((int)id));
}
}
public Respuesta AgregarRegistro(string nombreMedidasProteccion)
{
Respuesta retorno = new Respuesta();
retorno.FueExitosa = false;
retorno.Mensaje = "validando...";
try
{
using (SqlConnection con = new SqlConnection(connectionString))
{
con.Open();
using (SqlCommand command = new SqlCommand(@"INSERT INTO MedidasProteccion VALUES (@pNombreMedidasProteccion)", con))
{
SqlParameter pNombreMedidasProteccion = new SqlParameter("@pNombreMedidasProteccion", SqlDbType.VarChar);
pNombreMedidasProteccion.Value = nombreMedidasProteccion;
command.Parameters.Add(pNombreMedidasProteccion);
int rowsAfected = command.ExecuteNonQuery();
retorno.FueExitosa = true;
retorno.Mensaje = "Registro agregado correctamente";
}
if (con.State == ConnectionState.Open)
{
con.Dispose();
}
}
}
catch (Exception e)
{
retorno.FueExitosa = false;
retorno.Mensaje = "Error en el servidor. Error: " + e.Message;
}
return(retorno);
}
public Respuesta EliminarRegistro(string id)
{
Respuesta retorno = new Respuesta();
retorno.FueExitosa = false;
retorno.Mensaje = "validando...";
try
{
using (SqlConnection con = new SqlConnection(connectionString))
{
con.Open();
using (SqlCommand command = new SqlCommand(@"DELETE MedidasProteccion WHERE Id = @pId", con))
{
SqlParameter pId = new SqlParameter("@pId", SqlDbType.VarChar);
pId.Value = id;
command.Parameters.Add(pId);
command.ExecuteNonQuery();
retorno.FueExitosa = true;
retorno.Mensaje = "Registro eliminado correctamente";
}
if (con.State == ConnectionState.Open)
{
con.Dispose();
}
}
}
catch (Exception e)
{
retorno.FueExitosa = false;
retorno.Mensaje = "Error en el servidor. Error: " + e.Message;
}
return(retorno);
}
public Respuesta CrearRespuesta(Solicitud solicitud)
{
Respuesta respuesta = null;
switch (solicitud.Verbo)
{
case VerbosHttp.GET:
respuesta = CrearRespuestaGET(solicitud);
break;
case VerbosHttp.POST:
respuesta = CrearRespuestaPOST(solicitud);
break;
case VerbosHttp.PUT:
respuesta = CrearRespuestaPUT(solicitud);
break;
case VerbosHttp.DELETE:
respuesta = CrearRespuestaDELETE(solicitud);
break;
case VerbosHttp.OPTIONS:
respuesta = CrearRespuestaOPTIONS(solicitud);
break;
case VerbosHttp.HEAD:
respuesta = CrearRespuestaHEAD(solicitud);
break;
default:
respuesta = CrearRespuestaIncorrecta(solicitud);
break;
}
return(respuesta);
}
static public Respuesta recuperarListaMovimientos(List <SelectListItem> listaMovimientos)
{
Respuesta respuesta = new Respuesta();
respuesta.tipoRespuesta = TipoRespuesta.OK;
listaMovimientos.Add(new SelectListItem {
Value = "0", Text = "Todos"
});
listaMovimientos.Add(new SelectListItem {
Value = "1", Text = "1 semana"
});
listaMovimientos.Add(new SelectListItem {
Value = "2", Text = "2 semanas"
});
listaMovimientos.Add(new SelectListItem {
Value = "3", Text = "3 semanas"
});
listaMovimientos.Add(new SelectListItem {
Value = "4", Text = "1 mes"
});
return(respuesta);
}
static public Respuesta recuperarOperacion(Operaciones operacion, int operacion_pk)
{
SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["connectionstring"].ConnectionString);
Respuesta respuesta = new Respuesta();
respuesta.tipoRespuesta = TipoRespuesta.OK;
Func_Comunes.GuardarLog("Se recuperan la operacion");
string sql = "select * from Operaciones where operacion_pk=" + operacion_pk;
SqlDataAdapter adapt = new SqlDataAdapter(sql, connection);
DataTable datos = new DataTable();
try
{
adapt.Fill(datos);
}
catch (Exception e)
{
respuesta.tipoRespuesta = TipoRespuesta.KO;
respuesta.error = e.Message;
throw;
}
foreach (DataRow row in datos.Rows)
{
operacion.Operacion_PK = (int)row["Operacion_PK"];
operacion.Moneda_PK = (int)row["Moneda_PK"];
operacion.TipoOperacion_PK = (int)row["TipoOperacion_PK"];
operacion.Importe = (decimal)row["Importe"];
operacion.NumMonedas = (decimal)row["NumMonedas"];
operacion.FechaCreacion = (DateTime)row["FechaCreacion"];
operacion.FechaOperacion = (DateTime)row["FechaOperacion"];
}
return(respuesta);
}
public Respuesta Index()
{
Respuesta respuesta = new Respuesta();
respuesta.resultado = 0;
using (MacEntities db = new MacEntities())
{
List <CentroEscuela> centros =
(from centro in db.tbl_centros
join ciudad in db.tbl_ciudades on centro.id_ciudad equals ciudad.id
join estado in db.tbl_estados on ciudad.id equals estado.id
select new CentroEscuela()
{
ciudad = new Ciudad()
{
nombre = ciudad.nombre,
id = 0,
estado = new Estado()
{
id = 0,
pais = new Entidad()
{
id = 0, nombre = ""
},
nombre = estado.nombre
}
},
nombre = centro.nombre,
id = 0
}).ToList();
respuesta.data = centros; respuesta.resultado = 1; respuesta.mensaje = "exito";
}//using
return(respuesta);
}//index
public String Guardar_Excel(String Datos)
{
Cls_Ctrl_Operaciones Controlador = new Cls_Ctrl_Operaciones();
List <Cls_Mdl_Entrada_Mercancia> Lista_Productos = new List <Cls_Mdl_Entrada_Mercancia>();
Cls_Mdl_Entrada_Mercancia Obj_Capturado = new Cls_Mdl_Entrada_Mercancia();
JsonSerializerSettings Configuracion_Json = new JsonSerializerSettings();
Respuesta Obj_Respuesta = new Respuesta();
String Str_Respuesta = String.Empty;
try
{
Lista_Productos = JsonConvert.DeserializeObject <List <Cls_Mdl_Entrada_Mercancia> >(Datos);
foreach (Cls_Mdl_Entrada_Mercancia tabla in Lista_Productos)
{
tabla.Usuario_Registro = Sessiones.Nombre;
}
List <TablaDB> Lista = Lista_Productos.ToList <TablaDB>();
if (Controlador.MasterRegistro(Obj_Capturado, CORE.MODO_DE_CAPTURA.CAPTURA_ALTA, new FiltroBD(Lista, MODO_DE_CAPTURA.CAPTURA_ALTA)))
{
Obj_Respuesta.Estatus = true;
Obj_Respuesta.Mensaje = "Registro exitoso.";
}
}
catch (Exception ex)
{
Obj_Respuesta.Estatus = false;
Obj_Respuesta.Mensaje = "Guardar Cliente[" + ex.Message + "]";
}
finally
{
Str_Respuesta = JsonConvert.SerializeObject(Obj_Respuesta, Formatting.Indented, Configuracion_Json);
}
return(Str_Respuesta);
}
[HttpPost] // Actualiza una asistencia o inserta una observacion
public async Task <ActionResult> EditAtending(int idAsistencia, string dni, bool status, string materia, string observacion, string dniAdm)
{
if (System.Web.HttpContext.Current.Session["User"] == null)
{
return(Json(null));
}
int idCompany = 0;
if (System.Web.HttpContext.Current.Session["IdCompany"] != null)
{
idCompany = Convert.ToInt32(System.Web.HttpContext.Current.Session["IdCompany"]);
}
else
{
return(Json(null));
}
string token = System.Web.HttpContext.Current.Session["AccessToken"].ToString();
string jsonData = Funcion.BuildObservacionAsistencia(idAsistencia, dni, status, materia, observacion, dniAdm, idCompany);
bool resultado = await Proceso.UpdateObservacionAsistencia(jsonData, token, FuncionHttp);
Respuesta respuesta = new Respuesta();
if (resultado)
{
respuesta.Descripcion = "Transaccion Exitosa";
}
else
{
respuesta.Descripcion = "Transaccion Fallida";
}
return(Json(respuesta));
}
public bool Guardar(Respuesta entidad)
{
bool respuesta = false;
try
{
using (var cmd = CreateCommand())
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "usp_Respuesta_Guardar";
cmd.Parameters.AddWithValue("@preguntaid", entidad.PreguntaId);
cmd.Parameters.AddWithValue("@valor", entidad.Valor);
cmd.Parameters.AddWithValue("@descripcion", entidad.Descripcion ?? Convert.DBNull);
respuesta = cmd.ExecuteNonQuery() > 0;
}
return(respuesta);
}
catch (Exception)
{
throw new Exception("Ocurrió un problema al guardar una respuesta.");
}
}
public string GuardarJuego(string valor, int i, int j)
{
bool resultado = false;
try
{
EngineDataGame ValorGame = EngineDataGame.Instance();
string pathArchivo = ValorGame.PathArchivo;
ValorGame.valorIngresado[i, j] = valor;
this.Proceso.GuardarValoresIngresados(pathArchivo, ValorGame.valorIngresado);
this.Proceso.GuardarValoresEliminados(pathArchivo, ValorGame.valorEliminado);
this.Proceso.GuardarValoresInicio(pathArchivo, ValorGame.valorInicio);
this.Proceso.GuardarValoresSolucion(pathArchivo, ValorGame.valorSolucion);
resultado = true;
}
catch { }
Respuesta response = new Respuesta();
response.Status = resultado;
string respuesta = Newtonsoft.Json.JsonConvert.SerializeObject(response);
return(respuesta);
}
public Respuesta <Posicion> GetLocationByVehicle(string sessionId, string company, string branch, string vehicle)
{
try
{
ValidateLoginInfo(sessionId, Securables.WebServiceOperation);
ValidateExpiration(string.Concat("GetLocation[", company, ",", branch, "]"), 60);
var empresa = GetEmpresaByCode(company);
var linea = GetLineaByCode(branch, empresa);
var coche = DAOFactory.CocheDAO.GetList(new[] { empresa.Id }, new[] { linea.Id }).FirstOrDefault(c => c.Interno == vehicle);
if (coche == null)
{
throw new ApplicationException("No se encontro el vehiculo " + vehicle);
}
return(Respuesta <Posicion> .Create(GetPosicion(coche)));
}
catch (Exception ex)
{
return(Respuesta <Posicion> .CreateError(ex.Message));
}
}
public IActionResult Get(int Id)
{
BlazorCrudContext db = new BlazorCrudContext();
Producto producto = db.Productos.Find(Id);
Respuesta oRespuesta = new Respuesta();
try
{
producto = db.Productos.Find(Id);
oRespuesta.Exito = 1;
}
catch (Exception ex)
{
oRespuesta.Mensaje = ex.Message;
}
finally
{
db.Dispose();
}
return(Ok(producto));
}
public Respuesta Sesion([FromBody] Guerrilla guerrilla)
{
Respuesta r = new Respuesta();
string connectionString = Configuration["ConnectionStrings:DefaultConnection"];
using (var connection = new SqlConnection(connectionString))
{
connection.Open();
string sql = $"EXEC sp_Verificar '{guerrilla.correo}'";
using (var command = new SqlCommand(sql, connection))
{
using (var dataReader = command.ExecuteReader())
{
while (dataReader.Read())
{
r.Resultado = dataReader["resultado"].ToString();
}
}
}
connection.Close();
}
return(r);
}
private void btnGuardar_Click(object sender, EventArgs e)
{
Registrar();
if (ValidarDatos())
{
if (usuario.Id > 0)
{
Respuesta respuesta = controlador_orientacion.AgregarRegistro(objRegistro);
if (respuesta.FueExitosa)
{
MessageBox.Show("Registro exitoso");
CargarHistoria();
pnlRegistroNuevo.Enabled = false;
lblMensaje.Text = "Guardado";
}
}
else
{
lblMensaje.Text = "Problema con el usuario consultado no pudo agregarse la agresion";
}
}
}
public IActionResult Edit(CervezaRequest model)
{
Respuesta oRespuesta = new Respuesta();
try
{
using (cdAPIContext db = new cdAPIContext())
{
Cerveza oCerveza = db.Cervezas.Find(model.Id);
oCerveza.Nombre = model.Nombre;
oCerveza.Marca = model.Marca;
oCerveza.Precio = model.Precio;
db.Entry(oCerveza).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
db.SaveChanges();
oRespuesta.Exito = 1;
}
}
catch (Exception ex)
{
oRespuesta.Mensaje = ex.Message;
}
return(Ok(oRespuesta));
}
public IHttpActionResult PostRespuesta(Respuesta Respuesta)
{
Respuesta.Fecha = DateTime.Now;
Respuesta.Activo = true;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Respuestas.Add(Respuesta);
db.SaveChanges();
var RespuestaAdded = db.Respuestas.Where(x => x.Id == Respuesta.Id).Select(x => new RespuestaView
{
Id = x.Id,
IdPregunta = x.IdPregunta,
Fecha = x.Fecha,
Comentario = x.Comentario
}).FirstOrDefault();
return(Ok(RespuestaAdded));
// return CreatedAtRoute("DefaultApi", new { id = Respuesta.Id }, Respuesta);
}
[HttpPost]//insersion de datos a la base Escuela
public IActionResult Add([FromBody] RelacionAlumnoSalon alumno)
{
Respuesta orespuesta = new Respuesta();
try
{
using (escuelaContext db = new escuelaContext())
{
var nuevoAlumno = new Alumno();
nuevoAlumno.Nombre = alumno.nombre;
nuevoAlumno.ApellidoPaterno = alumno.apellidoPaterno;
nuevoAlumno.ApellidoMaterno = alumno.apellidoMaterno;
nuevoAlumno.Telefono = alumno.telefono;
nuevoAlumno.Edad = alumno.edad;
nuevoAlumno.Genero = alumno.genero;
db.Alumno.Add(nuevoAlumno);
db.SaveChanges();
var salon = (from sa in db.Salon where sa.Nombre == alumno.nombreSalon select sa).FirstOrDefault <Salon>();
var nuevoAlumnoSalon = new Alumnosalon();
nuevoAlumnoSalon.AlumnoId = nuevoAlumno.Id;
nuevoAlumnoSalon.SalonId = salon.Id;
nuevoAlumnoSalon.Activo = true;
db.Alumnosalon.Add(nuevoAlumnoSalon);
db.SaveChanges();
orespuesta.Exito = 1;
orespuesta.Data = nuevoAlumno;
}
}
catch (Exception ex)
{
orespuesta.Mensaje = ex.Message;
}
return(Ok(orespuesta));
}
public IActionResult Get(int Id)
{
BlazorCrudContext db = new BlazorCrudContext();
Cerveza cerveza = db.Cervezas.Find(Id);
Respuesta oRespuesta = new Respuesta();
try
{
cerveza = db.Cervezas.Find(Id);
oRespuesta.Exito = 1;
}
catch (Exception ex)
{
oRespuesta.Mensaje = ex.Message;
}
finally
{
db.Dispose();
}
return(Ok(cerveza));
}
public Respuesta ListarLibrosPrestados(string codigo)
{
Respuesta resp;
if (LibroPendienteDAO.ListarLibrosPrestados(codigo).ToList().Count() > 0)
{
resp = new Respuesta()
{
mensaje = "Usted cuenta con libros pendientes por devolver. Por favor, acérquese a la biblioteca.",
flag = 0
};
return(resp);
}
else
{
resp = new Respuesta()
{
mensaje = "El Alumno no tiene devoluciones pendientes.",
flag = 1
};
return(resp);
}
}
public async Task <ActionResult> Create([Bind("Name")] Tarea nuevaTarea)
{
try
{
if (ModelState.IsValid)
{
_logger.LogInformation($"Enviando nueva tareas al servicio");
Peticion <Tarea> peticion = new Peticion <Tarea>(_configuration.GetValue <string>("Api:Tareas:Nueva"))
{
Body = nuevaTarea
};
Respuesta <Tarea> respuesta = await _restClient.PostAsync <Tarea>(peticion);
_logger.LogInformation($"La tarea ha sido creada");
}
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
_logger.LogError(ex, $"No se pudo crear la tarea : ${ex.Message}");
return(View());
}
}
public async Task <IActionResult> EliminarCarrera(int Id)
{
Respuesta respuesta = new Respuesta();
try
{
Carreras carrera = await _carreraService.ObtenerCarreraPorID(Id);
if (carrera == null)
{
respuesta.Mensaje = "No se encuentra ese registro";
return(NotFound(respuesta));
}
await _carreraService.EliminarCarreraAsync(carrera);
respuesta.Exito = 1;
respuesta.Mensaje = "Carrera Eliminada" + carrera.NombreCarrera;
return(Ok(respuesta));
}
catch (System.Exception)
{
return(StatusCode(500, respuesta));
}
}
public Respuesta modiUsuario(int idUsuario, string usuario, string contrasena, string email, List<int> grupos, List<Permiso> permisos, bool bloqueado, bool baja, string motivo)
{
try
{
Respuesta _respuesta = new Respuesta();
// verifico que el usuario LEGUEADO no sea el que se quiere modifciar los permisos
BeanUsuario usuarioActual = new BeanUsuario();
if (HttpContext.Current.Session != null && HttpContext.Current.Session["usuarioActual"] != null)
{
usuarioActual = (BeanUsuario)HttpContext.Current.Session["usuarioActual"];
if (usuarioActual.id == idUsuario)
{
_respuesta.errorMismoUsuario = true;
return _respuesta;
}
}
// verifico que el nombre de usuario no este guardado anteriormente
DataSet ds = BRUsuarios.buscarPorId(idUsuario);
Boolean cambieNombreUsuario = false;
if (ds.Tables[0].Rows.Count != 0)
{
int nCantColumnas = ds.Tables[0].Rows.Count - 1;
for (int j = 0; j <= nCantColumnas; j++)
{
string nombreUsuario = BRSeguridad.desencriptar(Convert.ToString(ds.Tables[0].Rows[j]["usuario"]));
if (nombreUsuario != usuario)
{
ds = BRUsuarios.buscarPorUsuario(usuario);
if (ds.Tables[0].Rows.Count != 0)
{
//descError = "El nombre del usuario ya existe en la BD";//
_respuesta.errorNombreUsuario = true;
return _respuesta;
}
cambieNombreUsuario = true;
}
}
}
// verifico que si cambio el PSW de usuario le envio el mail
if (contrasena != "" ){
if (!BRUsuarios.enviarMailModificar(usuario, contrasena, email)) { // envio mail al usuario con la contraseña
_respuesta.errorEnviarMail = true;
return _respuesta;
}
}
// verifico que si cambio del nombre del usuario y envio el mail
if (cambieNombreUsuario)
{
if (!BRUsuarios.enviarMailModificar(usuario, contrasena, email))
{ // envio mail al usuario con la contraseña
_respuesta.errorEnviarMail = true;
return _respuesta;
}
}
BRUsuarios.modiUsuario(idUsuario, usuario, contrasena, email, bloqueado, baja, motivo); // modifico los datos del usuario
// modifico los permisos independientes al usuario
// primero traigo todos los permisos independientes
DataSet dsPermisosIndBD = BRUsuariosPermisos.buscarPorUsuario(idUsuario);
DataRowCollection drPermisosIndBD = dsPermisosIndBD.Tables[0].Rows;
foreach (Permiso _permiso in permisos)
{
if (_permiso.individual)
{
Boolean existePermiso = false;
if (drPermisosIndBD.Count != 0)
{ // hay permisos asignados en la BD
for (int i = 0; i <= drPermisosIndBD.Count - 1; i++)
{
int idUsuarioPermiso = Convert.ToInt32(drPermisosIndBD[i]["id"]);
int idPermisoBD = Convert.ToInt32(drPermisosIndBD[i]["idPermiso"]);
bool _perBloqueado = (Convert.ToInt32(drPermisosIndBD[i]["negado"]) == 1 ? true : false);
if (idPermisoBD == _permiso.idPermiso)
{ // comparo por id
existePermiso = true;
// lo saco de la coleccion para no evaluarlo de nuevo y dejo la BD como esta
if (_perBloqueado != _permiso.bloqueado)
{ // determina que SOLO TIENE MODIFICADO EL BLOQUEO
BRUsuariosPermisos.modificarBloqueo(idUsuarioPermiso, _permiso.bloqueado);
}
drPermisosIndBD.Remove(drPermisosIndBD[i]);
}
}
}
if (!existePermiso)
{ //es un permiso independiente es NUEVO, lo agrego en la BD
BRUsuariosPermisos.agregarPermisoAlUsuario(idUsuario, _permiso.idPermiso, _permiso.bloqueado);
}
}
}
if (drPermisosIndBD.Count != 0)
{// tiene elementos en la BD asi q lo tengo q borrar
for (int i = 0; i <= drPermisosIndBD.Count - 1; i++)
{
int idUsuarioPermiso = Convert.ToInt32(drPermisosIndBD[i]["id"]);
int idPermisoBD = Convert.ToInt32(drPermisosIndBD[i]["idPermiso"]);
if (idPermisoBD == 13)
{
if (BRPermisos.esUltimoPermiso(idPermisoBD))
{
_respuesta.errorABMUsuario = true;
}
else
{
BRUsuariosPermisos.eliminarPermisoIndependiente(idUsuarioPermiso);// lo borro de la BD
}
}
else if (idPermisoBD == 15)
{
if (BRPermisos.esUltimoPermiso(idPermisoBD))
{
_respuesta.errorBackUp = true;
}
else
{
BRUsuariosPermisos.eliminarPermisoIndependiente(idUsuarioPermiso);// lo borro de la BD
}
}
else if (idPermisoBD == 16)
{
if (BRPermisos.esUltimoPermiso(idPermisoBD))
{
_respuesta.errorRestore = true;
}
else
{
BRUsuariosPermisos.eliminarPermisoIndependiente(idUsuarioPermiso);// lo borro de la BD
}
}
else if (idPermisoBD == 17)
{
if (BRPermisos.esUltimoPermiso(idPermisoBD))
{
_respuesta.errorBitacora = true;
}
else
{
BRUsuariosPermisos.eliminarPermisoIndependiente(idUsuarioPermiso);// lo borro de la BD
}
}
else
{
BRUsuariosPermisos.eliminarPermisoIndependiente(idUsuarioPermiso);// lo borro de la BD
}
}
}
// ahora voy por los grupos
DataSet dsGruposBD = BRGrupos.getGruposPorIdusuario(idUsuario);
DataRowCollection drGruposBD = dsGruposBD.Tables[0].Rows;
foreach (int _idGrupo in grupos)
{
Boolean existeGrupo = false;
if (drGruposBD.Count != 0)
{ // hay grupos asignados en la BD
for (int i = 0; i <= drGruposBD.Count - 1; i++)
{
int idGrupo = Convert.ToInt32(drGruposBD[i]["id"]);
if (idGrupo == _idGrupo)
{ // comparo por id
existeGrupo = true;
// lo saco de la coleccion para no evaluarlo de nuevo y dejo la BD como esta
drGruposBD.Remove(drGruposBD[i]);
}
}
}
if (!existeGrupo)
{ //es un grupo es NUEVO, lo agrego en la BD
BRUsuarios_Grupos.agregarGrupoAlUsuario(idUsuario, _idGrupo);
}
}
// ahora voy por la ELIMINACION DE GRUPOS
if (drGruposBD.Count != 0)
{// tiene elementos en la BD asi q lo tengo q borrar
for (int i = 0; i <= drGruposBD.Count - 1; i++)
{
int idGrupo = Convert.ToInt32(drGruposBD[i]["id"]);
int idUsuarioGrupo = Convert.ToInt32(drGruposBD[i]["idUsuarioGrupo"]);
DataSet dsPermGrupoBD = BRPermisos.buscarPorIdGrupo(idGrupo);
DataRowCollection drPermGrupoBD = dsPermGrupoBD.Tables[0].Rows;
if (drPermGrupoBD.Count != 0)
{ // hay permisos asignados al grupo
Boolean tieneUltimoPermiso = false;
for (int z = 0; z <= drPermGrupoBD.Count - 1; z++)
{
// consulto que no sea el ULTIMO
int idPermisoBD = Convert.ToInt32(drPermGrupoBD[z]["id"]);// id del permiso
if (idPermisoBD == 13)
{
if (BRPermisos.esUltimoPermiso(idPermisoBD))
{
_respuesta.errorABMUsuario = true;
tieneUltimoPermiso = true;
}
}
else if (idPermisoBD == 15)
{
if (BRPermisos.esUltimoPermiso(idPermisoBD))
{
_respuesta.errorRestore = true;
tieneUltimoPermiso = true;
}
}
else if (idPermisoBD == 16)
{
if (BRPermisos.esUltimoPermiso(idPermisoBD))
{
_respuesta.errorRestore = true;
tieneUltimoPermiso = true;
}
}
else if (idPermisoBD == 17)
{
if (BRPermisos.esUltimoPermiso(idPermisoBD))
{
_respuesta.errorBitacora = true;
tieneUltimoPermiso = true;
}
}
}
if (!tieneUltimoPermiso)
{ // Saco al grupo de la BD ya q NO contiene ULTIMOS permisos
BRUsuarios_Grupos.eliminarUsuarios_Grupos(idUsuarioGrupo);
}
}
else
{// es un grupo q no tiene permisos asi q lo saco
BRUsuarios_Grupos.eliminarUsuarios_Grupos(idUsuarioGrupo);
}
}
}
return _respuesta;
}
catch (Exception ex)
{
// logueo el error en bitacora y en ELMATH
BRLoger.LogError(ex);
// me voy a mostrar el error
return new Respuesta() { error = ex.Message };
}
}
public Respuesta modificarGrupo(int idGrupo, string descGrupo, int[] idPermisosCliente)
{
try
{
Respuesta _respuesta = new Respuesta();
//string desc = "";
DataSet ds = BRGrupos.buscarPorNombre(descGrupo);
if (ds.Tables[0].Rows.Count != 0 )
{
if (Convert.ToInt32(ds.Tables[0].Rows[0]["id"]) != idGrupo)
{
//descError = "El nombre del grupo " + descGrupo + " ya existe en la BD";//
_respuesta.errorNombreGrupo = true;
return _respuesta;
}
}
else
{
BRGrupos.modificarGrupo(idGrupo, descGrupo); // modifique el grupo
}
// traigo todos los permisos
DataSet dsPermisos = BRPermisos.buscarPorIdGrupo(idGrupo);
DataRowCollection drPermisosBD = dsPermisos.Tables[0].Rows;
for (int j = 0; j < idPermisosCliente.Length; j++){
Boolean existePermiso = false;
if (drPermisosBD.Count != 0)
{ // hay permisos asignados en la BD
for (int i = 0; i <= drPermisosBD.Count - 1; i++)
{
int idPermisoBD = Convert.ToInt32(drPermisosBD[i]["id"]);
int idPerCliente = Convert.ToInt32(idPermisosCliente[j]);
if (idPermisoBD == idPerCliente) { // comparo por id
existePermiso = true;
// lo saco de la coleccion para no evaluarlo de nuevo y dejo la BD como esta
drPermisosBD.Remove(drPermisosBD[i]);
}
}
}
if (!existePermiso)
{ //es un permiso NUEVO, lo agrego en la BD
// agregar de a un grupo permiso iterando sobre la coll de grupos
BRGruposPermisos.agregarPermisoAlGrupo(idGrupo, Convert.ToInt32(idPermisosCliente[j]));
}
}
if (drPermisosBD.Count != 0)
{// tiene elementos en la BD asi q lo tengo q borrar
for (int i = 0; i <= drPermisosBD.Count - 1; i++){
int idPermiso = Convert.ToInt32(drPermisosBD[i]["id"]);
if (idPermiso == 13 ){
if (BRPermisos.esUltimoPermiso(idPermiso)){
_respuesta.errorABMUsuario = true;
}else{
BRGruposPermisos.eliminarPermisoDelGrupo(idGrupo, idPermiso);// lo borro de la BD
}
}
else if (idPermiso == 16){
if (BRPermisos.esUltimoPermiso(idPermiso)){
_respuesta.errorRestore = true;
}else{
BRGruposPermisos.eliminarPermisoDelGrupo(idGrupo, idPermiso);// lo borro de la BD
}
}
else if (idPermiso == 17){
if (BRPermisos.esUltimoPermiso(idPermiso)){
_respuesta.errorBitacora = true;
}else{
BRGruposPermisos.eliminarPermisoDelGrupo(idGrupo, idPermiso);// lo borro de la BD
}
}else{
BRGruposPermisos.eliminarPermisoDelGrupo(idGrupo, idPermiso);// lo borro de la BD
}
}
}
return _respuesta;
}
catch (Exception ex)
{
// logueo el error en bitacora y en ELMATH
BRLoger.LogError(ex);
// me voy a mostrar el error
return new Respuesta() { error = ex.Message };
}
}
public Respuesta _find(string texto, List<string> lPath, string pathOutput)
{
logger.Info("Find creating obj respuesta");
Respuesta response = new Respuesta();
if (String.IsNullOrEmpty(texto))
{
logger.Info("No se encontro texto a buscar");
response.error = true;
response.mensaje = "Falta especificar el texto a buscar";
return response;
}
try
{
logger.Info("inicializadno boss tools");
bossTools.Documment bossToolsDoccument = new bossTools.Documment();
logger.Info("boss tools searching");
response.filesInfo = bossToolsDoccument.Search(lPath, texto.Trim(), pathOutput);
return response;
}
catch (Exception ex)
{
logger.Error(ex);
response.error = true;
response.mensaje = ex.InnerException + ex.Message + ex.Source + ex.TargetSite;
return response;
}
}
public JsonResult Login(string Usuario, string Contrasena)
{
Respuesta r=new Respuesta();
r.Estado = true;
r.Rol = "admin";
return this.Json(r);
}
public Respuesta CreateRespuesta(int pregunta, string respuesta, int correcto){
var p = new Respuesta{
Pregunta_id = pregunta,
Texto = respuesta,
Correcto = correcto
};
_connection.Insert (p);
return p;
}
