/// <summary>
/// Inicia sesión para compañía especificada
/// </summary>
/// <param name="id_compania">Id de Compania</param>
/// <returns></returns>
private RetornoOperacion iniciaSesion(int id_compania)
{
// Recuperamos la IP de la máquina del cliente
// Primero comprobamos si se accede desde un proxy
string ipAddress1 = Request.ServerVariables["HTTP_X_FORWARDED_FOR"];
// Acceso desde una máquina particular
string ipAddress2 = Request.ServerVariables["REMOTE_ADDR"];
//Recuperando la ip correspondiente
string ipAddress = Cadena.RegresaElementoNoVacio(ipAddress1, ipAddress2);
//Nombre de dispositivo
string nomDispositivo = Request.ServerVariables["REMOTE_HOST"];
//Recuperando información del navegador
UsuarioSesion.TipoDispositivo tipoDispositivo = Request.Browser.IsMobileDevice ? UsuarioSesion.TipoDispositivo.Portatil : UsuarioSesion.TipoDispositivo.Escritorio;
//Insertamos Sesión del Usuario
RetornoOperacion resultado = UsuarioSesion.IniciaSesion(this._id_usuario, id_compania, tipoDispositivo, ipAddress, nomDispositivo,
this._id_usuario);
//Si se Insertó Sessión
if (resultado.OperacionExitosa)
{
//Instanciamos Usuario Sesión para Asignar al Sesión
using (UsuarioSesion objUsuarioSesion = new UsuarioSesion(resultado.IdRegistro))
{
try
{
//Creando cookie con datos de inicio de sesión
HttpCookie Cookie = new HttpCookie("Login");
//Asignando llave de sesión
Cookie["ID"] = objUsuarioSesion.id_usuario_sesion.ToString();
//Añadiendo cookie
Response.Cookies.Add(Cookie);
}
catch (Exception ex)
{
//Registrando en log de eventos de la aplicacion
Excepcion.RegistraExcepcionEventLog(ConfigurationManager.AppSettings["EventLogSource"], ex);
}
//Inicializamos Variables de Sesión
Pagina.InicializaVariablesSesion();
//Obteniendo Acceso por Defecto
string acceso = TSDK.Base.Cadena.RutaRelativaAAbsoluta("~/Externa/Login.aspx", PerfilSeguridadUsuario.ObtieneAccesoPerfilActivo(objUsuarioSesion.id_usuario)) + "?ustk=" + this._token;
//Validando que exista
if (!acceso.Equals(""))
{
//Redireccionando a forma por Default
Response.Redirect(acceso);
}
}
}
//Devolviendo Resultado Obtenido
return(resultado);
}
public ActionResult Pago(string dni = null)
{
if (Session["usuario"] == null)
{
return(RedirectToAction("../Sesion/Login/"));
}
UsuarioSesion usu = (UsuarioSesion)Session["usuario"];
// OBTIENE EL ID DEL ULTIMO PEDIDO + 1
int id = Autogenerar();
SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["cnFunko"].ConnectionString);
cn.Open();
SqlTransaction tr = cn.BeginTransaction(System.Data.IsolationLevel.Serializable);
try
{
string sql = "insert into tb_pedido (idusu,total,estado) values (@idusu,@monto,@estado)";
SqlCommand cmd = new SqlCommand(sql, cn, tr);
cmd.Parameters.Add("@idusu", SqlDbType.Char, 8).Value = usu.idUsuSesion;
cmd.Parameters.Add("@monto", SqlDbType.Decimal).Value = Monto();
cmd.Parameters.Add("@estado", SqlDbType.Char, 10).Value = "PENDIENTE";
cmd.ExecuteNonQuery();
List <Registro> detalle = (List <Registro>)Session["carrito"];
foreach (Registro it in detalle)
{
cmd = new SqlCommand("insert into tb_detapedido (idpedido,idprodu,precio,cantidad) values (@id,@prod,@pre,@q)", cn, tr);
cmd.Parameters.Add("@id", SqlDbType.Int).Value = id;
cmd.Parameters.Add("@prod", SqlDbType.Char, 8).Value = it.id;
cmd.Parameters.Add("@pre", SqlDbType.Decimal).Value = it.precio;
cmd.Parameters.Add("@q", SqlDbType.Int).Value = it.cantidad;
cmd.ExecuteNonQuery();
}
tr.Commit();
Console.WriteLine("Both records are written to database.");
}
catch (Exception ex)
{
Console.WriteLine("Commit Exception Type: {0}", ex.GetType());
Console.WriteLine(" Message: {0}", ex.Message);
try
{
tr.Rollback();
}
catch (Exception ex2)
{
Console.WriteLine("Rollback Exception Type: {0}", ex2.GetType());
Console.WriteLine(" Message: {0}", ex2.Message);
}
}
finally
{
cn.Close();
Session["carrito"] = null;
Console.WriteLine("FINALLY");
}
return(RedirectToAction("Index"));
}
/// <summary>
/// Método encargado de Inicializar la Forma
/// </summary>
private void inicializaForma()
{
/*TODO: DETERMINAR COMO SE HABILITARÁ O DESHABILITARÁ EL TIMER DE BUSQUEDA DE PENDIENTES*/
//Instanciando usuario
using (Usuario usuario = (Usuario)Session["usuario"])
{
//Si el usuario es el responsable de realizar depósitos
if (usuario.habilitar && usuario.notificaciones.Equals("Si"))
{
//Activando Notificaciones
tmrNotificaciones.Enabled = true;
}
}
//Instanciamos la Sesin del Usuario
using (UsuarioSesion objUsuarioSesion = ((UsuarioSesion)Session["usuario_sesion"]))
{
//Validamos que exista Sesion
if (objUsuarioSesion.id_usuario_sesion > 0)
{
//Refrescamos atributos de la Sesion
objUsuarioSesion.ActualizaUsuarioSesion();
//Inicializamos Valores
inicializamosValores(objUsuarioSesion);
if (tmrNotificaciones.Enabled)
{
//Buscando notificaciones
muestraPendientesUsuario();
}
}
}
}
protected override bool AuthorizeCore(HttpContextBase httpContext)
{
try
{
bool authorized = base.AuthorizeCore(httpContext);
var routeData = httpContext.Request.RequestContext.RouteData;
var controller = routeData.GetRequiredString("controller");
var action = routeData.GetRequiredString("action");
if (Util.Usuario != null)
{
UsuarioSesion userLoged = httpContext.User as UsuarioSesion;
if (PermisosRequeridos.Count > 0)
{
return(userLoged.IsInRole(PermisosRequeridos.Select(x => x.ToString()).ToArray()));
}
else
{
// If doesn't have Required Roles, allow all
return(true);
}
}
else
{
return(false);
}
}
catch
{
return(false);
}
}
public IResponse Autentica(LoginRequest login)
{
var _response = new UsuarioSesion()
{
ErrorCode = 1, ErrorDetail = "Credenciales o Usuario inválido."
};
try
{
using (ExamenDatabase db = new ExamenDatabase())
{
var usuarioDb = db.USUARIOS_W.Where(u => u.USERNAME == login.Usuario).FirstOrDefault();
if (usuarioDb != null)
{
if (usuarioDb.PASSWORD == login.Password)
{
_response = new UsuarioSesion()
{
Rol = usuarioDb.ROLE,
Usuario = usuarioDb.USERNAME,
Nombre = usuarioDb.NOMBRE,
Apellidos = usuarioDb.APELLIDOS
};
}
}
}
}
catch (Exception ex)
{
log.Error("error en autenticacion", ex);
_response.ErrorCode = 2;
_response.ErrorDetail = "Error en conexión";
}
return(_response);
}
/// <summary>
/// Evento Generado al hacer click en cualquier link Opciones
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void OnClick_MenuOpciones(object sender, EventArgs e)
{
//Referenciamos al objeto que disparo el evento
LinkButton boton = (LinkButton)sender;
//De acuerdo al nombre de comando
switch (boton.CommandName)
{
//Cerramos Sesion
case "CerrarSesion":
//Declaramos Objeto Resultante
RetornoOperacion resultado = new RetornoOperacion();
//Instanciamos la Sesion del Usuario
using (UsuarioSesion objUsuarioSesion = ((UsuarioSesion)Session["usuario_sesion"]))
{
//Validamos que exista Sesion
if (objUsuarioSesion.id_usuario_sesion > 0)
{
//Cerramos Sesion en BD
resultado = objUsuarioSesion.TerminarSesion();
//Si se Termino la Sesión correctamnete
if (resultado.OperacionExitosa)
{
//Cerramos Session
Sesion.CierraSesionActual(FormsAuthentication.LoginUrl);
}
}
}
break;
case "CambiaContrasena":
{
//Validando que exista un Evento
if (ClickCambiarContrasena != null)
{
//Iniciando Manejador
OnClickCambiarContrasena(e);
}
break;
}
case "CambiaPerfil":
{
//Validando que exista un Evento
if (ClickCambiaPerfil != null)
{
//Iniciando Manejador
OnClickCambiaPerfil(e);
}
break;
}
}
}
/// <summary>
/// Inicia sesión para compañía especificada
/// </summary>
/// <param name="id_compania">Id de Compania</param>
/// <returns></returns>
private RetornoOperacion iniciaSesion(int id_compania)
{
// Recuperamos la IP de la máquina del cliente
// Primero comprobamos si se accede desde un proxy
string ipAddress1 = Request.ServerVariables["HTTP_X_FORWARDED_FOR"];
// Acceso desde una máquina particular
string ipAddress2 = Request.ServerVariables["REMOTE_ADDR"];
//Recuperando la ip correspondiente
string ipAddress = Cadena.RegresaElementoNoVacio(ipAddress1, ipAddress2);
//Nombre de dispositivo
string nomDispositivo = Request.ServerVariables["REMOTE_HOST"];
//Recuperando información del navegador
UsuarioSesion.TipoDispositivo tipoDispositivo = Request.Browser.IsMobileDevice ? UsuarioSesion.TipoDispositivo.Portatil : UsuarioSesion.TipoDispositivo.Escritorio;
//Insertamos Sesión del Usuario
RetornoOperacion resultado = UsuarioSesion.IniciaSesion(((Usuario)Session["usuario"]).id_usuario, id_compania, tipoDispositivo, ipAddress, nomDispositivo,
((Usuario)Session["usuario"]).id_usuario);
//Si se Insertó Sessión
if (resultado.OperacionExitosa)
{
//Instanciamos Usuario Sesión para Asignar al Sesión
using (UsuarioSesion objUsuarioSesion = new UsuarioSesion(resultado.IdRegistro))
{
//Asignando variable de usuario
Session["usuario_sesion"] = objUsuarioSesion;
try
{
//Creando cookie con datos de inicio de sesión
HttpCookie Cookie = new HttpCookie("Login");
//Asignando llave de sesión
Cookie["ID"] = objUsuarioSesion.id_usuario_sesion.ToString();
//Añadiendo cookie
Response.Cookies.Add(Cookie);
}
catch (Exception ex)
{
//Registrando en log de eventos de la aplicacion
Excepcion.RegistraExcepcionEventLog(ConfigurationManager.AppSettings["EventLogSource"], ex);
}
}
//Inicializamos Variables de Sesión
Pagina.InicializaVariablesSesion();
//Redireccionando a forma por Default
FormsAuthentication.RedirectFromLoginPage(((Usuario)Session["usuario"]).email, false);
}
return(resultado);
}
public override void OnAuthorization(AuthorizationContext filterContext)
{
if (Util.Usuario != null)
{
UsuarioSesion newUser = new UsuarioSesion(Util.Usuario.Login)
{
Usuario = Util.Usuario
};
HttpContext.Current.User = newUser;
}
base.OnAuthorization(filterContext);
}
// GET: Pedidos
#region Index
public ActionResult Index()
{
UsuarioSesion usu = (UsuarioSesion)Session["usuario"];
if (usu.tipo == "CLIENTE")
{
List <tb_pedido> listapedidos = data.tb_pedido.Where(p => p.idusu == usu.idUsuSesion).ToList <tb_pedido>();
return(View(listapedidos));
}
return(View(data.tb_pedido.ToList()));
}
public ActionResult Login(string nomusu, string pass)
{
SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["cnFunko"].ConnectionString);
cn.Open();
if (!ModelState.IsValid)
{
return(View(new tb_usuarios()));
}
try
{
SqlCommand cmd = new SqlCommand("SELECT * FROM tb_usuarios where nomusu = @usu and pass = @pass and estado = 'A'", cn);
cmd.Parameters.AddWithValue("@usu", nomusu);
cmd.Parameters.AddWithValue("@pass", GenerateSHA512String(pass));
SqlDataReader dr = cmd.ExecuteReader();
if (dr.HasRows)
{
if (dr.Read())
{
if (Session["usuario"] != null)
{
Session["usuario"] = null;
}
UsuarioSesion ususesion = new UsuarioSesion();
ususesion.idUsuSesion = dr.GetString(0);
ususesion.nomUsuSesion = dr.GetString(1);
ususesion.tipo = dr.GetString(3);
Session["usuario"] = ususesion;
}
}
else
{
//ViewBag.msg = "Usuario Invalido";
return(View(new tb_usuarios()));
}
}
catch (Exception e)
{
Console.WriteLine("Error: ", e.Message);
}
finally
{
cn.Close();
}
ViewBag.msg = "SI";
return(RedirectToAction("../Funko/Index"));
}
public ActionResult Detalle(int id)
{
UsuarioSesion usu = (UsuarioSesion)Session["usuario"];
string s = data.tb_pedido.Where(p => p.idpedido == id).First().estado;
ViewBag.idpedi = id;
ViewBag.s = s;
ViewBag.tipo = usu.tipo;
List <tb_detapedido> listadetapedi = data.tb_detapedido.Where(pd => pd.idpedido == id).ToList <tb_detapedido>();
return(View(listadetapedi));
}
public List <tb_pedido> Fechas(string fecha1, string fecha2)
{
//if (Session["usuario"] == null)
//{
// return RedirectToAction("Index", "Funko");
//}
ViewBag.usuario = new SelectList(data.tb_usuarios.ToList(), "idusu", "nomusu");
UsuarioSesion usu = (UsuarioSesion)Session["usuario"];
List <tb_pedido> listapedidos = new List <tb_pedido>();
cn.Open();
try
{
string sql = "select idpedido,fecpedido,nomusu,total,p.estado from tb_pedido p join tb_usuarios u on p.idusu=u.idusu where cast(fecpedido as date) between @fecha1 and @fecha2 ";
SqlCommand cmd = new SqlCommand(sql, cn);
cmd.Parameters.AddWithValue("@fecha1", fecha1);
cmd.Parameters.AddWithValue("@fecha2", fecha2);
SqlDataReader dr = cmd.ExecuteReader();
while (dr.Read())
{
tb_pedido p = new tb_pedido();
p.idpedido = dr.GetInt32(0);
p.fecpedido = dr.GetDateTime(1);
p.idusu = dr.GetString(2);
p.total = dr.GetDecimal(3);
p.estado = dr.GetString(4);
listapedidos.Add(p);
}
dr.Close();
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.Message);
}
finally
{
cn.Close();
}
return(listapedidos);
}
public ActionResult Registro(string nomusu, string pass)
{
SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["cnFunko"].ConnectionString);
cn.Open();
if (!ModelState.IsValid)
{
return(View(new tb_usuarios()));
}
try
{
SqlCommand cmd = new SqlCommand("INSERT INTO tb_usuarios(nomusu, pass, tipusu, estado) VALUES(@usu, @pass, @tipo, @estado)", cn);
cmd.Parameters.AddWithValue("@usu", nomusu);
cmd.Parameters.AddWithValue("@pass", GenerateSHA512String(pass));
cmd.Parameters.AddWithValue("@tipo", "CLIENTE");
cmd.Parameters.AddWithValue("@estado", "A");
cmd.ExecuteNonQuery();
SqlCommand cmd2 = new SqlCommand("SELECT idusu,tipusu FROM tb_usuarios order by idusu desc", cn);
SqlDataReader dr = cmd2.ExecuteReader();
if (Session["usuario"] == null)
{
UsuarioSesion ususesion = new UsuarioSesion();
ususesion.idUsuSesion = dr.GetString(0);
ususesion.nomUsuSesion = nomusu;
ususesion.tipo = dr.GetString(1);
Session["usuario"] = ususesion;
}
}
catch (Exception e)
{
Console.WriteLine("Error: ", e.Message);
}
finally
{
cn.Close();
}
return(RedirectToAction("../Funko/Index"));
}
/// <summary>
/// Método encargado de Finalizar la Sesión de un Usuario
/// </summary>
/// <param name="id_usuario_sesion">Sesión de un Usuario</param>
/// <returns></returns>
public string FinalizaSesion(int id_usuario_sesion)
{
//Declarando objeto de retorno
RetornoOperacion result = new RetornoOperacion();
//Instanciamos la Sesion del Usuario
using (UsuarioSesion objUsuarioSesion = new UsuarioSesion(id_usuario_sesion))
{
//Validamos que exista Sesion
if (objUsuarioSesion.id_usuario_sesion > 0)
{
//Cerramos Sesion en BD
result = objUsuarioSesion.TerminarSesion();
}
}
//Devolviendo Resultado Obtenido
return(result.ToXMLString());
}
public static string ObtenerListaUsuarios()
{
JObject Respuesta = new JObject();
CUtilerias.DelegarAccion(delegate(CConexion pConexion, int Error, string Descripcion, CUsuario UsuarioSesion) {
if (Error == 0)
{
JObject Modelo = new JObject();
CUsuario ListaUsuarios = new CUsuario();
Dictionary <string, object> pParametros = new Dictionary <string, object>();
pParametros.Add("Baja", 0);
pParametros.Add("EsAgente", 1);
if (UsuarioSesion.TienePermisos(new String[] { "verActividadesAgentes" }, pConexion) != "")
{
pParametros.Add("IdUsuario", UsuarioSesion.IdUsuario);
}
JArray Usuarios = new JArray();
JObject MiUsuario = new JObject();
MiUsuario.Add("Valor", UsuarioSesion.IdUsuario);
MiUsuario.Add("Descripcion", UsuarioSesion.Nombre + " " + UsuarioSesion.ApellidoPaterno + " " + UsuarioSesion.ApellidoMaterno);
MiUsuario.Add("Selected", " selected");
Usuarios.Add(MiUsuario);
foreach (CUsuario oUsuario in ListaUsuarios.LlenaObjetosFiltros(pParametros, pConexion))
{
if (oUsuario.IdUsuario != UsuarioSesion.IdUsuario)
{
JObject Usuario = new JObject();
Usuario.Add("Valor", oUsuario.IdUsuario);
Usuario.Add("Descripcion", oUsuario.Nombre + " " + oUsuario.ApellidoPaterno + " " + oUsuario.ApellidoMaterno);
Usuario.Add("Selected", "");
Usuarios.Add(Usuario);
}
}
Modelo.Add("Usuarios", Usuarios);
Respuesta.Add("Modelo", Modelo);
}
Respuesta.Add("Error", Error);
Respuesta.Add("Descripcion", Descripcion);
});
return(Respuesta.ToString());
}
/// <summary>
/// Notificación de cierre de sesión
/// </summary>
/// <param name="id_sesion_cerrada">Id de Sesión de Usuario que fue terminada</param>
/// <returns></returns>
public RetornoOperacion NotificacionCierreSesion(int id_sesion_cerrada)
{
//Inicializando retorno
RetornoOperacion resultado = new RetornoOperacion();
//Token del usuario al que se reportará
string tokenFCM = "";
//Instanciando sesión
using (UsuarioSesion sesion = new UsuarioSesion(id_sesion_cerrada))
{
//Validando si se tiene habilitado el uso de apliacación móvil
resultado = CompaniaEmisorReceptor.ValidaConfiguracionUsoAplicacionMovil(sesion.id_compania_emisor_receptor);
if (resultado.OperacionExitosa)
{
//Recuperando referencias de usuario y compañía
using (DataTable mit = Referencia.CargaReferencias(sesion.id_usuario, 30, ReferenciaTipo.ObtieneIdReferenciaTipo(sesion.id_compania_emisor_receptor, 30, "Token FCM", 0, "Configuración")))
tokenFCM = mit != null ? mit.Rows[0]["Valor"].ToString() : "";
//Si se obtuvo el token del usuario correspondiente
if (tokenFCM != "")
{
//Construyendo mensaje
var datos = new
{
Titulo = "¡Sesión Terminada!",
Mensaje = "Vuelva a iniciar sesión en este dispositivo.",
TipoNotificacion = "CierreSesion"
};
//Enviando mensaje vía FCM
resultado = FirebaseCloudNotifications.EnviaMensajeFCM(_url_servidor_fcm, _server_token_fcm, tokenFCM, FirebaseCloudNotifications.Prioridad.Normal, datos);
}
else
{
resultado = new RetornoOperacion("El token del dispositivo del usuario debe ser actualizado.");
}
}
}
//Devolviendo resultado
return(resultado);
}
/// <summary>
/// Método encargado de Actualizar la Ultima Actividad del Usuario
/// </summary>
/// <param name="id_usuario_sesion">Sesión Activa</param>
/// <param name="direccion_mac">Dirección MAC</param>
/// <param name="nombre_dispositivo">Nombre del Dispositivo</param>
/// <returns></returns>
public string ActualizaUltimaActividad(int id_usuario_sesion, string direccion_mac, string nombre_dispositivo)
{
//Declarando Objeto de Retorno
RetornoOperacion result = new RetornoOperacion();
//Instanciando Usuario Sesión
using (UsuarioSesion us = new UsuarioSesion(id_usuario_sesion))
{
//Validando que exista
if (us.habilitar && us.EstatusSesion == UsuarioSesion.Estatus.Activo)
{
//Actualizamos Ultima Actividad
result = us.ActualizaUltimaActividad(direccion_mac, nombre_dispositivo);
}
else
{
//Instanciando Excepción
result = new RetornoOperacion("La Sesión ha Expirado");
}
}
//Devolviendo Resultado Obtenido
return(result.ToXMLString());
}
/// <summary>
/// Inicializamos Valores
/// </summary>
private void inicializamosValores(UsuarioSesion objUsuarioSesion)
{
//Referenciando al usuario de la sesión actual
using (Usuario u = (Usuario)Session["usuario"])
{
//Nombre de Usuario
lkbUsuario.Text = u.nombre;
//Fecha de Inicio de Sesión
lkbInicioSesion.Text = "Inicio Sesión: " + objUsuarioSesion.fecha_inicio.ToString("dd/MM/yyyy HH:mm");
//Obteniendo el perfil de seguridad actual del usuario
SAT_CL.Seguridad.PerfilSeguridadUsuario perfilActivo = SAT_CL.Seguridad.PerfilSeguridadUsuario.ObtienePerfilActivo(u.id_usuario);
using (SAT_CL.Seguridad.PerfilSeguridad perfil = new PerfilSeguridad(perfilActivo.id_perfil))
{
//Perfil
lkbPerfil.Text = string.Format("Perfil: {0}", perfil.descripcion);
}
//Instanciamos Compañia de la sesión actual
using (CompaniaEmisorReceptor objCompania = new CompaniaEmisorReceptor(((UsuarioSesion)Session["usuario_sesion"]).id_compania_emisor_receptor))
{
lkbCompania.Text = "Compañía: " + objCompania.nombre_corto;
}
//Validamos exista dias de Vigencia (0 = Sin vigencia, es permanente)
if (u.dias_vigencia > 0)
{
//Si la vigencia ha caducado
if (DateTime.Today.CompareTo(u.fecha_contrasena.Date.AddDays(u.dias_vigencia)) > 0)
{
//Redireccionamos a pagina Cambio de Contraseña
Response.Redirect("~/CambioContrasena.aspx");
}
}
}
}
public static string ObtenerFormaEditarSolicitudEntregaMaterial(int IdSolicitudMaterial)
{
JObject Respuesta = new JObject();
JObject oPermisos = new JObject();
int puedeEditarSalidaEntregaMaterial = 0;
CUtilerias.DelegarAccion(delegate(CConexion pConexion, int Error, string DescripcionError, CUsuario UsuarioSesion) {
if (Error == 0)
{
JObject Modelo = new JObject();
//Permisos
if (UsuarioSesion.TienePermisos(new string[] { "puedeEditarSalidaEntregaMaterial" }, pConexion) == "")
{
puedeEditarSalidaEntregaMaterial = 1;
}
oPermisos.Add("puedeEditarSalidaEntregaMaterial", puedeEditarSalidaEntregaMaterial);
Modelo.Add("Permisos", oPermisos);
CSolicitudMaterial solicitudMaterial = new CSolicitudMaterial();
solicitudMaterial.LlenaObjeto(IdSolicitudMaterial, pConexion);
Modelo.Add("IdSolicitudMaterial", solicitudMaterial.IdSolicitudMaterial);
Modelo.Add("FechaAlta", Convert.ToString(solicitudMaterial.FechaAlta.ToShortDateString()));
Modelo.Add("Confirmado", solicitudMaterial.Aprobar);
Modelo.Add("Comentarios", solicitudMaterial.Comentarios);
CUsuario solicitante = new CUsuario();
solicitante.LlenaObjeto(solicitudMaterial.IdUsuarioCreador, pConexion);
Modelo.Add("Solicitante", solicitante.Nombre + " " + solicitante.ApellidoPaterno + " " + solicitante.ApellidoMaterno);
COportunidad oportunidad = new COportunidad();
oportunidad.LlenaObjeto(solicitudMaterial.IdOportunidad, pConexion);
CCliente cliente = new CCliente();
cliente.LlenaObjeto(oportunidad.IdCliente, pConexion);
COrganizacion organizacion = new COrganizacion();
organizacion.LlenaObjeto(cliente.IdOrganizacion, pConexion);
Modelo.Add("RazonSocial", organizacion.RazonSocial);
Modelo.Add("RFC", organizacion.RFC);
Modelo.Add("Oportunidad", oportunidad.Oportunidad);
CUsuario agente = new CUsuario();
agente.LlenaObjeto(oportunidad.IdUsuarioCreacion, pConexion);
Modelo.Add("Agente", agente.Nombre + " " + agente.ApellidoPaterno + " " + agente.ApellidoMaterno);
CDivision division = new CDivision();
division.LlenaObjeto(oportunidad.IdDivision, pConexion);
Modelo.Add("Division", division.Division);
Respuesta.Add("Modelo", Modelo);
}
Respuesta.Add("Error", Error);
Respuesta.Add("Descripcion", DescripcionError);
});
return(Respuesta.ToString());
}
/// <summary>
/// Notificación para pedir ubicación actual al dispositivo
/// </summary>
/// <param name="tipo_recurso">Tipo de Recurso</param>
/// <param name="id_recurso">Id de Entidad acorde al tipo indicado</param>
/// <returns></returns>
public RetornoOperacion NotificacionPeticionUbicacion(MovimientoAsignacionRecurso.Tipo tipo_recurso, int id_recurso)
{
//Declrando objeto de resultado
RetornoOperacion resultado = new RetornoOperacion();
//Inicializando variables auxiliares
string tokenFCM = "";
int idCompania = 0;
Usuario usuario = null;
//En base al tipo de recurso
switch (tipo_recurso)
{
case MovimientoAsignacionRecurso.Tipo.Operador:
//Instanciando el recurso
using (Operador op = new Operador(id_recurso))
{
//Guardando id de compañía
idCompania = op.id_compania_emisor;
//Recuperando Usuario correspondiente
usuario = Usuario.ObtieneUsuarioAsignadoOperador(op.id_operador);
}
break;
case MovimientoAsignacionRecurso.Tipo.Unidad:
//Instanciando Unidad
using (Unidad unidad = new Unidad(id_recurso))
{
//recuperando Id de Compañía
idCompania = unidad.id_compania_emisor;
//Instanciando tipo de unidad
using (UnidadTipo tipo = new UnidadTipo(unidad.id_tipo_unidad))
{
//Si la unidad es motriz
if (tipo.bit_motriz)
{
//Determiando la propiedad de unidad
//Si no es propia
if (unidad.bit_no_propia)
{
}
//Si lo es
else
{
//Buscando asignación de operador activa
int idOperador = AsignacionOperadorUnidad.ObtieneOperadorAsignadoAUnidad(id_recurso);
//Recuperando Usuario correspondiente
usuario = Usuario.ObtieneUsuarioAsignadoOperador(idOperador);
}
}
}
}
break;
}
//Si hay compañía y usuario
if (idCompania > 0 && usuario != null)
{
//Validando configuración de notificaciones
resultado = CompaniaEmisorReceptor.ValidaConfiguracionUsoAplicacionMovil(idCompania);
//Si se configuró el uso de aplicación móvil
if (resultado.OperacionExitosa)
{
//Validando sesión activa en algún dispositivo
if (Validacion.ValidaOrigenDatos(UsuarioSesion.ObtieneSesionesActivasUsuario(usuario.id_usuario, UsuarioSesion.TipoDispositivo.Android)))
{
//Recuperando referencia del token de usuario
using (DataTable mit = Referencia.CargaReferencias(usuario.id_usuario, 30, ReferenciaTipo.ObtieneIdReferenciaTipo(idCompania, 30, "Token FCM", 0, "Configuración")))
tokenFCM = mit != null ? mit.Rows[0]["Valor"].ToString() : "";
//Si se obtuvo el token del usuario correspondiente
if (tokenFCM != "")
{
//Armando mensaje de petición
var datos = new
{
Titulo = "Comando de Ubicación",
Mensaje = "N/D",
TipoNotificacion = "Ubicacion"
};
//Enviando mensaje vía FCM
resultado = FirebaseCloudNotifications.EnviaMensajeFCM(_url_servidor_fcm, _server_token_fcm, tokenFCM, FirebaseCloudNotifications.Prioridad.Alta, datos);
}
//Si no hay token
else
{
resultado = new RetornoOperacion("El token del dispositivo del usuario debe ser actualizado.");
}
}
//Si no hay sesión activa
else
{
resultado = new RetornoOperacion("El usuario no cuenta con una sesión activa en dispositivo móvil.");
}
}
}
//Si no hay compañía o usuario
else
{
resultado = new RetornoOperacion("No se localizó la compañía o el usuario asignado al recurso.");
}
//Si el resultado es correcto
if (resultado.OperacionExitosa)
{
resultado = new RetornoOperacion("Petición enviada correctamente, el tiempo de respuesta puede variar de un dispositivo a otro y verse afectado por la calidad de datos móviles.", true);
}
//Devolviendo resultado
return(resultado);
}
/// <summary>
/// Realiza la validación de un usuario y asesión activa en dispositivo móvil
/// </summary>
/// <param name="id_movimiento_asignacion_recurso">Id de Asignación de recurso</param>
/// <param name="id_compania">Id de Compañía donde se encuentra el recurso</param>
/// <param name="token_fcm">Token de Firebase Cloud Messaging</param>
/// <returns></returns>
private RetornoOperacion validaUsuarioSesionActivaRecurso(int id_movimiento_asignacion_recurso, out int id_compania, out int id_recurso, out MovimientoAsignacionRecurso.Tipo tipo_recurso, out string token_fcm)
{
//Inicializando retorno
RetornoOperacion resultado = new RetornoOperacion("Sesión Activa Encontrada.", true);
//Inicializando parámetros de salida
id_compania = id_recurso = 0;
tipo_recurso = MovimientoAsignacionRecurso.Tipo.Operador;
token_fcm = "";
//Instanciando asignación
using (MovimientoAsignacionRecurso asignacion = new MovimientoAsignacionRecurso(id_movimiento_asignacion_recurso))
{
//Definiendo objeto usuario sin asignar
Usuario usuario = null;
//Para el tipo de asignación correspondiente
switch (asignacion.TipoMovimientoAsignacion)
{
case MovimientoAsignacionRecurso.Tipo.Operador:
//Instanciando operador
using (Operador op = new Operador(asignacion.id_recurso_asignado))
{
//Obteniendo usuario en cuestión
usuario = Usuario.ObtieneUsuarioAsignadoOperador(op.id_operador);
id_compania = op.id_compania_emisor;
id_recurso = op.id_operador;
}
break;
case MovimientoAsignacionRecurso.Tipo.Tercero:
//TODO: Implementar obtención de token FCM de dispositivo asignado al tercero
break;
case MovimientoAsignacionRecurso.Tipo.Unidad:
//TODO: Implementar obtención de token FCM de dispositivo asignado a la unidad
break;
}
//Validando existencia de usuario
if (usuario != null)
{
//Validando sesión activa en algún dispositivo
if (Validacion.ValidaOrigenDatos(UsuarioSesion.ObtieneSesionesActivasUsuario(usuario.id_usuario, UsuarioSesion.TipoDispositivo.Android)))
{
//Recuperando referencia del token de usuario
using (DataTable mit = Referencia.CargaReferencias(usuario.id_usuario, 30, ReferenciaTipo.ObtieneIdReferenciaTipo(id_compania, 30, "Token FCM", 0, "Configuración")))
token_fcm = mit != null ? mit.Rows[0]["Valor"].ToString() : "";
//Si no obtuvo el token del usuario correspondiente
if (token_fcm == "")
{
resultado = new RetornoOperacion("El token del dispositivo del usuario debe ser actualizado.");
}
}
//Si no hay sesiones activas
else
{
resultado = new RetornoOperacion("El usuario no cuenta con una sesión activa en dispositivo móvil.");
}
}
//Si no hay un usuario asiciado
else
{
resultado = new RetornoOperacion("No hay un usuario asociado al recurso.");
}
}
//Devolviendo resultado
return(resultado);
}
/// <summary>
/// Validamos Si la Sesión se encuentra activa
/// </summary>
private void validaSesionActiva()
{
//Verificando que exista una sesión de BD en la sesión de ASP
if (Session["usuario_sesion"] == null)
{
//Recuperando la cookie
HttpCookie c = Request.Cookies.Get("Login");
//Instanciando al usuario sesión para cerrar la sesión
using (UsuarioSesion objUsuarioSesion = new UsuarioSesion(Convert.ToInt32(c["ID"])))
{
//Validamos que exista Sesion
if (objUsuarioSesion.id_usuario_sesion > 0)
{
//Cerramos Sesion BD
objUsuarioSesion.TerminarSesion();
}
}
//Cerramos Session desde asp.net
Sesion.CierraSesionActual(FormsAuthentication.LoginUrl);
}
else
{
//Instanciamos Usuario Sesion
using (UsuarioSesion objUsuarioSesion = (UsuarioSesion)Session["usuario_sesion"])
{
//Refresca Atributos
if (objUsuarioSesion.ActualizaUsuarioSesion())
{
//Validando si la sesión ha finalizado
if (objUsuarioSesion.EstatusSesion == UsuarioSesion.Estatus.Activo)
{
//Referenciando al usuario de la sesión actual
using (Usuario u = (Usuario)Session["usuario"])
{
//Actualziando información desde BD
if (u.ActualizaAtributos())
{
//Validando posible cambio de contraseña no reflejado en esta sesión
if (u.fecha_contrasena < objUsuarioSesion.ultima_actividad)
{
//Actualizamos Ultima Actividad
objUsuarioSesion.ActualizaUltimaActividad();
}
//Si la contraseña se modificó
else
{
//Direccionando a página de inicio
Sesion.CierraSesionActual(FormsAuthentication.LoginUrl);
}
}
}
}
else
{
//Direccionando a página de inicio
Sesion.CierraSesionActual(FormsAuthentication.LoginUrl);
}
}
}
}
}
/// <summary>
/// Actualiza el token de dispositivo, asignado para servicios FCM
/// </summary>
/// <param name="id_usuario_sesion">Id de Sesión de Usuario</param>
/// <returns></returns>
private RetornoOperacion actualizaTokenFireBaseCloudMessaging(int id_usuario_sesion, string token)
{
//Declarando objeto de resultado
RetornoOperacion resultado = new RetornoOperacion(id_usuario_sesion);
//Inicializando bloque transaccional
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Instanciando sesión solicitada
using (UsuarioSesion sesion = new UsuarioSesion(id_usuario_sesion))
{
//Validando estatus de sesión
if (sesion.EstatusSesion == UsuarioSesion.Estatus.Activo)
{
//Obteniendo Referencia de token existente para el registro de usuario de la sesión
using (DataTable mitTokenActual = Referencia.CargaReferencias(sesion.id_usuario, 30, ReferenciaTipo.ObtieneIdReferenciaTipo(0, 30, "Token FCM", 0, "Configuración")))
{
//Si existe alguna
if (mitTokenActual != null)
{
//Verificando existencia de esta misma referencia
using (Referencia tokenDuplicado = new Referencia(token, ReferenciaTipo.ObtieneIdReferenciaTipo(sesion.id_compania_emisor_receptor, 30, "Token FCM", 0, "Configuración")))
{
//Si hay alguna existente que no sea la referencia del token actual a editar
if (tokenDuplicado.id_referencia > 0 && tokenDuplicado.id_referencia != Convert.ToInt32(mitTokenActual.Rows[0]["Id"]))
{
//Verificando si está asignado a un usuario con sesiones móviles activas
if (UsuarioSesion.ObtieneSesionesActivasUsuario(tokenDuplicado.id_registro, UsuarioSesion.TipoDispositivo.Android) != null)
{
//Señalando error
resultado = new RetornoOperacion(String.Format("El Token está asignado a una sesión activa de '{0}', cierre la sesión antes de continuar.", new SAT_CL.Seguridad.Usuario(tokenDuplicado.id_registro).nombre));
}
//Si no hay asignación
else
{
//Borrando el token del usuario anterior
resultado = Referencia.EditaReferencia(tokenDuplicado.id_referencia, "", sesion.id_usuario);
}
}
}
//Si no hay errores
if (resultado.OperacionExitosa)
{
//Editando registro previo
resultado = Referencia.EditaReferencia(Convert.ToInt32(mitTokenActual.Rows[0]["Id"]), token, sesion.id_usuario);
}
else
{
resultado = new RetornoOperacion(String.Format("Error al borrar Token anterior: {0}", resultado.Mensaje));
}
}
//Si no existe alguna
else
{
//Insertando nuevo elemento
resultado = Referencia.InsertaReferencia(sesion.id_usuario, 30, ReferenciaTipo.ObtieneIdReferenciaTipo(sesion.id_compania_emisor_receptor, 30, "Token FCM", 0, "Configuración"), token, Fecha.ObtieneFechaEstandarMexicoCentro(), sesion.id_usuario);
}
}
}
//Si la sesión ya no se encuentra activa
else
{
resultado = new RetornoOperacion("La Sesión ha Expirado.");
}
}
//Si no hay errores
if (resultado.OperacionExitosa)
{
scope.Complete();
}
}
//Devolviendo resultado
return(resultado);
}
