/// <summary>
/// Click en botón quitar de la lista de recursos asignados
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void lkbQuitarRecursoAsignado_Click(object sender, EventArgs e)
{
//Declaramos Objeto Resultado
RetornoOperacion resultado = new RetornoOperacion();
//Validamos que existan Recursos Asignados
if (gvRecursosAsignados.DataKeys.Count > 0)
{
//Seleccionando la fila actual
Controles.SeleccionaFila(gvRecursosAsignados, sender, "lnk", false);
//Instanciamos Asignación
using (MovimientoAsignacionRecurso objMovimientoAsignacionRecurso = new MovimientoAsignacionRecurso
(Convert.ToInt32(gvRecursosAsignados.SelectedDataKey.Value)))
{
//Validamos Deshabilitación de Recursos
resultado = objMovimientoAsignacionRecurso.ValidaDeshabilitacionRecursos();
}
//Si existe asignación ligada
if (!resultado.OperacionExitosa)
{
//Asignamos Mensaje a la ventana Modal
lblMensaje.Text = resultado.Mensaje;
//Ocultando ventana de recursos asignados
alternaVentanaModal("unidadesAsignadas", (LinkButton)sender);
//Mostrando ventana de confirmación para quitar recurso asociado
alternaVentanaModal("confirmacionQuitarRecursos", (LinkButton)sender);
}
else
{
//Deshabilitamos Recurso Asignado
deshabilitaRecurso();
}
}
}
/// <summary>
/// Deshabilita Recurso
/// </summary>
private void deshabilitaRecurso()
{
//Definiendo objeto de resultado
RetornoOperacion resultado = new RetornoOperacion();
//Instanciando la asignación
using (MovimientoAsignacionRecurso r = new MovimientoAsignacionRecurso(Convert.ToInt32(gvRecursosAsignados.SelectedValue)))
//Realizando la deshabilitación
resultado = r.DeshabilitaMovimientosAsignacionesRecurso(((SAT_CL.Seguridad.UsuarioSesion)Session["usuario_sesion"]).id_usuario);
//Si no existe ningún error
if (resultado.OperacionExitosa)
{
//Cargando lista de recursos asignados
cargaRecursosAsignados();
//Actualizamos la consulta de servicios pendientes
cargaServiciosManteniendoSeleccion();
//Actualizamos el grid
upgvServicios.Update();
//Si no hay registros asignados al servicio
if (gvRecursosAsignados.DataKeys.Count == 0)
{
//Ocultando ventana de recursos asignados
alternaVentanaModal("unidadesAsignadas", this);
}
}
//Mostrando resultados
ScriptServer.MuestraNotificacion(this, resultado, ScriptServer.PosicionNotificacion.AbajoDerecha);
}
/// <summary>
/// Valida que la asignación de recurso esté asociada a un movimiento de servicio (NO Movimientos en Vacío)
/// </summary>
/// <param name="id_movimiento_asignacion">Id de Asignación del movimiento</param>
/// <param name="id_servicio">Id de servicio al que pertenece</param>
/// <returns></returns>
private RetornoOperacion validaMovimientoServicio(int id_movimiento_asignacion, out int id_servicio)
{
//Asignando parametros de salida
id_servicio = 0;
//Inicializando resultado sin errores
RetornoOperacion resultado = new RetornoOperacion("Recurso asignado a servicio.", true);
//Instanciando Asignación
using (MovimientoAsignacionRecurso asignacion = new MovimientoAsignacionRecurso(id_movimiento_asignacion))
{
//Cargando movimiento correspondiente
using (Movimiento mov = new Movimiento(asignacion.id_movimiento))
{
//Asignando id de servicio
id_servicio = mov.id_servicio;
//Si el movimiento no es de servicio
if (mov.id_servicio == 0)
{
resultado = new RetornoOperacion("El movimiento de la asignación no corresponde a un servicio.");
}
}
}
//Devolviendo resultado
return(resultado);
}
/// <summary>
/// Inicializamos Controles Movimiento en Vacio
/// </summary>
/// <param name="idCompania">Id Compania del Servicio</param>
/// <param name="idParadaActual">Id Parada Actual</param>
/// <param name="tipoActualizaionFin">Tipo de Actualización Fin de la Estancia (Manual, GPS, APP)</param>
public void InicializaControl(int idCompania, int idParadaActual, Parada.TipoActualizacionLlegada tipoActualizacionLlegada, Parada.TipoActualizacionSalida tipoActualizacionSalida, EstanciaUnidad.TipoActualizacionInicio tipoActuailizacionInicio,
EstanciaUnidad.TipoActualizacionFin tipoActualizaionFin)
{
//Asignamo Atributos
this._id_compania_emisor = idCompania;
this._id_tipo_actualizacion_fin = tipoActualizaionFin;
this._id_parada = idParadaActual;
this._id_ubicacion_origen = 0; //Se actualiza con el Id de Ubicación de la unidad principal del movimiento
//Instanciamos Parada
using (Parada objParada = new Parada(idParadaActual))
{
//Declaramos Variables para la Unidad por modificar ubicación
int id_unidad = 0;
//Asignando Atributos
this._id_servicio = objParada.id_servicio;
//Cargamos la Unidade que se asignarón a la Parada pero se encuentran en una ubicación distinta
MovimientoAsignacionRecurso.CargaRecursoAsignadoAParadaDifUbicacion(idParadaActual, objParada.id_ubicacion, out id_unidad, out this._id_ubicacion_origen);
//Instanciamos Unidad
using (SAT_CL.Global.Unidad objUnidad = new SAT_CL.Global.Unidad(id_unidad))
{
//Si existe unidad a mover
if (objUnidad.id_unidad > 0)
{
//Instanciamos Tipo de Unidad
using (SAT_CL.Global.UnidadTipo objUnidadTipo = new SAT_CL.Global.UnidadTipo(objUnidad.id_tipo_unidad))
{
//Cargamos Catalogos
cargaCatalogos(this._id_ubicacion_origen);
//Validamos Tipo de Unidad para Inicializar y habilitar Controles
if (objUnidadTipo.bit_motriz == true)
{
//Inicializamos Controles
inicializaValoresUnidad(objUnidad.id_unidad);
//Habilitamos Controles
habilitarControlesUnidad();
}
else
{
//Inicializamos Controles
inicializaValoresRemolque(objUnidad.id_unidad);
//Habilitamos Controles
habilitaControlesRemolque();
}
}
}
else
{
//Inicializamos Controles
inicializaValores();
//Habilitamos Controles
habilitarControles();
}
}
}
}
/// <summary>
/// Edita la Fecha de Termino del Movimiento
/// </summary>
/// <param name="fecha_termino">Fecha de termino del movimiento / Inicio de la Estancia</param>
/// <param name="tipo_llegada">Tipo actualización de la fecha de llegada de la parada</param>
/// <param name="tipo_actualizacion_inicio">Tipo actualización de la fecha de inicio de la estancia</param>
/// <param name="id_usuario">Id Usuario actualiza</param>
/// <returns></returns>
public RetornoOperacion EditaFechaTerminoMovimiento(DateTime fecha_termino, Parada.TipoActualizacionLlegada tipo_llegada, EstanciaUnidad.TipoActualizacionInicio tipo_actualizacion_inicio, int id_usuario)
{
//Declarando objeto de retorno
RetornoOperacion resultado = new RetornoOperacion();
//Validando estatus actual del movimiento
if (this.EstatusMovimiento == Estatus.Terminado)
{
//Iniciando transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Validando que las unidades involucradas se encuentren:
//Asociadas aún al servicio y en estatus ocupado
//Disponibles en la ubicación de fin del movimiento y sin ningún movimiento asignado
resultado = MovimientoAsignacionRecurso.ValidaRecursosParaReversaTerminaMovimiento(this._id_movimiento);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Validamos que no existan pagos ligados al movimeinto
resultado = validaPagos();
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Actualizamos la fecha de llegada de las Estancias
resultado = EstanciaUnidad.EditaEstanciasUnidadFechaInicio(this._id_parada_destino, fecha_termino, tipo_actualizacion_inicio, id_usuario);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Instanciamos Parada destino
using (Parada objParadaDestino = new Parada(this._id_parada_destino))
{
//Editamos fecha de llegada de la parada
resultado = objParadaDestino.EditaFechaLlegadaParada(fecha_termino, tipo_llegada, 0, id_usuario);
}
}
}
}
}
}
//Devolvemos Resultado
return(resultado);
}
/// <summary>
/// Realiza la actualización de la parada, fecha y recursos finales del servicio
/// </summary>
/// <param name="id_parada_destino">Id de parada de destino</param>
/// <param name="fecha_fin">Fecha de Fin de la parada</param>
/// <param name="id_usuario">Id de Usuario</param>
/// <returns></returns>
public RetornoOperacion ActualizaParadaDestinoServicio(int id_parada_destino, DateTime fecha_fin, int id_usuario)
{
//Declarando variables auxiliareas para obtencion de recursos principales del servicio
int id_motriz_principal = 0, id_arrastre_1 = 0, id_arrastre_2 = 0, id_tercero = 0;
//Obtenemos Unidades de Arratre Principales
MovimientoAsignacionRecurso.ObtieneRecursoArrastrePrincipalServicio(this._id_servicio, out id_arrastre_1, out id_arrastre_2);
//Motriz
id_motriz_principal = MovimientoAsignacionRecurso.ObtieneRecursoPrincipalServicio(this._id_servicio, MovimientoAsignacionRecurso.Tipo.Unidad, 1);
//Tercero
id_tercero = MovimientoAsignacionRecurso.ObtieneRecursoPrincipalServicio(this._id_servicio, MovimientoAsignacionRecurso.Tipo.Tercero, 0);
//Actualizando y devolviendo resultado
return(editaServicioDespacho(this._id_servicio, this._fecha_inicio, fecha_fin, this._id_parada_origen,
id_parada_destino, this._id_parada_carga_inicio, id_parada_destino, this._kms_asignados,
this._kms_recorridos, this._kms_cargado_recorridos, this._kms_vacio_recorridos,
this._kms_tronco_recorridos, id_motriz_principal, id_arrastre_1, id_arrastre_2,
id_tercero, id_usuario, this._habilitar));
}
/// <summary>
/// Método encargado de Reversa el Inicio de un Movimiento Vacio
/// </summary>
/// <param name="mitEstanciasOrigen">Estancias Origen</param>
/// <param name="estatus">Estatus de la Asignación que se desea editar</param>
/// <param name="id_usuario">Id Usuario</param>
/// <returns></returns>
private RetornoOperacion ReversaInicioMovimietoVacio(DataTable mitEstanciasOrigen, MovimientoAsignacionRecurso.Estatus estatus, int id_usuario)
{
//Declaramos objeto Retorno
RetornoOperacion resultado = new RetornoOperacion(0);
//Iniciando transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Instanciamos la Parada Origen
using (Parada objParadaOrigen = new Parada(this._id_parada_origen))
{
//Localizando parada comodín de la ubicación origen
int id_parada_origen = Parada.ObtieneParadaComodinUbicacion(objParadaOrigen.id_ubicacion, true, id_usuario);
//Validamos existencia de Parada Comodin
if (id_parada_origen > 0)
{
//Iniciamos Estancias de la parada origen del servicio
resultado = EstanciaUnidad.IniciaEstanciasTerminadasParada(this._id_parada_origen, id_usuario);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Actuakizamos Kilometraje de las Unidades de Movimiento
resultado = MovimientoAsignacionRecurso.ActualizaKilometrajeUnidadesMovimiento(this._id_movimiento, -this._kms, id_usuario);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Actualizando estatus de recursos asignados a Disponibles
resultado = MovimientoAsignacionRecurso.ActualizaEstatusRecursosTerminadosADisponible(this._id_movimiento, id_parada_origen, objParadaOrigen.fecha_llegada, estatus, id_usuario);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Deshabilita Asignaciones
resultado = MovimientoAsignacionRecurso.DeshabilitaMovimientosAsignacionesRecursosVacio(this._id_movimiento, id_usuario);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Recuperando los Id de Recurso de las Unidades
List <int> unidades = (from DataRow r in mitEstanciasOrigen.Rows
select r.Field <int>("IdRecurso")).DefaultIfEmpty().ToList();
//Cambiamos el Id de Parada de las Estrancias
resultado = EstanciaUnidad.CambiaParadaEstanciaUnidadesUbicacion(unidades, id_parada_origen, objParadaOrigen.id_ubicacion, id_usuario);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Deshabilitamos Parada Origen
resultado = objParadaOrigen.DeshabilitaParada(id_usuario);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Validamos Deshabilitación de Movimiento
resultado = this.editaMovimiento(this._id_servicio, this._id_segmento_carga, this._secuencia_servicio, (Estatus)this._id_estatus_movimiento, (Tipo)this._id_tipo_movimiento
, this._kms, this._kms_maps, this._id_compania_emisor, this._id_parada_origen, this._id_parada_destino, id_usuario, false);
}
}
}
}
}
else
{
//Mostramos Mensaje Error
resultado = new RetornoOperacion(string.Format("Error al actualizar kilometraje de unidades asociadas: {0}", resultado.Mensaje));
}
}
}
else
{
//Mostramos Mensaje Error
resultado = new RetornoOperacion("No se encontró datos complementarios de la parada comodin.");
}
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Validamos resultado
scope.Complete();
}
}
//Devolvemos Valor
return(resultado);
}
/// <summary>
/// Mètodo encargado de validar pagos ligados al movimiento
/// </summary>
/// <returns></returns>
private RetornoOperacion validaPagos()
{
//Declaramos objeto retorno
RetornoOperacion resultado = new RetornoOperacion(0);
//Obtenemos Asignaciones Liquidadas
using (DataTable mitAsignaciones = MovimientoAsignacionRecurso.CargaAsignacionesLiquidadas(this._id_movimiento))
{
//Validamos Asignaciones
if (Validacion.ValidaOrigenDatos(mitAsignaciones))
{
//Recorremos cada una de las asignaciones liquidadas
foreach (DataRow r in mitAsignaciones.Rows)
{
//Intsanciamos Asignación
using (MovimientoAsignacionRecurso objAsignacion = new MovimientoAsignacionRecurso(r.Field <int>("Id")))
{
//De acuerdo al tipo de asignación
switch ((MovimientoAsignacionRecurso.Tipo)(objAsignacion.id_tipo_asignacion))
{
//Si es Operador
case MovimientoAsignacionRecurso.Tipo.Operador:
//Instanciamos Operador
using (Operador objOperador = new Operador(objAsignacion.id_recurso_asignado))
{
//establecemos mensaje error
resultado = new RetornoOperacion("La asignación del operador " + objOperador.nombre + " se encuentra liquidada.");
}
break;
//Si es tercero
case MovimientoAsignacionRecurso.Tipo.Tercero:
//Instanciamos Tercero
using (CompaniaEmisorReceptor objCompania = new CompaniaEmisorReceptor(objAsignacion.id_recurso_asignado))
{
//establecemos mensaje error
resultado = new RetornoOperacion("La asignación del Tercero " + objCompania.nombre_corto + " se encuentra liquidada.");
}
break;
//Si es Unidad
case MovimientoAsignacionRecurso.Tipo.Unidad:
//Instanciamos Unidad
using (Unidad objUnidad = new Unidad(objAsignacion.id_recurso_asignado))
{
//establecemos mensaje error
resultado = new RetornoOperacion("La asignación de la unidad " + objUnidad.numero_unidad + " se encuentra liquidada.");
}
break;
}
}
}
}
//Validamos si existen pagos
else if (PagoMovimiento.ValidaPagoMovimiento(this._id_movimiento))
{
//Establecemos Mensaje Error
resultado = new RetornoOperacion("Existen pagos ligados al movimiento.");
}
}
//Retornamos resultado
return(resultado);
}
/// <summary>
/// Realiza las acciones necesarias para la reversa en la actualización de fin de movimiento: elimina estancias, inicia asignaciones del movimiento, elimina asignaciones copiadas al movimiento siguiente (en caso de existir), los recursos se colocan en estatus tránsito, se resta el kilometraje del movimiento en el despacho de su servicio y el movimiento se coloca como iniciado
/// </summary>
/// <param name="id_usuario">Id de Usuario que actualiza</param>
/// <returns></returns>
public RetornoOperacion ReversaTerminaMovimientoVacio(int id_usuario)
{
//Declarando objeto de retorno
RetornoOperacion resultado = new RetornoOperacion("El movimiento debe estar en estatus Terminado");
//Validando estatus actual del movimiento
if (this.EstatusMovimiento == Estatus.Terminado)
{
//Iniciando transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Validando que las unidades involucradas se encuentren:
//Asociadas aún al servicio y en estatus ocupado
//Disponibles en la ubicación de fin del movimiento y sin ningún movimiento asignado
resultado = MovimientoAsignacionRecurso.ValidaRecursosParaReversaTerminaMovimiento(this._id_movimiento);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Validamos que no existan pagos ligados al movimeinto
resultado = validaPagos();
//Si es válido realizar la reversa
if (resultado.OperacionExitosa)
{
//Actualziando el kilometraje de las unidades involucradas
resultado = MovimientoAsignacionRecurso.ActualizaKilometrajeUnidadesMovimiento(this._id_movimiento, -this._kms, id_usuario);
//Si no hubo errores
if (resultado.OperacionExitosa)
{
//instanciando parad de origen
using (Parada paradaOrigen = new Parada(this._id_parada_origen))
{
//Si la parada se encontró
if (paradaOrigen.habilitar)
{
//Eliminando estancias creadas para dichos recursos
resultado = EstanciaUnidad.DeshabilitaEstanciaUnidadesReversaFinMovimiento(this._id_movimiento, paradaOrigen.fecha_salida, id_usuario);
}
else
{
resultado = new RetornoOperacion("No fue localizada la información de la parada de origen.");
}
}
//Si no hubo errores
if (resultado.OperacionExitosa)
{
//Actualziando estatus de movimiento a iniciado
resultado = ActualizaEstatusMovimiento(Estatus.Iniciado, id_usuario);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Instanciamos Parada Destino
using (Parada objParadaDestino = new Parada(this._id_parada_destino))
//Editamos Pararda
resultado = objParadaDestino.CambiaParadaARegistrada(id_usuario);
}
else
{
resultado = new RetornoOperacion("No fue posible actualizar el estatus del movimiento.");
}
}
}
else
{
resultado = new RetornoOperacion(string.Format("Error al actualizar kilometraje de unidades involucradas: {0}", resultado.Mensaje));
}
}
}
//Si no hay errores
if (resultado.OperacionExitosa)
{
//Terminando transacción
scope.Complete();
}
}
}
//Devolviendo resultado
return(resultado);
}
/// <summary>
/// Deshabilita un Movimiento en Vacio
/// </summary>
/// <param name="id_usuario">Id Usuario</param>
/// <returns></returns>
public RetornoOperacion DeshabilitaMovimientoVacioTerminado(int id_usuario)
{
//Declaramos objeto resultado
RetornoOperacion resultado = new RetornoOperacion("El movimiento debe estar en estatus Terminado");
//Validando estatus actual del movimiento
if (this.EstatusMovimiento == Estatus.Terminado)
{
//Iniciando transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Instanciamos la Parada Origen
using (Parada objParadaOrigen = new Parada(this._id_parada_origen), objParadadDestino = new Parada(this._id_parada_destino))
{
//Cargamos Estancias ligadas a un Id Movimiento en Estatus Terminado
using (DataTable mitEstanciasOrigen = EstanciaUnidad.CargaEstanciasTerminadasParada(this._id_parada_origen))
{
//Validando que las unidades involucradas se encuentren:
//Asociadas aún al servicio y en estatus ocupado
//Disponibles en la ubicación de fin del movimiento y sin ningún movimiento asignado
resultado = MovimientoAsignacionRecurso.ValidaRecursosParaReversaTerminaMovimiento(this._id_movimiento);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Validamos que no existan pagos ligados al movimeinto
resultado = validaPagos();
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Deshabilitamos Estancias
resultado = EstanciaUnidad.DeshabilitaEstanciaUnidadesMovimientoVacio(this._id_movimiento, this._id_parada_destino, id_usuario);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Deshabilitamos Parada Destino
resultado = objParadadDestino.DeshabilitaParada(id_usuario);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Reversa los movimientos de la Parada Origen
resultado = ReversaInicioMovimietoVacio(mitEstanciasOrigen, MovimientoAsignacionRecurso.Estatus.Terminado, id_usuario);
}
}
}
}
}
}
//Si no hay errores
if (resultado.OperacionExitosa)
{
//Terminando transacción
scope.Complete();
}
}
}
else
{
//Establecemos Mesnaje Error
resultado = new RetornoOperacion("El estatus del movimiento no permite su eliminación");
}
//Devolvemos resultado
return(resultado);
}
/// <summary>
/// Notificación de un nuevo servicio asignado (nueva asignación a movimiento)
/// </summary>
/// <param name="id_movimiento_asignacion_recurso">Id de Asignación de recurso</param>
/// <returns></returns>
public RetornoOperacion NuevoServicioAsignado(int id_movimiento_asignacion_recurso)
{
//Inicializando variables auxiliares
string tokenFCM = "";
int idCompania = 0, idRecurso = 0;
MovimientoAsignacionRecurso.Tipo tipoRecurso = MovimientoAsignacionRecurso.Tipo.Operador;
//Validando que la asignación pertenezca a un servicio
RetornoOperacion resultado = validaMovimientoServicio(id_movimiento_asignacion_recurso);
//Si es de un servicio
if (resultado.OperacionExitosa)
{
//Validando asignación del recurso y obtención de token al que se enviará la notificación
resultado = validaUsuarioSesionActivaRecurso(id_movimiento_asignacion_recurso, out idCompania, out idRecurso, out tipoRecurso, out tokenFCM);
//Si hay datos suficientes
if (resultado.OperacionExitosa)
{
//Validando configuración de notificaciones
resultado = CompaniaEmisorReceptor.ValidaConfiguracionUsoAplicacionMovil(idCompania);
//Si hay datos suficientes
if (resultado.OperacionExitosa)
{
//Inicializando asignaciones totales
int totalAsignaciones = 0;
DateTime cita_inicio = Fecha.ObtieneFechaEstandarMexicoCentro();
//Recuperando asignaciones totales de servicio al usuario
using (DataTable mit = MovimientoAsignacionRecurso.CargaServiciosAsignadosAlRecurso(tipoRecurso, idRecurso, false))
{
//Si hay asignaciones
if (mit != null)
{
totalAsignaciones = mit.Rows.Count;
cita_inicio = Convert.ToDateTime(mit.Rows[0]["CitaOrigen"]);
}
}
//Si hay asignaciones
if (totalAsignaciones > 0)
{
//Definiendo datos del mensaje de la notificación (si hay mas de una asignación, se considera como notificación de baja prioridad dado que existe otra en curso)
var datos = new
{
Titulo = "¡Nuevo viaje asignado!",
Mensaje = String.Format(totalAsignaciones > 1 ? "Se ha añadido un viaje a la lista de pendientes." : "Inicia el '{0:dd-MM-yyyy HH:mm}'", cita_inicio),
TipoNotificacion = totalAsignaciones > 1 ? "NAsignacion" : "NAsignacionActivo"
};
//Enviando mensaje vía FCM
resultado = FirebaseCloudNotifications.EnviaMensajeFCM(_url_servidor_fcm, _server_token_fcm, tokenFCM, FirebaseCloudNotifications.Prioridad.Normal, datos);
}
//Si no hay asignaciones
else
{
resultado = new RetornoOperacion("No se pudo obtener el total de asignaciones.");
}
}
}
}
//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>
/// Notificación de asignación eliminada
/// </summary>
/// <param name="id_movimiento_asignacion_recurso">Id de Asignanción de Recurso</param>
/// <param name="viaje_activo">True para indicar que la asignación correspondia al viaje inmediato siguiente, de lo contrario false</param>
/// <returns></returns>
public RetornoOperacion EliminaAsignacionServicio(int id_movimiento_asignacion_recurso, bool viaje_activo)
{
//Inicializando variables auxiliares
string tokenFCM = "";
int idCompania = 0, idRecurso = 0;
MovimientoAsignacionRecurso.Tipo tipoRecurso = MovimientoAsignacionRecurso.Tipo.Operador;
//Validando que la asignación pertenezca a un servicio
RetornoOperacion resultado = validaMovimientoServicio(id_movimiento_asignacion_recurso);
//Si es de un servicio
if (resultado.OperacionExitosa)
{
//Obtención de token al que se enviará la notificación
resultado = validaUsuarioSesionActivaRecurso(id_movimiento_asignacion_recurso, out idCompania, out idRecurso, out tipoRecurso, out tokenFCM);
//Si hay datos suficientes
if (resultado.OperacionExitosa)
{
//Validando configuración de notificaciones
resultado = CompaniaEmisorReceptor.ValidaConfiguracionUsoAplicacionMovil(idCompania);
//Si se configuró el uso de aplicación móvil
if (resultado.OperacionExitosa)
{
//Inicializando asignaciones totales
int totalAsignaciones = 0;
//Recuperando asignaciones totales de servicio al usuario
using (DataTable mit = MovimientoAsignacionRecurso.CargaServiciosAsignadosAlRecurso(tipoRecurso, idRecurso, false))
{
//Si hay asignaciones
if (mit != null)
{
totalAsignaciones = mit.Rows.Count;
}
}
//Definiendo datos del mensaje de la notificación (si no hay asignaciones se informa que no tiene servicios asignados, si queda alguna otra pendiente se informa)
//Si hay asignaciones pendientes
if (totalAsignaciones > 0)
{
var datos1 = new
{
Titulo = "¡Viaje Reemplazado!",
Mensaje = "El viaje activo fue cambiado, consulte los detalles.",
TipoNotificacion = "NAsignacionActivo"
};
var datos2 = new
{
Titulo = "¡Viajes pendientes actualizados!",
Mensaje = "La lista de pendientes fue modificada, consulte los detalles.",
TipoNotificacion = "EAsignacion"
};
//Enviando mensaje vía FCM
resultado = FirebaseCloudNotifications.EnviaMensajeFCM(_url_servidor_fcm, _server_token_fcm, tokenFCM, FirebaseCloudNotifications.Prioridad.Normal, viaje_activo ? datos1 : datos2);
}
//Si ya no hay asignaciones
else
{
var datos = new
{
Titulo = "¡Sin viajes pendientes!",
Mensaje = "Por el momento no tiene viajes asignados.",
TipoNotificacion = "EAsignacionActivo"
};
//Enviando mensaje vía FCM
resultado = FirebaseCloudNotifications.EnviaMensajeFCM(_url_servidor_fcm, _server_token_fcm, tokenFCM, FirebaseCloudNotifications.Prioridad.Normal, datos);
}
}
}
}
//Devolviendo resultado
return(resultado);
}