Esempio n. 1
0
        public Object Accion(Object oDatos)
        {
            _afdEdoDataMdl    = (AfdEdoDataMdl)oDatos;
            _calcularPlazoNeg = new CalcularPlazoNeg(_afdEdoDataMdl.dicDiaNoLaboral);
            int iClaveProceso = (int)_afdEdoDataMdl.solicitud.prcclave;

            //AL NODO ACTGUAL LO ACTUALIZAMOS
            _afdEdoDataMdl.AFDnodoActMdl.nodatendido = AfdConstantes.NODO.FINALIZADO;
            _nodoDao.dmlEditar(_afdEdoDataMdl.AFDnodoActMdl);

            // BUSCAR EL NODO ANTERIOR DE CT por FOLIO - CAPA - AREA
            SIT_RED_NODO nodoCT = ExisteNodo(_afdEdoDataMdl.solClave, Constantes.NodoEstado.INDEFINIDO, _afdEdoDataMdl.ID_AreaCT, _afdEdoDataMdl.ID_Capa);

            /* CREAR ARISTA NODO_ACTUAL UA --> CT  */
            int[]          aiDias    = _calcularPlazoNeg.obtenerDiasNaturalesLaborales(_afdEdoDataMdl.AFDnodoActMdl.nodfeccreacion, _afdEdoDataMdl.FechaRecepcion);
            SIT_RED_ARISTA aristaMdl = new SIT_RED_ARISTA {
                arihito    = Constantes.RespuestaHito.SI,
                aridiasnat = aiDias[CalcularPlazoNeg.DIAS_NATURALES],
                aridiaslab = aiDias[CalcularPlazoNeg.DIAS_LABORALES], arifecenvio = _afdEdoDataMdl.FechaRecepcion,
                ariclave   = Constantes.General.ID_PENDIENTE,
                noddestino = nodoCT.nodclave, nodorigen = _afdEdoDataMdl.AFDnodoActMdl.nodclave
            };

            _redAristaDao.dmlEditar(aristaMdl);
            aristaMdl.ariclave = _redAristaDao.iSecuencia;

            /* ACTUALIZAR EL SEGUIMIENTO */
            _afdEdoDataMdl.AFDseguimientoMdl = _calcularPlazoNeg.CalcularSeguimiento((int)_afdEdoDataMdl.solicitud.sotclave, _afdEdoDataMdl.FechaRecepcion,
                                                                                     _afdEdoDataMdl.lstProcesoPlazos, _afdEdoDataMdl.AFDseguimientoMdl);

            _segDao.dmlEditar(_afdEdoDataMdl.AFDseguimientoMdl);

            //////GrabarDocumentos(aristaMdl.ariclave);

            return(true);
        }
Esempio n. 2
0
        public Object Accion(Object oDatos)
        {
            _afdEdoDataMdl = (AfdEdoDataMdl)oDatos;
            int iClaveProceso = (int)_afdEdoDataMdl.solicitud.prcclave;

            /// FALTA GRABAR LA RESOLUCION DE LA UA...
            if (_afdEdoDataMdl.rtpclave == Constantes.Respuesta.TURNAR)
            {
                return(base.AccionBase(true));
            }
            else if (_afdEdoDataMdl.rtpclave == Constantes.Respuesta.AMPLIACION_PLAZO)
            {
                // SE CREA UN NUEVO FLUJO DE TRABAJO EN PARALELO
                _calcularPlazoNeg = new CalcularPlazoNeg(_afdEdoDataMdl.dicDiaNoLaboral);
                return(base.AccionBase(false));
            }
            else  // DEFINO UNA RESPUESTA
            {
                _calcularPlazoNeg = new CalcularPlazoNeg(_afdEdoDataMdl.dicDiaNoLaboral);
                // como es una respueta verficamos si existe el nodo siguiente que es la UT.
                SIT_RED_NODO nodoAnt = _afdEdoDataMdl.AFDnodoActMdl;
                nodoAnt.nodatendido = AfdConstantes.NODO.FINALIZADO;
                _nodoDao.dmlEditar(nodoAnt);


                SIT_SOL_SEGUIMIENTO solSegBuscar = new SIT_SOL_SEGUIMIENTO();
                solSegBuscar.solclave = _afdEdoDataMdl.solClave;
                solSegBuscar.prcclave = iClaveProceso;

                SIT_SOL_SEGUIMIENTO segAux = _segDao.dmlSelectID(solSegBuscar);
                _afdEdoDataMdl.AFDseguimientoMdl.usrclave = segAux.usrclave;


                _afdEdoDataMdl.ID_EstadoSiguiente = _afdEdoDataMdl.dicAfdFlujo[_afdEdoDataMdl.ID_EstadoActual].dicAccionEstado[_afdEdoDataMdl.rtpclave];

                //////// VERIFICAR SI EXISTE EL NODO SIGUIENTE UT, ya que solo puede existir uno...  y actualizar su estado.. ya que no lo veo...
                _afdEdoDataMdl.AFDnodoActMdl = ExisteNodo((int)nodoAnt.solclave, _afdEdoDataMdl.ID_EstadoSiguiente, (int)segAux.usrclave, nodoAnt.nodcapa + 1);
                if (_afdEdoDataMdl.AFDnodoActMdl == null)
                {
                    throw new System.ArgumentException("NO EXISTE NODO DE BARRERA", "original");
                }

                _afdEdoDataMdl.AFDnodoActMdl.nodatendido = AfdConstantes.NODO.EN_PROCESO;
                _nodoDao.dmlUpdateNodoAtendido(_afdEdoDataMdl.AFDnodoActMdl);


                /* CREAR ARISTA NODO_ANTERIOR --> NODO_NUEVO  */
                int[] aiDias = _calcularPlazoNeg.obtenerDiasNaturalesLaborales(nodoAnt.nodfeccreacion, DateTime.Now);

                /* EN LA ARISTA SE GUARDA LA RESOLUCION DEL AREA */
                SIT_RED_ARISTA aristaMdl = new SIT_RED_ARISTA {
                    arihito    = Constantes.RespuestaHito.SI,
                    aridiasnat = aiDias[CalcularPlazoNeg.DIAS_NATURALES],
                    aridiaslab = aiDias[CalcularPlazoNeg.DIAS_LABORALES], arifecenvio = nodoAnt.nodfeccreacion,
                    ariclave   = Constantes.General.ID_PENDIENTE,
                    noddestino = _afdEdoDataMdl.AFDnodoActMdl.nodclave, nodorigen = nodoAnt.nodclave
                };

                _redAristaDao.dmlAgregar(aristaMdl);
                aristaMdl.ariclave = _redAristaDao.iSecuencia;

                /* ACTUALIZAR EL SEGUIMIENTO */
                _afdEdoDataMdl.AFDseguimientoMdl = _calcularPlazoNeg.CalcularSeguimiento((int)_afdEdoDataMdl.solicitud.sotclave, DateTime.Now,
                                                                                         _afdEdoDataMdl.lstProcesoPlazos, _afdEdoDataMdl.AFDseguimientoMdl);

                //////GrabarDocumentos(aristaMdl.ariclave);
            }
            return(true);
        }
Esempio n. 3
0
        protected Boolean AccionBase(bool bAvanzar)
        {
            try
            {
                SIT_RED_NODO nodoActual = null;


                _afdEdoDataMdl.AFDnodoOrigen = _afdEdoDataMdl.AFDnodoActMdl;

                if (bAvanzar == true)
                {
                    _afdEdoDataMdl.AFDnodoOrigen.nodatendido = AfdConstantes.NODO.FINALIZADO;
                    _nodoDao.dmlEditar(_afdEdoDataMdl.AFDnodoOrigen);
                    _afdEdoDataMdl.ID_EstadoSiguiente = _afdEdoDataMdl.dicAfdFlujo[_afdEdoDataMdl.ID_EstadoActual].dicAccionEstado[_afdEdoDataMdl.rtpclave];
                    _afdEdoDataMdl.ID_EstadoActual    = _afdEdoDataMdl.ID_EstadoSiguiente;
                }

                if (_calcularPlazoNeg == null)
                {
                    _calcularPlazoNeg = new CalcularPlazoNeg(_afdEdoDataMdl.dicDiaNoLaboral);
                }

                if (_afdEdoDataMdl.AFDnodoOrigen.nodregresar > 0)
                {
                    nodoActual             = _nodoDao.dmlSelectNodoID(_afdEdoDataMdl.AFDnodoOrigen.nodregresar);
                    nodoActual.nodatendido = AfdConstantes.NODO.EN_PROCESO;
                    _nodoDao.dmlUpdateNodoAtendido(nodoActual);
                }
                else
                {
                    nodoActual = new SIT_RED_NODO
                    {
                        prcclave       = _afdEdoDataMdl.AFDseguimientoMdl.prcclave,
                        solclave       = _afdEdoDataMdl.solClave,
                        araclave       = _afdEdoDataMdl.ID_AreaDestino,
                        nodcapa        = _afdEdoDataMdl.ID_Capa,
                        nodatendido    = AfdConstantes.NODO.EN_PROCESO,
                        nedclave       = _afdEdoDataMdl.ID_EstadoActual,
                        nodfeccreacion = _afdEdoDataMdl.FechaRecepcion,
                        nodclave       = Constantes.General.ID_PENDIENTE,
                        usrclave       = _afdEdoDataMdl.usrClaveDestino,
                        perclave       = _afdEdoDataMdl.ID_PerfilDestino
                    };
                    _nodoDao.dmlAgregar(nodoActual);
                    nodoActual.nodclave = _nodoDao.iSecuencia;
                }
                // CREAR NODO ACTUAL


                // NODO ACTUAL EL NUEVO CREADO
                _afdEdoDataMdl.AFDnodoActMdl = nodoActual;

                /* CREAR ARISTA NODO_ANTERIOR --> NODO_NUEVO  */
                int[] aiDias = _calcularPlazoNeg.obtenerDiasNaturalesLaborales(_afdEdoDataMdl.AFDnodoOrigen.nodfeccreacion, nodoActual.nodfeccreacion);

                SIT_RED_ARISTA aristaMdl = new SIT_RED_ARISTA
                {
                    ariclave    = Constantes.General.ID_PENDIENTE,
                    nodorigen   = _afdEdoDataMdl.AFDnodoOrigen.nodclave,
                    noddestino  = nodoActual.nodclave,
                    arifecenvio = _afdEdoDataMdl.AFDnodoOrigen.nodfeccreacion,
                    aridiasnat  = aiDias[CalcularPlazoNeg.DIAS_NATURALES],
                    aridiaslab  = aiDias[CalcularPlazoNeg.DIAS_LABORALES],
                    arihito     = _afdEdoDataMdl.ID_Hito,
                    rtpclave    = _afdEdoDataMdl.rtpclave,
                    solclave    = _afdEdoDataMdl.solClave
                };

                _redAristaDao.dmlAgregar(aristaMdl);
                aristaMdl.ariclave = _redAristaDao.iSecuencia;

                /* ACTUALIZAR EL SEGUIMIENTO */
                _afdEdoDataMdl.AFDseguimientoMdl = _calcularPlazoNeg.CalcularSeguimiento((int)_afdEdoDataMdl.solicitud.sotclave, nodoActual.nodfeccreacion,
                                                                                         _afdEdoDataMdl.lstProcesoPlazos, _afdEdoDataMdl.AFDseguimientoMdl);
                _segDao.dmlEditar(_afdEdoDataMdl.AFDseguimientoMdl);

                _afdEdoDataMdl.ID_ClaAristaActual = aristaMdl.ariclave;
                ////////RespMoverSigNodo(_afdEdoDataMdl.AFDnodoOrigen.nodclave, _afdEdoDataMdl.AFDnodoActMdl.nodclave);
            }
            catch (Exception ex)
            {
                _sMsjError = ex.ToString();
                throw new Exception("Error en el método AccionBase " + ex.ToString());
            }

            return(true);
        }
Esempio n. 4
0
        public Object Accion(Object oDatos)
        {
            _afdEdoDataMdl    = (AfdEdoDataMdl)oDatos;
            _calcularPlazoNeg = new CalcularPlazoNeg(_afdEdoDataMdl.dicDiaNoLaboral);
            int iClaveProceso = (int)_afdEdoDataMdl.solicitud.prcclave;


            if (_afdEdoDataMdl.rtpclave == Constantes.Respuesta.CORREGIR)
            {
                // CREAR NODO UT y MARCARLO COMO FINALIZADO
                SIT_RED_NODO nodoUT = new SIT_RED_NODO {
                    prcclave       = iClaveProceso, solclave = _afdEdoDataMdl.solClave, araclave = _afdEdoDataMdl.ID_AreaUT,
                    nodcapa        = _afdEdoDataMdl.ID_Capa, nodatendido = AfdConstantes.NODO.FINALIZADO, nodclave = Constantes.NodoEstado.INDEFINIDO,
                    nodfeccreacion = _afdEdoDataMdl.FechaRecepcion, nedclave = Constantes.General.ID_PENDIENTE,
                    usrclave       = _afdEdoDataMdl.usrClaveDestino
                };
                _nodoDao.dmlAgregar(nodoUT);
                nodoUT.nodclave = _nodoDao.iSecuencia;

                // CREAR ARISTA CT ( Sesionar) --(18)--> UT (requerimiento)
                int[]          aiDias    = _calcularPlazoNeg.obtenerDiasNaturalesLaborales(_afdEdoDataMdl.AFDnodoActMdl.nodfeccreacion, _afdEdoDataMdl.FechaRecepcion);
                SIT_RED_ARISTA aristaMdl = new SIT_RED_ARISTA {
                    arihito     = Constantes.RespuestaHito.NO,
                    aridiasnat  = aiDias[CalcularPlazoNeg.DIAS_NATURALES],
                    aridiaslab  = aiDias[CalcularPlazoNeg.DIAS_LABORALES],
                    arifecenvio = _afdEdoDataMdl.AFDnodoActMdl.nodfeccreacion, ariclave = Constantes.General.ID_PENDIENTE,
                    noddestino  = nodoUT.nodclave, nodorigen = _afdEdoDataMdl.AFDnodoActMdl.nodclave
                };

                _redAristaDao.dmlEditar(aristaMdl);
                aristaMdl.ariclave = _redAristaDao.iSecuencia;

                // CREAR NODO UA PARA REQUERIMIENTO
                SIT_RED_NODO nodoUA = new SIT_RED_NODO {
                    prcclave       = iClaveProceso, solclave = _afdEdoDataMdl.solClave, araclave = _afdEdoDataMdl.ID_AreaDestino,
                    nodcapa        = _afdEdoDataMdl.ID_Capa, nodatendido = AfdConstantes.NODO.EN_PROCESO, nodclave = Constantes.NodoEstado.INDEFINIDO,
                    nodfeccreacion = _afdEdoDataMdl.FechaRecepcion, nedclave = Constantes.General.ID_PENDIENTE,
                    usrclave       = _afdEdoDataMdl.usrClaveDestino
                };

                _nodoDao.dmlAgregar(nodoUA);
                nodoUA.nodclave = _nodoDao.iSecuencia;

                // CREAR ARISTA UT ( requerimiento) --(18)--> UA (requerimiento)
                aiDias = _calcularPlazoNeg.obtenerDiasNaturalesLaborales(nodoUA.nodfeccreacion, _afdEdoDataMdl.FechaRecepcion);
                SIT_RED_ARISTA aristaNvoMdl = new SIT_RED_ARISTA
                {
                    arihito     = Constantes.RespuestaHito.NO,
                    aridiasnat  = 0,
                    aridiaslab  = 0,
                    arifecenvio = _afdEdoDataMdl.FechaRecepcion,
                    ariclave    = Constantes.General.ID_PENDIENTE,
                    noddestino  = nodoUA.nodclave,
                    nodorigen   = nodoUT.nodclave
                };
                _redAristaDao.dmlEditar(aristaNvoMdl);

                /* ACTUALIZAR EL SEGUIMIENTO */
                _afdEdoDataMdl.AFDseguimientoMdl = _calcularPlazoNeg.CalcularSeguimiento((int)_afdEdoDataMdl.solicitud.sotclave,
                                                                                         nodoUA.nodfeccreacion, _afdEdoDataMdl.lstProcesoPlazos, _afdEdoDataMdl.AFDseguimientoMdl);

                _segDao.dmlEditar(_afdEdoDataMdl.AFDseguimientoMdl);
            }
            else
            {
                // Creamos una capa nueva para contestar
                _afdEdoDataMdl.ID_Capa = _afdEdoDataMdl.ID_Capa + 1;
                AccionBase(true);

                /* GUARDAMOS EN EL SEGUIMIENTO LA RESPUESTA INTERNA Y EXTERNA*/
                ////////_afdEdoDataMdl.AFDseguimientoMdl.ariclave = _afdEdoDataMdl.ID_ClaAristaActual;
                ////////_segDao.dmlEditar(_afdEdoDataMdl.AFDseguimientoMdl);

                ////////_afdEdoDataMdl.AFDrescomiteMdl.ariclave = _afdEdoDataMdl.ID_ClaAristaActual;

                //////new SIT_ARISTA_COMITEDao(_cn, _transaction, _sDataAdapter).dmlAgregar(_afdEdoDataMdl.AFDrescomiteMdl);

                // ACUTALIZAMOS EL HITO
                SIT_RED_ARISTA aristaHito = new SIT_RED_ARISTA();
                aristaHito.ariclave = _afdEdoDataMdl.ID_ClaAristaActual;
                aristaHito.arihito  = Constantes.RespuestaHito.SI;
                _redAristaDao.dmlUpdateAristaHito(aristaHito);
            }
            return(true);
        }
        public Object Accion(Object oDatos)
        {
            _afdEdoDataMdl    = (AfdEdoDataMdl)oDatos;
            _calcularPlazoNeg = new CalcularPlazoNeg(_afdEdoDataMdl.dicDiaNoLaboral);

            SIT_RED_NODO   nodoActual = null;
            SIT_RED_ARISTA aristaMdl  = null;

            SIT_RED_NODO nodoAnterior = _afdEdoDataMdl.AFDnodoActMdl;
            int          iEdoSig      = _afdEdoDataMdl.ID_EstadoSiguiente; // SiguienteEstado(afdEdoDataMdl.rptclave);

            _afdEdoDataMdl.AFDnodoActMdl.nodatendido = AfdConstantes.NODO.FINALIZADO;
            _nodoDao.dmlEditar(_afdEdoDataMdl.AFDnodoActMdl);
            _afdEdoDataMdl.ID_Hito = Constantes.RespuestaHito.NO;

            int iClaveProceso = (int)_afdEdoDataMdl.solicitud.prcclave;

            if (_afdEdoDataMdl.rtpclave == Constantes.Respuesta.AMPLIACION_PLAZO)
            {
                // CREAR NUEVO NODO ACTUAL
                nodoActual = new SIT_RED_NODO
                {
                    prcclave       = iClaveProceso,
                    solclave       = _afdEdoDataMdl.solClave,
                    araclave       = _afdEdoDataMdl.ID_AreaUTN,
                    nodcapa        = _afdEdoDataMdl.ID_Capa,
                    nodatendido    = AfdConstantes.NODO.EN_PROCESO,
                    nedclave       = iEdoSig,
                    nodfeccreacion = _afdEdoDataMdl.FechaRecepcion,
                    nodclave       = Constantes.General.ID_PENDIENTE,
                    usrclave       = _afdEdoDataMdl.usrClaveDestino
                };

                _nodoDao.dmlEditar(nodoActual);
                nodoActual.nodclave = _nodoDao.iSecuencia;

                /* CREAR ARISTA NODO_ANTERIOR --> NODO_NUEVO  */
                int[] aiDias = _calcularPlazoNeg.obtenerDiasNaturalesLaborales(nodoAnterior.nodfeccreacion, nodoActual.nodfeccreacion);

                aristaMdl = new SIT_RED_ARISTA {
                    arihito    = _afdEdoDataMdl.ID_Hito,
                    aridiasnat = aiDias[CalcularPlazoNeg.DIAS_NATURALES],
                    aridiaslab = aiDias[CalcularPlazoNeg.DIAS_LABORALES], arifecenvio = nodoActual.nodfeccreacion,
                    ariclave   = Constantes.General.ID_PENDIENTE,
                    noddestino = nodoActual.nodclave, nodorigen = nodoAnterior.nodclave
                };

                _redAristaDao.Agregar(aristaMdl);
                aristaMdl.ariclave = _redAristaDao.iSecuencia;
                ////////////GrabarDocumentos(aristaMdl.ariclave);

                // BUSCAR SI EXISTEN OTRAS SOLICITUDES DE AMPLIACION Y CERRARLAS DEBIDO QUE SE AUTORIZO LA AMPLIACION
                Dictionary <string, object> dicParam = new Dictionary <string, object>();
                dicParam.Add(DButil.SIT_RED_NODO_COL.SOLCLAVE, _afdEdoDataMdl.solClave);
                dicParam.Add(DButil.SIT_RESP_TIPO_COL.RTPCLAVE, Constantes.Respuesta.AMPLIACION_PLAZO);
                dicParam.Add(DButil.SIT_RED_ARISTA_COL.NODDESTINO, _afdEdoDataMdl.AFDnodoActMdl.nodclave);

                List <SIT_RED_NODO> lstSIT_RED_NODO = _nodoDao.dmlSelectMdlAmpPendiente(dicParam) as List <SIT_RED_NODO>;
                foreach (SIT_RED_NODO nodoPendienteMdl in lstSIT_RED_NODO)
                {
                    nodoPendienteMdl.nodatendido = AfdConstantes.NODO.FINALIZADO;
                    _nodoDao.dmlEditar(nodoPendienteMdl);

                    aiDias    = _calcularPlazoNeg.obtenerDiasNaturalesLaborales(nodoPendienteMdl.nodfeccreacion, nodoActual.nodfeccreacion);
                    aristaMdl = new SIT_RED_ARISTA {
                        arihito    = _afdEdoDataMdl.ID_Hito,
                        aridiasnat = aiDias[CalcularPlazoNeg.DIAS_NATURALES],
                        aridiaslab = aiDias[CalcularPlazoNeg.DIAS_LABORALES], arifecenvio = nodoActual.nodfeccreacion,
                        ariclave   = Constantes.General.ID_PENDIENTE,
                        noddestino = nodoActual.nodclave, nodorigen = nodoPendienteMdl.nodclave
                    };

                    _redAristaDao.dmlAgregar(aristaMdl);

                    ////////GrabarDocumentos(aristaMdl.ariclave);
                }

                // GENERAMOS UN MENSAJE A TODAS LAS DEMAS ÁREAS PENDIENTES
                iEdoSig = dicAccionEstado[Constantes.Respuesta.CREAR_MENSAJE];

                List <Int32> lstOmitir = new List <Int32>();
                lstOmitir.Add(_afdEdoDataMdl.ID_AreaCT);
                lstOmitir.Add(_afdEdoDataMdl.ID_AreaUTN);
                lstOmitir.Add(_afdEdoDataMdl.ID_AreaInai);  // El perfil y el area tienen el mismo valor..

                dicParam.Add(DButil.SIT_RED_NODO_COL.PRCCLAVE, _afdEdoDataMdl.solicitud.prcclave);
                dicParam.Add(SIT_RED_NODODao.COL_AREAS_EXCLUIR, lstOmitir);



                DataTable dtAreasTurnar = _nodoDao.dmlSelectNodosGrafo(dicParam) as DataTable;

                foreach (DataRow drArea in dtAreasTurnar.Rows)
                {
                    nodoActual = new SIT_RED_NODO {
                        prcclave       = iClaveProceso, solclave = _afdEdoDataMdl.solClave, araclave = Convert.ToInt32(drArea["ka_claarea"]),
                        nodcapa        = _afdEdoDataMdl.ID_Capa, nodatendido = AfdConstantes.NODO.EN_PROCESO, nodclave = iEdoSig,
                        nodfeccreacion = _afdEdoDataMdl.FechaRecepcion, nedclave = Constantes.General.ID_PENDIENTE,
                        usrclave       = _afdEdoDataMdl.usrClaveDestino
                    };
                    _nodoDao.dmlAgregar(nodoActual);
                    nodoActual.nodclave = _nodoDao.iSecuencia;

                    aiDias    = _calcularPlazoNeg.obtenerDiasNaturalesLaborales(nodoAnterior.nodfeccreacion, nodoActual.nodfeccreacion);
                    aristaMdl = new SIT_RED_ARISTA {
                        arihito    = _afdEdoDataMdl.ID_Hito,
                        aridiasnat = aiDias[CalcularPlazoNeg.DIAS_NATURALES],
                        aridiaslab = aiDias[CalcularPlazoNeg.DIAS_LABORALES], arifecenvio = nodoActual.nodfeccreacion,
                        ariclave   = Constantes.General.ID_PENDIENTE,
                        noddestino = nodoActual.nodclave, nodorigen = nodoAnterior.nodclave
                    };
                    _redAristaDao.dmlAgregar(aristaMdl);
                }
            }
            else
            {
                // MANDAMOS UN MENSAJE AL AREA ANTERIOR NOTIFICANDO LA CAUSA
                iEdoSig = dicAccionEstado[Constantes.RespuestaEstado.NEGAR];

                // CREAR NODO ACTUAL
                nodoActual = new SIT_RED_NODO {
                    prcclave       = iClaveProceso, solclave = _afdEdoDataMdl.solClave, araclave = _afdEdoDataMdl.ID_AreaDestino,
                    nodcapa        = _afdEdoDataMdl.ID_Capa, nodatendido = AfdConstantes.NODO.EN_PROCESO, nodclave = iEdoSig,
                    nodfeccreacion = _afdEdoDataMdl.FechaRecepcion, nedclave = Constantes.General.ID_PENDIENTE,
                    usrclave       = _afdEdoDataMdl.usrClaveDestino
                };



                _nodoDao.dmlAgregar(nodoActual);
                nodoActual.nodclave = _nodoDao.iSecuencia;

                /* CREAR ARISTA NODO_ANTERIOR --> NODO_NUEVO  */
                int[] aiDias = _calcularPlazoNeg.obtenerDiasNaturalesLaborales(nodoAnterior.nodfeccreacion, nodoActual.nodfeccreacion);

                aristaMdl = new SIT_RED_ARISTA {
                    arihito     = _afdEdoDataMdl.ID_Hito,
                    aridiasnat  = aiDias[CalcularPlazoNeg.DIAS_NATURALES],
                    aridiaslab  = aiDias[CalcularPlazoNeg.DIAS_LABORALES],
                    arifecenvio = nodoActual.nodfeccreacion, ariclave = Constantes.General.ID_PENDIENTE,
                    noddestino  = nodoActual.nodclave, nodorigen = nodoAnterior.nodclave
                };


                _redAristaDao.dmlAgregar(aristaMdl);
                aristaMdl.ariclave = _redAristaDao.iSecuencia;
            }
            return(true);
        }