Exemplo n.º 1
0
        /// <summary>
        /// Método encargado de eralizar las ediciones de las evidencias de acuerdo a la deshabilitacion de parada en despacho
        /// </summary>
        /// <param name="id_servicio"></param>
        /// <param name="id_segmento_anterior"></param>
        /// <param name="id_segmento_posterior"></param>
        /// <param name="id_usuario"></param>
        /// <returns></returns>
        public static RetornoOperacion SegmentoControlEvidenciaDeshabilitaParada(int id_servicio, int id_segmento_anterior, int id_segmento_posterior, int id_usuario)
        {
            //Declaramos objeto Resultado
            RetornoOperacion res = new RetornoOperacion(0);

            //declaramos avriables para almacenar la HI
            int hi_segmento_segmento_anterior = 0;

            //Creamos la transacción
            using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
            {
                //Instanciamos Servicio Control Evidencia
                using (ServicioControlEvidencia objServicioCE = new ServicioControlEvidencia(ServicioControlEvidencia.TipoConsulta.IdServicio, id_servicio))
                {
                    //Validamos que exista el Servicio Control Evidencia
                    if (objServicioCE.id_servicio_control_evidencia > 0)
                    {
                        //En caso de ser segmento en medio
                        if (id_segmento_posterior != 0 && id_segmento_anterior != 0)
                        {
                            //Establcemos valor
                            hi_segmento_segmento_anterior = res.IdRegistro;
                            //Obtenemos HI correspondiente al Segmento  anterior
                            res = Despacho.SegmentoCarga.ObteniendoHISegmento(id_segmento_anterior);
                            //Validamos que exista HI para el segmento anterior
                            if (res.OperacionExitosa)
                            {
                                //Establecemos valor
                                hi_segmento_segmento_anterior = res.IdRegistro;

                                //Instanciamos Control Evidencia Segmento
                                using (SegmentoControlEvidencia objSegmentoControlEvidencia = new SegmentoControlEvidencia(TipoConsulta.IdSegmento, id_segmento_anterior))
                                {
                                    //Carga Control Evidencia Documentos ligado al Segmento Control Evidencia Documento
                                    res = ControlEvidenciaDocumento.CancelaControlEvidenciaDocumento(objSegmentoControlEvidencia.id_segmento_control_evidencia, objSegmentoControlEvidencia, id_usuario);
                                    //Insertamos Segmento Control Evidencia para el posterior Segmento
                                    //Validamos Resultado
                                    if (res.OperacionExitosa)
                                    {
                                        //Instanciamos Control Evidencia Segmento Posterior
                                        using (SegmentoControlEvidencia objSegmentoControlEvidenciaP = new SegmentoControlEvidencia(TipoConsulta.IdSegmento, id_segmento_posterior))
                                        {
                                            //Carga Control Evidencia Documentos ligado al Segmento Control Evidencia Documento
                                            res = ControlEvidenciaDocumento.CancelaControlEvidenciaDocumento(objSegmentoControlEvidenciaP.id_segmento_control_evidencia, objSegmentoControlEvidenciaP, id_usuario);

                                            //Validamos resulado
                                            if (res.OperacionExitosa)
                                            {
                                                //Insertamos Segmento Control Evidencia
                                                res = SegmentoControlEvidencia.InsertaSegmentoControlEvidencia(objServicioCE.id_servicio_control_evidencia, id_segmento_anterior, hi_segmento_segmento_anterior, id_usuario);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        //En caso de Ser Segmento Al final
                        else if (id_segmento_posterior == 0)
                        {
                            if (objServicioCE.id_servicio_control_evidencia > 0)
                            {
                                //Instanciamos Control Evidencia Segmento
                                using (SegmentoControlEvidencia objSegmentoControlEvidencia = new SegmentoControlEvidencia(TipoConsulta.IdSegmento, id_segmento_anterior))
                                {
                                    //Carga Control Evidencia Documentos ligado al Segmento Control Evidencia Documento
                                    res = ControlEvidenciaDocumento.CancelaControlEvidenciaDocumento(objSegmentoControlEvidencia.id_segmento_control_evidencia, objSegmentoControlEvidencia, id_usuario);
                                }
                            }
                        }
                        //Validamos Resultado
                        if (res.OperacionExitosa)
                        {
                            //anteriorizamos Estatus del Servicio Control Evidencia
                            res = objServicioCE.ActualizaEstatusGeneralServicioControlEvidencia(id_usuario);
                        }
                    }
                }
                //Validamos Resultado
                if (res.OperacionExitosa)
                {
                    //Finalizamos Transacción
                    scope.Complete();
                }
            }

            //Devolvemos resultado
            return(res);
        }
Exemplo n.º 2
0
        /// <summary>
        /// Cancela Control Evidencia Documento
        /// </summary>
        /// <param name="id_segmento_control_evidencia">Id Segmento Control Evidencia Documento</param>
        /// <param name="objSegmentoControEvlidencia">Objeto Segmento Control Evidencia</param>
        /// <param name="id_usuario">Id Usuario</param>
        /// <returns></returns>
        public static RetornoOperacion CancelaControlEvidenciaDocumento(int id_segmento_control_evidencia, SegmentoControlEvidencia objSegmentoControEvlidencia, int id_usuario)
        {
            //Objeto Resultado
            RetornoOperacion res = new RetornoOperacion(0);

            //Creamos la transacción
            using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
            {
                //Cargamos Evidencias de Documento
                using (DataTable mitDocumento = CargaDocumentosControlEvidencia(id_segmento_control_evidencia))
                {
                    //Validamos Origen de Datos
                    if (Validacion.ValidaOrigenDatos(mitDocumento))
                    {
                        //Recorremos Cada uno de los Documento
                        foreach (DataRow r in mitDocumento.Rows)
                        {
                            //Instanciamos Documento
                            using (ControlEvidenciaDocumento doc = new ControlEvidenciaDocumento(r.Field <int>("Id")))
                            {
                                //Actualizamos Estatus
                                res = doc.ActualizaEstatusControlEvidenciaDocumento(ControlEvidenciaDocumento.EstatusDocumento.Cancelado, id_usuario);

                                //Validamos Resultado
                                if (res.OperacionExitosa)
                                {
                                    //Cargamos detalle del paquete correspondiente al Documento
                                    using (DataTable mit = PaqueteEnvioDocumento.ObtieneDetallesPaqueteDocumento(doc.id_control_evidencia_documento))
                                    {
                                        //Validamos Origen de Datos
                                        if (Validacion.ValidaOrigenDatos(mit))
                                        {
                                            //Recorremos cada uno de los paquetes
                                            foreach (DataRow p in mit.Rows)
                                            {
                                                //Insertamos Refrencia
                                                res = Referencia.InsertaReferencia(p.Field <int>("Id"), 41, 2070, "Reacomodo de los documentos a causa de la edición del segmento", Fecha.ObtieneFechaEstandarMexicoCentro(), id_usuario);

                                                //Validamos Resultado
                                                if (!res.OperacionExitosa)
                                                {
                                                    //Salimos del ciclo
                                                    break;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            //Validamos Resultado
                            if (!res.OperacionExitosa)
                            {
                                //Salimos del ciclo
                                break;
                            }
                        }
                    }
                    //Validamos Resultado
                    if (res.OperacionExitosa)
                    {
                        //Cancelamos Segmento
                        res = objSegmentoControEvlidencia.EditaEstatusSegmentoControlEvidencia(SegmentoControlEvidencia.EstatusSegmentoControlEvidencias.Cancelado, id_usuario);
                    }
                }
                //Validamos Resultado
                if (res.OperacionExitosa)
                {
                    scope.Complete();
                }
            }
            //Devolvemos resultado
            return(res);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Método encargado de actualizar el estatus del control de evidencia del segmento.
        /// </summary>
        /// <param name="id_usuario">Id de Usuario</param>
        /// <returns></returns>
        public RetornoOperacion ActualizaEstatusSegmentoControlEvidenciaSegmento(int id_usuario)
        {
            //Definiendo objetos de estatus de documentos
            bool             recibido, recibido_reenvio, transito, en_aclaracion, no_recibido, cancelado, imagen_digitalizada;
            RetornoOperacion resultado = new RetornoOperacion();
            //Definiendo variable de estatus por asignar
            EstatusSegmentoControlEvidencias nuevo_estatus = EstatusSegmentoControlEvidencias.No_Recibidos;

            //Cargando los estatus de documentos
            ControlEvidenciaDocumento.CargaEstatusDocumentosControlEvidencia(this.id_segmento_control_evidencia, out recibido, out recibido_reenvio, out transito, out en_aclaracion, out no_recibido, out cancelado,
                                                                             out imagen_digitalizada);

            //Determinando estatus de viaje
            //Filtrando solo recibidos
            if (recibido & !recibido_reenvio & !transito & !en_aclaracion & !no_recibido & !imagen_digitalizada)
            {
                nuevo_estatus = EstatusSegmentoControlEvidencias.Recibido;
            }
            //Filtrando solo recibidos con Imagen Digitalizada
            else if (recibido & !recibido_reenvio & !transito & !en_aclaracion & !no_recibido & imagen_digitalizada)
            {
                nuevo_estatus = EstatusSegmentoControlEvidencias.Imagen_Digitalizada;
            }
            //Solo cancelados
            else if (cancelado & !recibido & !recibido_reenvio & !transito & !en_aclaracion & !no_recibido & !imagen_digitalizada)
            {
                nuevo_estatus = EstatusSegmentoControlEvidencias.Cancelado;
            }
            //Solo cancelados con Imagen Digitalizada
            else if (cancelado & !recibido & !recibido_reenvio & !transito & !en_aclaracion & !no_recibido & imagen_digitalizada)
            {
                nuevo_estatus = EstatusSegmentoControlEvidencias.Cancelado;
            }
            //Solo recibido con reenvio
            else if (!recibido & recibido_reenvio & !transito & !en_aclaracion & !no_recibido & !imagen_digitalizada)
            {
                nuevo_estatus = EstatusSegmentoControlEvidencias.Recibido_Reenvio;
            }
            //Solo recibido con reenvio con Imagen Digitalizada
            else if (!recibido & recibido_reenvio & !transito & !en_aclaracion & !no_recibido & imagen_digitalizada)
            {
                nuevo_estatus = EstatusSegmentoControlEvidencias.Imagen_Digitalizada;
            }
            //Solo no recibido
            else if (!recibido & !recibido_reenvio & !transito & !en_aclaracion & no_recibido & !imagen_digitalizada)
            {
                nuevo_estatus = EstatusSegmentoControlEvidencias.No_Recibidos;
            }
            //Imagen Digitalizada
            else if (!recibido & !recibido_reenvio & !transito & !en_aclaracion & !no_recibido & imagen_digitalizada)
            {
                nuevo_estatus = EstatusSegmentoControlEvidencias.Imagen_Digitalizada;
            }
            //No Recibidos con Imagen Digitalizada
            else if (!recibido & !recibido_reenvio & !transito & !en_aclaracion & no_recibido & imagen_digitalizada)
            {
                nuevo_estatus = EstatusSegmentoControlEvidencias.Imagen_Digitalizada;
            }
            //Cualquier combinación con estatus en aclaración, tomará este estatus directamente
            else if (en_aclaracion)
            {
                nuevo_estatus = EstatusSegmentoControlEvidencias.En_Aclaracion;
            }
            //Para el resto de posibilidades
            else
            {
                //Si existen documentos en transito, se asigna estatus directo
                if (transito)
                {
                    nuevo_estatus = EstatusSegmentoControlEvidencias.Transito;
                }
                //Si no hay transito, en este nivel solo habrá aclaraciones
                else
                {
                    nuevo_estatus = EstatusSegmentoControlEvidencias.En_Aclaracion;
                }
            }

            //Invocando Método de Actualización
            resultado = this.actualizaAtributos(this._id_servicio_contorl_evidencia, this._id_segmento, nuevo_estatus,
                                                this._id_hoja_instruccion, id_usuario, this._habilitar);

            return(resultado);
        }