Example #1
0
        public Object Accion(Object oDatos)
        {
            _afdEdoDataMdl = (AfdEdoDataMdl)oDatos;
            int iClaveProceso = (int)_afdEdoDataMdl.solicitud.prcclave;

            Borrar();

            /// FALTA GRABAR LA RESOLUCION DE LA UA...
            if (_afdEdoDataMdl.rtpclave == Constantes.Respuesta.TURNAR)
            {
                return(base.Turnar(_afdEdoDataMdl, _afdEdoDataMdl.AFDnodoActMdl.nodregresar));
            }
            else if (_afdEdoDataMdl.rtpclave == Constantes.Respuesta.AMPLIACION_PLAZO)
            {
                // SE CREA UN NUEVO FLUJO DE TRABAJO EN PARALELO
                _calcularPlazoNeg = new CalcularPlazoNeg(_afdEdoDataMdl.dicDiaNoLaboral);
                base.AccionBase(false);
            }
            else  // DEFINO UNA RESPUESTA
            {
                long iNodoOrigen = _afdEdoDataMdl.AFDnodoActMdl.nodclave;

                // Constantes.Respuesta.RIA_AREA
                // DEFINO UNA RESPUESTA UNA RESPUESTA QUE ES MULTIPLE
                if (_afdEdoDataMdl.rtpclave != Constantes.Respuesta.INCOMPETENCIA_TOTAL_AREA &&
                    _afdEdoDataMdl.rtpclave != Constantes.Respuesta.RIA_AREA)
                {
                    _afdEdoDataMdl.rtpclave = Constantes.Respuesta.RESPUESTA_MULTIPLE;
                }

                base.AccionBase(true);
                //Regreso las repusta al nodo que se creo previamente....
                RespMoverSigNodo(iNodoOrigen, _afdEdoDataMdl.AFDnodoActMdl.nodclave, Constantes.RespuestaEstado.PROPUESTA, Constantes.RespuestaEstado.ANALIZAR);
            }
            return(true);
        }
        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);
        }
        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);
        }
        public Object Accion(Object oDatos)
        {
            Object oResultado = null;

            _afdEdoDataMdl = (AfdEdoDataMdl)oDatos;

            // ESTE ESTADO TIENE DOS ETAPAS 1) CREAR SU PROPIO ESTADO 2) TURNAR LA ACLARACION
            int iTipoProceso  = 0;
            int?iClaveProceso = _afdEdoDataMdl.solicitud.prcclave;

            if (_afdEdoDataMdl.solicitud != null)
            {
                if (_afdEdoDataMdl.solicitud.solfecacl == DateTime.MinValue)
                {
                    iTipoProceso = Constantes.ProcesoTipo.SOLICITUD;
                }
                else
                {
                    iTipoProceso = Constantes.ProcesoTipo.ACLARACION;
                }

                _afdEdoDataMdl.ID_Hito = Constantes.RespuestaHito.NO;

                // CREAR MI PROPIO ESTADO
                // BUSCAR DATOS PARA PROCESAR LA ACCION
                Dictionary <string, object> dicParam = new Dictionary <string, object>();
                dicParam.Add(DButil.SIT_SOL_SOLICITUD_COL.SOLCLAVE, _afdEdoDataMdl.solicitud.solclave);
                dicParam.Add(DButil.SIT_SOL_SOLICITUD_COL.PRCCLAVE, iTipoProceso);

                _afdEdoDataMdl.AFDseguimientoMdl = _segDao.dmlSelectSeguimientoPorID(dicParam) as SIT_SOL_SEGUIMIENTO;

                if (_afdEdoDataMdl.AFDseguimientoMdl.segultimonodo > 0)
                {
                    _afdEdoDataMdl.AFDnodoActMdl = _nodoDao.dmlSelectNodoID(_afdEdoDataMdl.AFDseguimientoMdl.segultimonodo) as SIT_RED_NODO;
                    _afdEdoDataMdl.ID_Capa       = _afdEdoDataMdl.AFDnodoActMdl.nodcapa + 1;
                    _afdEdoDataMdl.rtpclave      = Constantes.Respuesta.RECURSO_REVISION;



                    //////_afdEdoDataMdl.dicAuxRespuesta[ProcesoGralDao.PARAM_LISTA_TURNAR]
                    //////if (_afdEdoDataMdl.lstPersonasTurnar.Count > 1)
                    //////    iMultiple = 1;



                    /* CREAR UN NUEVO SEGUIMIENTO */
                    SIT_SOL_SEGUIMIENTO solSegMdl = new SIT_SOL_SEGUIMIENTO(repclave: Constantes.Respuesta.SIN_RESPUESTA,
                                                                            segfecestimada: _afdEdoDataMdl.ID_FecEstimada, segultimonodo: 0, segfecini: new DateTime(),
                                                                            afdclave: _afdEdoDataMdl.ID_ClaAfd, segedoproceso: AfdConstantes.PROCESO_ESTADO.EN_EJECUCION,
                                                                            prcclave: Constantes.ProcesoTipo.RECURSO_REVISION, segfeccalculo: new DateTime(), segdiasnolab: 0,
                                                                            segmultiple: _afdEdoDataMdl.AFDseguimientoMdl.segmultiple,
                                                                            segfecfin: new DateTime(), segfecamp: new DateTime(), segsemaforocolor: 0, segdiassemaforo: 0,
                                                                            solclave: _afdEdoDataMdl.solClave, usrclave: _afdEdoDataMdl.usrClaveOrigen);


                    ////DEBEMSO DE CALCULAR EL SEGUIMINETO..
                    ////afdEdoDataMdl = afdDatos;
                    ////CalcularSeguimiento(afdEdoDataMdl.solicitud.sotclave, afdDatos.FechaRecepcion);

                    _segDao.dmlAgregar(solSegMdl);

                    //Actualziamos el seguimiento
                    _afdEdoDataMdl.AFDseguimientoMdl = solSegMdl;

                    // CREAR NODO UT-RECIBIR_SOLICITUD
                    SIT_RED_NODO nodoUT = new SIT_RED_NODO {
                        prcclave       = iClaveProceso, solclave = _afdEdoDataMdl.solClave, araclave = _afdEdoDataMdl.ID_AreaUT,
                        nodcapa        = _afdEdoDataMdl.ID_Capa, nodatendido = AfdConstantes.NODO.EN_PROCESO, nodclave = Constantes.NodoEstado.UT_RECIBIR_SOLICITUD,
                        nodfeccreacion = _afdEdoDataMdl.FechaRecepcion, nedclave = Constantes.General.ID_PENDIENTE,
                        usrclave       = _afdEdoDataMdl.usrClaveDestino
                    };
                    _nodoDao.dmlAgregar(nodoUT);
                    nodoUT.nodclave = _nodoDao.iSecuencia;

                    /* CREAR ARISTA NODO_ANTERIOR --> NODO_NUEVO  */
                    if (_calcularPlazoNeg == null)
                    {
                        _calcularPlazoNeg = new CalcularPlazoNeg(_afdEdoDataMdl.dicDiaNoLaboral);
                    }

                    int[] aiDias = _calcularPlazoNeg.obtenerDiasNaturalesLaborales(_afdEdoDataMdl.FechaRecepcion, DateTime.Now);

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


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

                    // Guardamos los datos del recurso de revision
                    _afdEdoDataMdl.recRevisionMdl.repclave = aristaMdl.ariclave;
                    new SIT_RESP_RREVISIONDao(_cn, _transaction, _sDataAdapter).dmlAgregar(_afdEdoDataMdl.recRevisionMdl);

                    ////////////Grabamos los documentso en al nueva arista
                    ////////////GrabarDocumentos(aristaMdl.ariclave);
                    ////////////Borramos los docuemntso apra que no se graben nuevamente...

                    ////////////if (_afdEdoDataMdl.lstDocContenidoMdl != null)
                    ////////////    _afdEdoDataMdl.lstDocContenidoMdl.Clear();

                    // ACTUALIZAR EL REGISTRO DE LA SOLICICTUD CON UNA ACLARACION
                    _afdEdoDataMdl.solicitud.solfecrecrev = _afdEdoDataMdl.FechaRecepcion;
                    _afdEdoDataMdl.solicitud.prcclave     = Constantes.ProcesoTipo.RECURSO_REVISION;
                    new SIT_SOL_SOLICITUDDao(_cn, _transaction, _sDataAdapter).dmlEditar(_afdEdoDataMdl.solicitud);

                    // AHORA QUE SE HA CREADO EL NODO NUEVO ES NECESARIO CREAR LOS TURNOS..
                    // Y SE EJECUTA LA FUNCION BASE

                    List <Tuple <int, string, int> > lstPersonasTurnar = _afdEdoDataMdl.dicAuxRespuesta[ProcesoGralDao.PARAM_LISTA_TURNAR] as List <Tuple <int, string, int> >;

                    foreach (Tuple <int, string, int> areaTurnar in lstPersonasTurnar)
                    {
                        _afdEdoDataMdl.AFDnodoActMdl      = nodoUT;
                        _afdEdoDataMdl.ID_AreaDestino     = Convert.ToInt32(areaTurnar.Item1);
                        _afdEdoDataMdl.Observacion        = areaTurnar.Item2;
                        _afdEdoDataMdl.ID_PerfilDestino   = areaTurnar.Item3;
                        _afdEdoDataMdl.rtpclave           = Constantes.Respuesta.TURNAR;
                        _afdEdoDataMdl.ID_EstadoSiguiente = Constantes.NodoEstado.INAI_RECURSO_REVISION;

                        oResultado = AccionBase(true);
                    }
                }
                else
                {
                    return(false);
                }
            }
            return(true);
        }
Example #5
0
        public Object Accion(Object oDatos)
        {
            _afdEdoDataMdl = (AfdEdoDataMdl)oDatos;
            int iClaveProceso = (int)_afdEdoDataMdl.solicitud.prcclave;

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

            Dictionary <string, object> dicParam = new Dictionary <string, object>();

            dicParam.Add(DButil.SIT_SOL_SEGUIMIENTO_COL.SOLCLAVE, _afdEdoDataMdl.solClave);
            dicParam.Add(DButil.SIT_SOL_SEGUIMIENTO_COL.PRCCLAVE, Constantes.ProcesoTipo.SOLICITUD);

            _afdEdoDataMdl.AFDseguimientoMdl = _segDao.dmlSelectSeguimientoPorID(dicParam) as SIT_SOL_SEGUIMIENTO;

            _afdEdoDataMdl.AFDnodoActMdl = (SIT_RED_NODO)_nodoDao.dmlSelectNodoID(_afdEdoDataMdl.AFDseguimientoMdl.segultimonodo);
            _afdEdoDataMdl.ID_Capa       = _afdEdoDataMdl.AFDnodoActMdl.nodcapa + 1;
            _afdEdoDataMdl.rtpclave      = Constantes.Respuesta.RECEPCION_INFO_ADICIONAL;

            /* CREAR UN NUEVO SEGUIMIENTO */
            SIT_SOL_SEGUIMIENTO solSegMdl = new SIT_SOL_SEGUIMIENTO {
                repclave       = Constantes.Respuesta.SIN_RESPUESTA,
                segfecestimada = _afdEdoDataMdl.ID_FecEstimada, segultimonodo = 0, segfecini = _afdEdoDataMdl.FechaRecepcion,
                afdclave       = _afdEdoDataMdl.ID_ClaAfd, segedoproceso = AfdConstantes.PROCESO_ESTADO.EN_EJECUCION,
                prcclave       = Constantes.ProcesoTipo.ACLARACION, segfeccalculo = new DateTime(), segdiasnolab = 0, segmultiple = AfdConstantes.MULTIPLE.NO,
                segfecfin      = new DateTime(), segfecamp = new DateTime(), segsemaforocolor = 0, segdiassemaforo = 0,
                solclave       = _afdEdoDataMdl.solClave, usrclave = _afdEdoDataMdl.usrClaveOrigen
            };

            _segDao.dmlAgregar(solSegMdl);


            // CREAR NODO UT-RECIBIR_SOLICITUD
            SIT_RED_NODO nodoUT = new SIT_RED_NODO {
                prcclave       = Constantes.ProcesoTipo.ACLARACION, solclave = _afdEdoDataMdl.solClave, araclave = _afdEdoDataMdl.ID_AreaUT,
                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(nodoUT);
            nodoUT.nodclave = _nodoDao.iSecuencia;

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

            SIT_RED_ARISTA aristaMdl = new SIT_RED_ARISTA
            {
                arihito     = Constantes.RespuestaHito.NO,
                aridiasnat  = aiDias[CalcularPlazoNeg.DIAS_NATURALES],
                aridiaslab  = aiDias[CalcularPlazoNeg.DIAS_LABORALES],
                arifecenvio = _afdEdoDataMdl.FechaRecepcion,
                ariclave    = Constantes.General.ID_PENDIENTE,
                noddestino  = nodoUT.nodclave,
                nodorigen   = _afdEdoDataMdl.AFDnodoActMdl.nodclave
            };

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

            // NODO ACTUAL EL NUEVO CREADO PARA PROCESAR EL SIGUIENTE
            _afdEdoDataMdl.AFDnodoActMdl = nodoUT;

            // ACTUALIZAR EL REGISTRO DE LA SOLICICTUD CON UNA ACLARACION
            _afdEdoDataMdl.solicitud.solfecacl = _afdEdoDataMdl.FechaRecepcion;
            _afdEdoDataMdl.solicitud.prcclave  = Constantes.ProcesoTipo.ACLARACION;

            SIT_SOL_SOLICITUDDao solDao = new SIT_SOL_SOLICITUDDao(_cn, _transaction, _sDataAdapter);

            solDao.dmlEditar(_afdEdoDataMdl.solicitud);

            return(_afdEdoDataMdl);
        }
        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);
        }
Example #7
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);
        }
        public Object Accion(Object oDatos)
        {
            _afdEdoDataMdl = (AfdEdoDataMdl)oDatos;

            SIT_RED_NODO nodoAnterior = _afdEdoDataMdl.AFDnodoActMdl;

            nodoAnterior.nodatendido = AfdConstantes.NODO.FINALIZADO;
            _nodoDao.dmlEditar(nodoAnterior);
            int iClaveProceso = (int)_afdEdoDataMdl.solicitud.prcclave;

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

                _afdEdoDataMdl.ID_EstadoActual = _afdEdoDataMdl.ID_EstadoSiguiente;

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

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

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

                /* CREAR ARISTA NODO_ANTERIOR --> NODO_NUEVO  */
                int[]          aiDias    = _calcularPlazoNeg.obtenerDiasNaturalesLaborales(nodoAnterior.nodfeccreacion, nodoActual.nodfeccreacion);
                SIT_RED_ARISTA 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.dmlEditar(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);

                //////GrabarDocumentos(aristaMdl.ariclave);
                _afdEdoDataMdl.ID_ClaAristaActual = aristaMdl.ariclave;
            }
            catch (Exception ex)
            {
                _sMsjError = ex.ToString();
                throw new Exception("Error en el método AccionCrearNodoAristaSeg " + ex.ToString());
            }
            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);
        }
Example #10
0
        public Object Accion(Object oDatos)
        {
            _afdEdoDataMdl = (AfdEdoDataMdl)oDatos;
            int iClaveProceso = (int)_afdEdoDataMdl.solicitud.prcclave;

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

            /// FALTA GRABAR LA RESOLUCION DE LA UA...
            if (_afdEdoDataMdl.rtpclave == Constantes.Respuesta.TURNAR)
            {
                AccionBase(true);
            }
            else
            {
                // 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);

                // VERIFICAR SI EXISTE EL NODO SIGUIENTE CT, ya que solo puede existir uno...
                // el nodo siemrpe existe....

                SIT_RED_NODO nodoActual = ExisteNodo((long)nodoAnt.solclave, _afdEdoDataMdl.ID_EstadoSiguiente, _afdEdoDataMdl.ID_AreaDestino, nodoAnt.nodcapa + 1);
                if (nodoActual == null)
                {
                    // CREAR NODO ACTUAL

                    nodoActual = new SIT_RED_NODO {
                        prcclave       = iClaveProceso, solclave = _afdEdoDataMdl.solClave, araclave = _afdEdoDataMdl.ID_AreaDestino,
                        nodcapa        = _afdEdoDataMdl.ID_Capa + 1, nodatendido = AfdConstantes.NODO.EN_PROCESO, nodclave = _afdEdoDataMdl.ID_EstadoSiguiente,
                        nodfeccreacion = _afdEdoDataMdl.FechaRecepcion, nedclave = Constantes.General.ID_PENDIENTE,
                        usrclave       = _afdEdoDataMdl.usrClaveDestino
                    };
                    _nodoDao.dmlAgregar(nodoActual);
                    nodoActual.nodclave = _nodoDao.iSecuencia;
                }

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

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

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

                _redAristaDao.dmlEditar(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);

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