public static string Procesar(string sRegistros, string strDatos)
        {
            string  sResul = "", sEstadoMes = "";
            int     nPSN_C = 0, nPSN_J = 0, nPSN_P = 0, nSegMesProy = 0;
            int     nIDEmpresaNodoProyecto_C = 0;
            int     nNodoUsuario = 0, nEmpresaNodoUsuario = 0, nNodo_C = 0, nNodo_J = 0, nNodo_P = 0;
            decimal nTipoCambio_C = 0, nTipoCambio_J = 0, nTipoCambio_P = 0;

            SqlConnection  oConn            = null;
            SqlTransaction tr               = null;
            bool           bErrorControlado = false;

            string[] aIncentivos = Regex.Split(strDatos, "#reg#");

            #region Abrir conexión y transacción
            try
            {
                oConn = Conexion.Abrir();
                tr    = Conexion.AbrirTransaccionSerializable(oConn);
            }
            catch
            {
                if (oConn.State == ConnectionState.Open)
                {
                    Conexion.Cerrar(oConn);
                }
                throw (new Exception("Error al abrir la conexión."));
            }
            #endregion

            try
            {
                //inserto los registros seleccionados en la T726_INCENTIVOSPRODUCTIVIDAD
                Capa_Datos.INCENTIVOSPRODUCTIVIDAD.Insertar(tr, sRegistros);

                //Trato los registros seleccionados
                int i = 0;
                foreach (string oIncentivo in aIncentivos)
                {
                    i++;
                    if (oIncentivo == "")
                    {
                        continue;
                    }
                    string[] aDatos = Regex.Split(oIncentivo, "#sep#");

                    #region Datos Incentivo
                    //aDatos[0] = id incentivo //0
                    //aDatos[1] = idusuario //1
                    //aDatos[2] = idnodo_usuario //2
                    //aDatos[3] = importe //3
                    //aDatos[4] = idproyecto //4
                    //aDatos[5] = anomes //5
                    //aDatos[6] = Profesional //6
                    //aDatos[7] = Denominación proyecto //7
                    //aDatos[8] = importe SS //8
                    #endregion

                    #region inicializar variables
                    nPSN_C      = 0;
                    nPSN_J      = 0;
                    nPSN_P      = 0;
                    nSegMesProy = 0;
                    nIDEmpresaNodoProyecto_C = 0;
                    nNodoUsuario             = 0;
                    nEmpresaNodoUsuario      = 0;
                    nNodo_C       = 0;
                    nNodo_J       = 0;
                    nNodo_P       = 0;
                    nTipoCambio_C = 0;
                    nTipoCambio_J = 0;
                    nTipoCambio_P = 0;
                    #endregion

                    DataSet ds = Capa_Datos.INCENTIVOSPRODUCTIVIDAD.ObtenerInstanciasProyecto(tr, int.Parse(aDatos[4]), int.Parse(aDatos[1]), int.Parse(aDatos[5]));
                    foreach (DataRow oFila in ds.Tables[0].Rows)
                    {
                        switch (oFila["t305_cualidad"].ToString())
                        {
                        case "C":
                            nPSN_C  = (int)oFila["t305_idproyectosubnodo"];
                            nNodo_C = (int)oFila["t303_idnodo"];
                            nIDEmpresaNodoProyecto_C = (int)oFila["t313_idempresa_nodo"];
                            nTipoCambio_C            = decimal.Parse(oFila["t699_tipocambio"].ToString());
                            break;

                        case "J":
                            nPSN_J        = (int)oFila["t305_idproyectosubnodo"];
                            nNodo_J       = (int)oFila["t303_idnodo"];
                            nTipoCambio_J = decimal.Parse(oFila["t699_tipocambio"].ToString());
                            break;

                        case "P":
                            nPSN_P        = (int)oFila["t305_idproyectosubnodo"];
                            nNodo_P       = (int)oFila["t303_idnodo"];
                            nTipoCambio_P = decimal.Parse(oFila["t699_tipocambio"].ToString());
                            break;
                        }
                        if (nNodoUsuario == 0)
                        {
                            nNodoUsuario = (int)oFila["t303_idnodo_usuario"];
                        }
                        if (nEmpresaNodoUsuario == 0)
                        {
                            nEmpresaNodoUsuario = (int)oFila["t313_idempresa_nodousuario"];
                        }
                    }

                    if (nPSN_C == 0)
                    {
                        sResul           = "Instancia contratante del proyecto económico no existente";
                        bErrorControlado = true;
                        throw (new Exception(sResul));
                    }

                    if (nPSN_P != 0) //Réplica con gestión
                    {
                        nSegMesProy = SEGMESPROYECTOSUBNODO.ExisteSegMesProy(tr, nPSN_P, int.Parse(aDatos[5]));
                        if (nSegMesProy == 0)
                        {
                            sEstadoMes  = SEGMESPROYECTOSUBNODO.EstadoMesACrear(tr, nPSN_P, int.Parse(aDatos[5]));
                            nSegMesProy = SEGMESPROYECTOSUBNODO.Insert(tr, nPSN_P, int.Parse(aDatos[5]), sEstadoMes, 0, 0, false, 0, 0);
                        }
                        DATOECO.Insert(tr, nSegMesProy, Constantes.nIdClaseProductividad, Utilidades.unescape(aDatos[6]), decimal.Parse(aDatos[3]) * nTipoCambio_P, null, null, 4);
                        DATOECO.Insert(tr, nSegMesProy, Constantes.nIdClaseProductividadSS, Utilidades.unescape(aDatos[6]), decimal.Parse(aDatos[8]) * nTipoCambio_P, null, null, 4);
                    }
                    else if (nNodo_C == nNodoUsuario) //El usuario pertenece a la Contratante
                    {
                        nSegMesProy = SEGMESPROYECTOSUBNODO.ExisteSegMesProy(tr, nPSN_C, int.Parse(aDatos[5]));
                        if (nSegMesProy == 0)
                        {
                            sEstadoMes  = SEGMESPROYECTOSUBNODO.EstadoMesACrear(tr, nPSN_C, int.Parse(aDatos[5]));
                            nSegMesProy = SEGMESPROYECTOSUBNODO.Insert(tr, nPSN_C, int.Parse(aDatos[5]), sEstadoMes, 0, 0, false, 0, 0);
                        }
                        DATOECO.Insert(tr, nSegMesProy, Constantes.nIdClaseProductividad, Utilidades.unescape(aDatos[6]), decimal.Parse(aDatos[3]) * nTipoCambio_C, null, null, 4);
                        DATOECO.Insert(tr, nSegMesProy, Constantes.nIdClaseProductividadSS, Utilidades.unescape(aDatos[6]), decimal.Parse(aDatos[8]) * nTipoCambio_C, null, null, 4);
                    }
                    else //Réplica sin gestión
                    {
                        //Para la réplica sin gestión
                        if (nNodo_J == 0) //no existe la réplica sin gestión, por lo que hay que crearla.
                        {
                            #region Creación de la instancia de proyecto
                            int     nCountManiobraTipo1 = 0, idNodoAuxManiobra = 0, nCountSubnodosNoManiobra = 0, idNodoAuxDestino = 0, idSubNodoGrabar = 0;
                            int     nResponsablePSN = 0;
                            DataSet dsSubnodos      = PROYECTOSUBNODO.ObtenerSubnodosParaReplicar(tr, nNodoUsuario);
                            foreach (DataRow oFila in dsSubnodos.Tables[0].Rows)
                            {
                                if ((byte)oFila["t304_maniobra"] == 1)
                                {
                                    nCountManiobraTipo1++;
                                    idNodoAuxManiobra = (int)oFila["t304_idsubnodo"];
                                }
                                else
                                {
                                    nCountSubnodosNoManiobra++;
                                    idNodoAuxDestino = (int)oFila["t304_idsubnodo"];
                                }
                            }

                            if (nCountSubnodosNoManiobra == 1) //si solo hay un subnodo en el nodo, que la réplica se haga a ese subnodo.
                            {
                                idSubNodoGrabar = idNodoAuxDestino;
                            }
                            else
                            {
                                if (nCountManiobraTipo1 == 0)
                                {
                                    NODO oNodo2 = NODO.SelectEnTransaccion(tr, nNodoUsuario);
                                    nResponsablePSN = oNodo2.t314_idusuario_responsable;
                                    //crear subnodo maniobra
                                    idSubNodoGrabar = SUBNODO.Insert(tr, "Proyectos a reasignar", nNodoUsuario, 0, true, 1, oNodo2.t314_idusuario_responsable, null);
                                }
                                else
                                {
                                    if (nCountManiobraTipo1 > 1)
                                    {
                                        ds.Dispose();
                                        throw (new Exception("El número de subnodos de maniobra es " + nCountManiobraTipo1.ToString() + " en el nodo " + nNodoUsuario.ToString() + ". Por favor avise al administrador."));
                                    }

                                    if (ds.Tables[0].Rows.Count - 1 > 1 || ds.Tables[0].Rows.Count - 1 == 0)
                                    {
                                        idSubNodoGrabar = idNodoAuxManiobra;
                                    }
                                    else
                                    {
                                        idSubNodoGrabar = idNodoAuxDestino;
                                    }
                                }
                            }
                            ds.Dispose();

                            if (nResponsablePSN == 0)
                            {
                                NODO oNodo3 = NODO.SelectEnTransaccion(tr, nNodoUsuario);
                                nResponsablePSN = oNodo3.t314_idusuario_responsable;
                            }
                            if (nTipoCambio_J == 0)
                            {
                                //hay que obtener el tipo de cambio de la moneda por defecto del nodo en el mes del incentivo.
                                nTipoCambio_J = NODO.getTipocambioMonedaNodoMes(tr, nNodoUsuario, int.Parse(aDatos[5]));
                            }
                            nPSN_J = PROYECTOSUBNODO.Insert(tr, int.Parse(aDatos[4]), idSubNodoGrabar, false, "J",
                                                            false, nResponsablePSN, Utilidades.unescape(aDatos[7]), "X", "X",
                                                            false, false, false, false, false, "", "",
                                                            "", null, null, null, null, null, null, false, 0);
                            #endregion
                        }

                        nSegMesProy = SEGMESPROYECTOSUBNODO.ExisteSegMesProy(tr, nPSN_J, int.Parse(aDatos[5]));
                        if (nSegMesProy == 0)
                        {
                            sEstadoMes  = SEGMESPROYECTOSUBNODO.EstadoMesACrear(tr, nPSN_J, int.Parse(aDatos[5]));
                            nSegMesProy = SEGMESPROYECTOSUBNODO.Insert(tr, nPSN_J, int.Parse(aDatos[5]), sEstadoMes, 0, 0, false, 0, 0);
                        }

                        DATOECO.Insert(tr, nSegMesProy, Constantes.nIdClaseProductividad, Utilidades.unescape(aDatos[6]), decimal.Parse(aDatos[3]) * nTipoCambio_J, null, null, 4);
                        DATOECO.Insert(tr, nSegMesProy, Constantes.nIdClaseProductividadSS, Utilidades.unescape(aDatos[6]), decimal.Parse(aDatos[8]) * nTipoCambio_J, null, null, 4);


                        //Para la contratante (se añade el nodo destino)
                        nSegMesProy = SEGMESPROYECTOSUBNODO.ExisteSegMesProy(tr, nPSN_C, int.Parse(aDatos[5]));
                        if (nSegMesProy == 0)
                        {
                            sEstadoMes  = SEGMESPROYECTOSUBNODO.EstadoMesACrear(tr, nPSN_C, int.Parse(aDatos[5]));
                            nSegMesProy = SEGMESPROYECTOSUBNODO.Insert(tr, nPSN_C, int.Parse(aDatos[5]), sEstadoMes, 0, 0, false, 0, 0);
                        }
                        DATOECO.Insert(tr, nSegMesProy, (nIDEmpresaNodoProyecto_C == nEmpresaNodoUsuario) ? 4 : 6, Utilidades.unescape(aDatos[6]), (decimal.Parse(aDatos[3]) + decimal.Parse(aDatos[8])) * nTipoCambio_C, nNodoUsuario, null, 4);
                    }

                    Capa_Datos.INCENTIVOSPRODUCTIVIDAD.Registrar(tr, int.Parse(aDatos[0]));
                }

                Conexion.CommitTransaccion(tr);
            }
            catch (Exception ex)
            {
                Conexion.CerrarTransaccion(tr);
                if (bErrorControlado)
                {
                    sResul = ex.Message;
                }
                else
                {
                    sResul = Errores.mostrarError("Error al procesar.", ex);
                }
            }
            finally
            {
                Conexion.Cerrar(oConn);
                if (sResul != "")
                {
                    if (bErrorControlado)
                    {
                        sResul = "ErrorControlado##EC##" + sResul;
                    }
                    throw (new Exception(sResul));
                }
            }

            return("");
        }
        public static SUBNODO Obtener(SqlTransaction tr, int t304_idsubnodo)
        {
            SUBNODO o = new SUBNODO();

            SqlParameter[] aParam = new SqlParameter[1];
            aParam[0]       = new SqlParameter("@t304_idsubnodo", SqlDbType.Int, 4);
            aParam[0].Value = t304_idsubnodo;

            SqlDataReader dr;

            if (tr == null)
            {
                dr = SqlHelper.ExecuteSqlDataReader("SUP_SUBNODO_O", aParam);
            }
            else
            {
                dr = SqlHelper.ExecuteSqlDataReaderTransaccion(tr, "SUP_SUBNODO_O", aParam);
            }

            if (dr.Read())
            {
                if (dr["t304_idsubnodo"] != DBNull.Value)
                {
                    o.t304_idsubnodo = int.Parse(dr["t304_idsubnodo"].ToString());
                }
                if (dr["t304_denominacion"] != DBNull.Value)
                {
                    o.t304_denominacion = (string)dr["t304_denominacion"];
                }
                if (dr["t303_idnodo"] != DBNull.Value)
                {
                    o.t303_idnodo = int.Parse(dr["t303_idnodo"].ToString());
                }
                if (dr["t304_estado"] != DBNull.Value)
                {
                    o.t304_estado = (bool)dr["t304_estado"];
                }
                if (dr["t304_orden"] != DBNull.Value)
                {
                    o.t304_orden = int.Parse(dr["t304_orden"].ToString());
                }
                if (dr["t314_idusuario_responsable"] != DBNull.Value)
                {
                    o.t314_idusuario_responsable = int.Parse(dr["t314_idusuario_responsable"].ToString());
                }
                if (dr["responsable"] != DBNull.Value)
                {
                    o.DesResponsable = (string)dr["responsable"];
                }
                if (dr["t304_maniobra"] != DBNull.Value)
                {
                    o.t304_maniobra = byte.Parse(dr["t304_maniobra"].ToString());
                }
                if (dr["t313_idempresa"] != DBNull.Value)
                {
                    o.t313_idempresa = int.Parse(dr["t313_idempresa"].ToString());
                }
                if (dr["t313_denominacion"] != DBNull.Value)
                {
                    o.t313_denominacion = (string)dr["t313_denominacion"];
                }
            }
            else
            {
                throw (new NullReferenceException("No se ha obtenido ningun dato de SUBNODO"));
            }

            dr.Close();
            dr.Dispose();

            return(o);
        }
        public static void CambioEstructuraCasoA(SqlTransaction tr, int t305_idproyectosubnodo, int t303_idnodo_origen, int t303_idnodo_destino, bool bMantenerResponsables)
        {
            #region Obtención de subnodo para crear el proyectosubnodo
            int nCount = 0;
            int nCountManiobraTipo2  = 0;
            int idSubNodoAuxDestino  = 0;
            int idSubNodoAuxManiobra = 0;
            int idSubNodoGrabar      = 0;

            int    nCountSubnodosNoManiobra = 0;
            int    nResponsableSubNodo      = 0;
            string sDenominacionNodo        = "";

            DataSet dsSubNodos = SUBNODO.CatalogoActivos(tr, t303_idnodo_destino, true);
            foreach (DataRow oSN in dsSubNodos.Tables[0].Rows)
            {
                if ((byte)oSN["t304_maniobra"] == 1)
                {
                    nCount++;
                    idSubNodoAuxManiobra = (int)oSN["t304_idsubnodo"];
                    nResponsableSubNodo  = (int)oSN["t314_idusuario_responsable"];
                    sDenominacionNodo    = oSN["t303_denominacion"].ToString();
                }
                else if ((byte)oSN["t304_maniobra"] == 0)
                {
                    idSubNodoAuxDestino = (int)oSN["t304_idsubnodo"];
                    nCountSubnodosNoManiobra++;
                    nResponsableSubNodo = (int)oSN["t314_idusuario_responsable"];
                    sDenominacionNodo   = oSN["t303_denominacion"].ToString();
                }
                else
                {
                    nCountManiobraTipo2++;
                }
            }
            if (nCountSubnodosNoManiobra == 1) //si solo hay un subnodo en el nodo, que la réplica se haga a ese subnodo.
            {
                idSubNodoGrabar = idSubNodoAuxDestino;
            }
            else
            {
                if (nCount == 0)
                {
                    NODO oNodo = NODO.Select(tr, t303_idnodo_destino);
                    //crear subnodo maniobra
                    idSubNodoGrabar     = SUBNODO.Insert(tr, "Proyectos a reasignar", t303_idnodo_destino, 0, true, 1, oNodo.t314_idusuario_responsable, null);//
                    nResponsableSubNodo = oNodo.t314_idusuario_responsable;
                }
                else
                {
                    if (nCount > 1)
                    {
                        dsSubNodos.Dispose();
                        throw (new Exception("El número de subnodos de maniobra es " + nCount.ToString() + " en el nodo " + sDenominacionNodo + ". Por favor avise al administrador."));
                    }

                    if (dsSubNodos.Tables[0].Rows.Count - 1 - nCountManiobraTipo2 > 1 || dsSubNodos.Tables[0].Rows.Count - 1 - nCountManiobraTipo2 == 0)
                    {
                        idSubNodoGrabar = idSubNodoAuxManiobra;
                    }
                    else
                    {
                        idSubNodoGrabar = idSubNodoAuxDestino;
                    }
                }
            }
            dsSubNodos.Dispose();
            #endregion

            CAMBIOESTRUCTURAPSN.Paso01(tr, t305_idproyectosubnodo, idSubNodoGrabar, (bMantenerResponsables)? null:(int?)nResponsableSubNodo);
            CAMBIOESTRUCTURAPSN.Paso02(tr, t305_idproyectosubnodo, t303_idnodo_origen);
            CAMBIOESTRUCTURAPSN.Paso03(tr, t305_idproyectosubnodo, t303_idnodo_origen);
            CAMBIOESTRUCTURAPSN.Paso04(tr, t305_idproyectosubnodo, t303_idnodo_destino);
            CAMBIOESTRUCTURAPSN.Paso05(tr, t305_idproyectosubnodo, t303_idnodo_destino);
            CAMBIOESTRUCTURAPSN.Paso06(tr, t305_idproyectosubnodo, t303_idnodo_origen, t303_idnodo_destino);
            CAMBIOESTRUCTURAPSN.Paso07(tr, t305_idproyectosubnodo, t303_idnodo_origen, t303_idnodo_destino);
        }
        /// <summary>
        /// Obtiene el subnodo por defecto de un nodo para crear un PE.
        /// Si no existe, crea uno de maniobra
        /// </summary>
        /// <param name="t303_idnodo"></param>
        /// <returns></returns>
        public static int GetSubNodoDefecto(int t303_idnodo)
        {
            #region Obtención de subnodo para crear el proyectosubnodo
            int nCount = 0;
            int nCountManiobraTipo2  = 0;
            int idSubNodoAuxDestino  = 0;
            int idSubNodoAuxManiobra = 0;
            int idSubNodoGrabar      = 0;

            int     nCountSubnodosNoManiobra = 0;
            int     nResponsableSubNodo      = 0;
            string  sDenominacionNodo        = "";
            DataSet dsSubNodos = null;

            try
            {
                dsSubNodos = SUBNODO.CatalogoActivos(null, t303_idnodo, true);
                foreach (DataRow oSN in dsSubNodos.Tables[0].Rows)
                {
                    if ((byte)oSN["t304_maniobra"] == 1)
                    {
                        nCount++;
                        idSubNodoAuxManiobra = (int)oSN["t304_idsubnodo"];
                        nResponsableSubNodo  = (int)oSN["t314_idusuario_responsable"];
                        sDenominacionNodo    = oSN["t303_denominacion"].ToString();
                    }
                    else if ((byte)oSN["t304_maniobra"] == 0)
                    {
                        idSubNodoAuxDestino = (int)oSN["t304_idsubnodo"];
                        nCountSubnodosNoManiobra++;
                        nResponsableSubNodo = (int)oSN["t314_idusuario_responsable"];
                        sDenominacionNodo   = oSN["t303_denominacion"].ToString();
                    }
                    else
                    {
                        nCountManiobraTipo2++;
                    }
                }
                if (nCountSubnodosNoManiobra == 1) //si solo hay un subnodo en el nodo, que la réplica se haga a ese subnodo.
                {
                    idSubNodoGrabar = idSubNodoAuxDestino;
                }
                else
                {
                    if (nCount == 0)
                    {
                        NODO oNodo = NODO.Select(null, t303_idnodo);
                        //crear subnodo maniobra
                        idSubNodoGrabar     = SUBNODO.Insert(null, "Proyectos a reasignar", t303_idnodo, 0, true, 1, oNodo.t314_idusuario_responsable, null);
                        nResponsableSubNodo = oNodo.t314_idusuario_responsable;
                    }
                    else
                    {
                        //if (nCount > 1)
                        //{
                        //    dsSubNodos.Dispose();
                        //    throw (new Exception("El número de subnodos de maniobra es " + nCount.ToString() + " en el nodo " + sDenominacionNodo + ". Por favor avise al administrador."));
                        //}

                        if (dsSubNodos.Tables[0].Rows.Count - 1 - nCountManiobraTipo2 > 1 || dsSubNodos.Tables[0].Rows.Count - 1 - nCountManiobraTipo2 == 0)
                        {
                            idSubNodoGrabar = idSubNodoAuxManiobra;
                        }
                        else
                        {
                            idSubNodoGrabar = idSubNodoAuxDestino;
                        }
                    }
                }
                dsSubNodos.Dispose();
                #endregion
                return(idSubNodoGrabar);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (dsSubNodos != null)
                {
                    dsSubNodos.Dispose();
                }
            }
        }