Esempio n. 1
0
function public_insertar($conexion, $registro)
{  
  // definicion de globales
  global $public_tipo_links; 
  global $public_dir_docs;
  global $_FILES;

  //--------------------------------------------------------------------
  // COPIA/BORRA DOCUMENTO SI ESTÁ DEFINIDO
  //--------------------------------------------------------------------
  // fija link y nombre de documento
  $nombre_fichero = $public_dir_docs.$registro['id_ref_bibtex'].'.pdf';
  
  // verifica si insertamos uno nuevo
  if (isset($_FILES['fichero_pub']) && strlen($_FILES['fichero_pub']['name'])>0) {
   // admite solo pdfs
   if ($_FILES['fichero_pub']['type']=='application/pdf') {
     // copia fichero a directorio de curriculum renombrandolo
     copy($_FILES['fichero_pub']['tmp_name'],$nombre_fichero);
   }  
  }
  // verifica si existe interno y lo borramos si procede
  if (($registro['tipo_link'] != $public_tipo_links['Interno']) &&
     (file_exists($nombre_fichero)))
  {
    unlink($nombre_fichero);
  }
  //---------------------------------------------
  // Actualiza valores de la referencia
  //---------------------------------------------
  // prepara datos para insertar desde web
  $id_ref_bibtex = addslashes($registro['id_ref_bibtex']);
  if ($registro['tipo_link'] == $public_tipo_links['Externo']) {
      $link_refer = addslashes($registro['link_refer']);
    }
  else if (($registro['tipo_link'] == $public_tipo_links['Interno'])&&
           (file_exists($nombre_fichero)))
    {
      $link_doc_interno = 'docs/'.$registro['id_ref_bibtex'].'.pdf'; 
      $link_refer = $link_doc_interno;
    }  
  $publicar = (AUX_estado_es_visible($registro['estado']) == 1)?  1:0;
  
  // chequea si hay que insertar un nuevo registro o solo actualizarlo
  if ($registro['id_ref'] == 0) {
     // construye la consulta de Insercion
     $consulta_public ='INSERT INTO referencias(id_ref_bibtex, tipo, visible,'.
       ' tipo_link, link_referencia, idioma, estado, tipo_bibtex) VALUES("'.
       $id_ref_bibtex.'","'.$registro['tipo'].'", '.$publicar.', "'.
       $registro['tipo_link'].'", "'.$link_refer.'","'.$registro['idioma'].
       '","'.$registro['estado'].'", "'.$registro['tipo'].'")';
  }
  else {
     // construye la consulta de actualizacion
     $consulta_public = 'UPDATE referencias SET id_ref_bibtex="'.
       $id_ref_bibtex.'", tipo="'.$registro['tipo'].'", tipo_bibtex="'.
       $registro['tipo'].'", visible='.$publicar.', tipo_link="'.
       $registro['tipo_link'].'", link_referencia="'.$link_refer.
       '", idioma="'.$registro['idioma'].'", estado="'.$registro['estado']
       .'" WHERE id_referencia='.$registro['id_ref'];
  }
  
  // realiza consulta de miembro
  $resultado = mysql_query($consulta_public, $conexion);

  // si da error, devuelve 0
  if (!$resultado) {
   echo "Error de consulta ".$consulta_public;
   return 0;
  }

  // obtiene el valor del elemento insertado/actualizado
  if ($registro['id_ref'] == 0) {
     $id_referencia = mysql_insert_id(); 
     
     // inserta una referencia de campo nueva
     $consulta_id = 'SELECT MAX(id_campos) FROM ref_relacion';
     $resultado =  mysql_query($consulta_id, $conexion);
     $identificador_tmp = mysql_fetch_row($resultado);
     $id_campo = $identificador_tmp[0] + 1;
     
     $consulta_cross = 'INSERT INTO ref_relacion(id_ref,'.
      'id_campos, referencia_cruzada, id_ref_cruzada) VALUES('.
      $id_referencia.','.$id_campo.',0,0)';
      
     $resultado =  mysql_query($consulta_cross, $conexion);
     
     if (! $resultado) {
      echo "Error de consulta ".$consulta_cross;
      return 0;           
     }         
  }  
  else {
     $id_referencia = $registro['id_ref'];
     
     // obtiene el id_campos para el registro actualizado
     $consulta_id = 'SELECT id_campos FROM ref_relacion '.
      'WHERE referencia_cruzada=0 AND id_ref='.$id_referencia;
     $resultado =  mysql_query($consulta_id, $conexion);
     $identificador_tmp = mysql_fetch_row($resultado);
     $id_campo = $identificador_tmp[0];     
  }
  
  //---------------------------------------------  
  // Actualización de los campos de la referencia
  //---------------------------------------------
  // variables de fecha
  $fecha_publicacion = array();
  // variable de sobreescritura de tipo de busqueda
  $tipo_busqueda = $registro['tipo'];
  // array de campos
  $lista_campos = array();

  // insertar toda la informacion de los campos en un array
  for ($i=1; $i<= $registro['numero_campos'];$i++) {
    $campo = $registro["id_campo_c_$i"];
    $lista_campos[$campo]['borrar'] = $registro["id_campo_b_$i"];
    $lista_campos[$campo]['modificar'] = $registro["id_campo_m_$i"];
    $lista_campos[$campo]['valor'] = addslashes($registro["id_campo_t_$i"]);
  }
  
  // recorremos lista borrando todos los marcados como 'borrar' o 'modificar'
  // y actualizando el valor del resto
  foreach ($lista_campos as $campo => $valor) {
    if ($lista_campos[$campo]['borrar'] == 1) {
       // si campo es crossref, borramos el enlace
       if ($campo == 'crossref') {
          Borra_Crossref($id_referencia, $conexion);
       }
       
       // construye consulta de borrado
       $consulta_campo='DELETE FROM ref_campos WHERE id_campo_ref='.
         $id_campo.' AND campo="'.$campo.'"';
             
    } elseif ($lista_campos[$campo]['modificar'] == 1) {
        $campo_modificado = AUX_campo_renombrado($campo);

        // realiza consulta de borrado de las dos posibilidades de campo
        // !! si eres torpe y no te das cuenta, adios a uno de los campos !!!
        $consulta_campo='DELETE FROM ref_campos WHERE id_campo_ref='.
         $id_campo.' AND (campo="'.$campo.'" OR '.'campo="'.
         $campo_modificado.'")';
    } else {
       // si campo es crossref, actualizamos su valor
       if ($campo == 'crossref') {
          Borra_Crossref($id_referencia, $conexion);
          Inserta_Crossref($lista_campos[$campo]['valor'], $id_referencia, $conexion);
       }
       // construye consulta de update
       $consulta_campo='UPDATE ref_campos SET valor="'.
         $lista_campos[$campo]['valor'].'" WHERE id_campo_ref='.$id_campo.
         ' AND campo="'.$campo.'"';
      
       AUX_verifica_campos_especiales($campo, $lista_campos[$campo]['valor'],
          $fecha_publicacion, $tipo_busqueda);             
    }

    // ejecuta consulta para uno de los cuatro casos posibles
    $resultado = mysql_query($consulta_campo, $conexion);
      
    // si da error, saca un mensaje
    if (!$resultado) {
         echo "No se pudo ejecutar la consulta ".$consulta_campo;
    }    
  }  
  
  // por ultimo, recorre una ultima vez la lista para insertar
  // con el nuevo nombre aquellos campos que hayan sido renombrados
  foreach ($lista_campos as $campo => $valor) {
    if ($lista_campos[$campo]['modificar'] == 1) {
      $campo_modificado = AUX_campo_renombrado($campo); 
      
      // Verificamos gestion de crossref
      if ($campo_modificado == 'crossref') {
        Inserta_Crossref($lista_campos[$campo]['valor'], $id_referencia, $conexion);

      } else if ($campo_modificado == 'OPTcrossref') {
         Borra_Crossref($id_referencia, $conexion);
      }

      // construye consulta de insercion     
      $consulta_campo='INSERT INTO ref_campos(id_campo_ref, campo, valor) '.
         'VALUES ('.$id_campo.',"'.$campo_modificado.'","'.
         $lista_campos[$campo]['valor'].'")'; 
      // ejecuta consulta para uno de los tres casos posibles
      $resultado = mysql_query($consulta_campo, $conexion);
      
      // si da error, saca un mensaje
      if (!$resultado) {
         echo "No se pudo ejecutar la consulta ".$consulta_campo;
      }

       AUX_verifica_campos_especiales($campo_modificado, 
          $lista_campos[$campo]['valor'],$fecha_publicacion, $tipo_busqueda);          
    } 
  }  

  //------------------------------------------------------------  
  // inserta el nuevo campo si no existe ya y no está vacío.
  // Esto se tiene que hacer despues de haber procesado los demas
  // para poder chequear que no existe ya el nombre a insertar
  //------------------------------------------------------------
  
  if (strlen($registro["nuevo_campo"]) > 0) {
     $campo_existe = false;
     $nuevo_campo = $registro["nuevo_campo"];
     $campo_modificado = AUX_campo_renombrado($nuevo_campo);   
           
     // verifica que campo no existe
     if ((array_key_exists($nuevo_campo,$lista_campos)) AND 
        ($lista_campos["$nuevo_campo"]['modificar'] == 0) AND
        ($lista_campos["$nuevo_campo"]['borrar'] == 0))
      { $campo_existe = true;}
     
     // verifica que no se ha renombrado uno existente con nombre final igual
     if ((array_key_exists($campo_modificado,$lista_campos)) AND 
        ($lista_campos["$campo_modificado"]['modificar'] == 1))
     { $campo_existe = true;}
     
     // verifica que no es uno prohibido
     if (($nuevo_campo == 'OPTidioma')||($nuevo_campo == 'OPTestado'))
     { $campo_existe = true; }
     
     if (! $campo_existe)
     {
       // prepara valores
       $campo_nuevo = addslashes($registro["nuevo_campo"]);
       $valor_nuevo = addslashes($registro["nuevo_valor"]);

       // Verificamos gestion de crossref
       if ($campo_nuevo == 'crossref')
       {
         Inserta_Crossref($valor_nuevo, $id_referencia, $conexion);
       }

       AUX_verifica_campos_especiales($campo_nuevo, $valor_nuevo,
          $fecha_publicacion, $tipo_busqueda);
       
       // construye consulta
       $consulta_insertar = 'INSERT INTO ref_campos(id_campo_ref, campo, valor) '.
         'VALUES ('.$id_campo.',"'.$campo_nuevo.'","'.$valor_nuevo.'")';
       // ejecuta consulta   
       $resultado = mysql_query($consulta_insertar, $conexion);  
       
       // si da error, saca un mensaje
       if (!$resultado)
       {
           echo "No se pudo ejecutar la consulta ".$consulta_insertar;
       }
     }
  }

  //------------------------------------------------------------------------  
  // Comprobación. En caso que NO HAYA DEFINIDO NINGUN CAMPO. Se inserta uno
  // Dummy Author para poder acceder al registro desde el web.
  //------------------------------------------------------------------------
  else if ($registro['numero_campos'] == 0)
  {
     // construye consulta
     $consulta_insertar = 'INSERT INTO ref_campos(id_campo_ref, campo, valor) '.
       'VALUES ('.$id_campo.',"author","Sin Definir")';
       
     // ejecuta consulta   
     $resultado = mysql_query($consulta_insertar, $conexion);
     
     // si da error, saca un mensaje
     if (!$resultado)
     {
         echo "No se pudo ejecutar la consulta ".$consulta_insertar;
     }       
  }

  //----------------------------------------------------------------------  
  // Por ultimo, actualizamos la fecha de la referencia y tipo de busqueda
  //----------------------------------------------------------------------  
  // calcula la nueva fecha
  $nueva_fecha = Calcula_fecha_publicacion($fecha_publicacion);
  
  // actualiza fecha con crossref si no tiene
  if ($nueva_fecha == "'9999-01-01'")
  {
     $consulta_crossref = 'SELECT fecha_publicacion '.
      'FROM ref_relacion LEFT JOIN referencias '.
      'ON referencias.id_referencia=ref_relacion.id_ref_cruzada '.
      'WHERE referencia_cruzada=1 AND id_ref='.$id_referencia;
     
     $resultado = mysql_query($consulta_crossref, $conexion);
     
     if (mysql_num_rows($resultado) > 0)
     {
       $fecha_crossref = mysql_fetch_row($resultado);
       $nueva_fecha = $fecha_crossref[0];
     }
  }
  
  // construye consulta de actualizacion
  $consulta_fecha = 'UPDATE referencias SET fecha_publicacion='.$nueva_fecha.
    ', tipo="'.$tipo_busqueda.'" WHERE id_referencia='.$id_referencia;

  // ejecuta consulta   
  $resultado = mysql_query($consulta_fecha, $conexion);
     
  // si da error, saca un mensaje
  if (!$resultado)
  {
      echo "No se pudo ejecutar la consulta ".$consulta_fecha;
  } 
          
  // devuelve el valor del elemento insertado
  return $id_referencia;
} 
function inserta_BD_referencias($datosref, &$acciones)
{

  global $BASE_DATOS;
  global $USER_BD;
  global $PASS_BD;
  // incluido desde common_pub;
  global $public_estado_defecto;
  global $public_rel_tipos;
  global $public_tipos_bibtex;
  
  // asigna los registros y los sinonimos
  $registros = array();
  $registros = $datosref['bib'];
  $sinonimos = array();
  $sinonimos = $datosref['sin'];
  
  // lista de corssref
  $lista_crossref = array();
  
  // contador de avisos
  $contador_acciones = 1;
  
  // conecta a Base de Datos MySQL
  $conexion = mysql_connect("localhost",$USER_BD,$PASS_BD);
  // verifica si se abrió conexion
  if (!$conexion)
  {
     echo "Error al conectarse a la base de datos MYSQL\n";
     return;
  }
  
  // selecciona base de datos
  mysql_select_db($BASE_DATOS,$conexion);
  
  // -----------------------------------------------
  // inserta todos los sinonimos en la base de datos
  // -----------------------------------------------
  for (reset($sinonimos); $sinonimo = key($sinonimos); next($sinonimos))
  {
    if (Existe_Sinonimo_en_BD($conexion, $sinonimo))
    {
     $consulta_sinonimo = 'UPDATE ref_cadenas SET valor="'.$sinonimos[$sinonimo]
      .'" WHERE cadena="'.$sinonimo.'"';
    }
    else
    {
     $consulta_sinonimo = 'INSERT INTO ref_cadenas(cadena, valor) VALUES("'.
        $sinonimo.'","'.$sinonimos[$sinonimo].'")';
    }
    // ejecuta consulta
    $resultado = mysql_query($consulta_sinonimo,$conexion);
    
    // si dio error, insertalo en la lista de acciones
    if (!$resultado)
    {
        $acciones[$contador_acciones] = array (0,"ERROR de sinonimos: ".
                  $sinonimo." .No se pudo realizar la consulta ".
                  $consulta_sinonimo);
        $contador_acciones++;
    }
   
  }
  
  
  // recorre todos los elementos del array por tipo e identificador
  for (reset($registros); $tipo_reg = key($registros); next($registros))
  {
   for (reset($registros[$tipo_reg]); 
        $id_ref_bibtex = key($registros[$tipo_reg]); 
        next($registros[$tipo_reg]))
   {
      // ------------------------------------------------------
      // Prepara los valores de la referencia
      // ------------------------------------------------------
      // calcula la fecha de publicacion
      $fecha_publicacion = Calcula_fecha_publicacion(
                                        $registros[$tipo_reg][$id_ref_bibtex]);
      // mira fecha de referencia cruzada si no tiene una dada
      if (($fecha_publicacion == "'9999-01-01'") &&
          (strlen($registros[$tipo_reg][$id_ref_bibtex]['crossref']) > 0))
      {
         $id_ref_crossref = Quitar_Llaves(
                            $registros[$tipo_reg][$id_ref_bibtex]['crossref']);
	 
         for (reset($public_tipos_bibtex); 
              $tipo_pub = current($public_tipos_bibtex);
              next($public_tipos_bibtex))
         {
           if (array_key_exists($tipo_pub, $registros))
           {
             if (array_key_exists($id_ref_crossref, $registros[$tipo_pub]))
             {
               $fecha_publicacion = Calcula_fecha_publicacion(
                                       $registros[$tipo_pub][$id_ref_crossref]);
             }
           }
         }
      }                                  
                                        
      // determina idioma
      $idioma_pub = Determina_Idioma_Publicacion ($id_ref_bibtex, 
        $registros[$tipo_reg][$id_ref_bibtex]['OPTidioma']);

      // determina enlace si está presente
      $link_referencia_pub = Quitar_Llaves(
                           $registros[$tipo_reg][$id_ref_bibtex]['OPTenlace']);
      $tipo_link_pub = Determina_Tipo_Enlace($link_referencia_pub);
      
      // obtiene estado y visibilidad de publicacion
      if (strlen($registros[$tipo_reg][$id_ref_bibtex]['OPTestado'])>0)
      {
        // convierte a uppercase y quitale llaves
        $estado_pub = Quitar_Llaves(
                            $registros[$tipo_reg][$id_ref_bibtex]['OPTestado']);
        $estado_pub = strtoupper($estado_pub);
      }
      else
      { // si no está definido OPTestado, sobreescribelo como el valor
        // de estado por defecto
        $estado_pub = $public_estado_defecto;
      }

      $visibilidad = AUX_estado_es_visible($estado_pub);
      
      //  Da un aviso y no inserta si no es un estado valido
      if ($visibilidad == -1)
      {
         $acciones[$contador_acciones] = array (0,"ERROR de actualización: ".
               $id_ref_bibtex." tiene un estado inválido");
         $contador_acciones++;
         continue;         
      }

      // verifica el tipo de publicacion
      if (strlen($registros[$tipo_reg][$id_ref_bibtex]['OPTtipopub'])>0)
      {
         // verifica que es un tipo valido
         $tipo_formateado = trim(strtoupper(
          $registros[$tipo_reg][$id_ref_bibtex]['OPTtipopub']));
         
         for (reset($public_rel_tipos); $tipo_web = key($public_rel_tipos);
          next($public_rel_tipos))
         {
            if (in_array($tipo_formateado,$public_rel_tipos[$tipo_web]))
            {
               $tipo_busqueda = $tipo_formateado;
            }
         }
      }
      else
      {
         $tipo_busqueda = $tipo_reg;
      }

      // ------------------------------------------------------------
      // Ejecuta la consulta de Insercion/Actualizacion de referencia
      // ------------------------------------------------------------      
      // chequea si ya hay un registro con el mismo id_ref_bibtex
      $consulta_identificacion = "SELECT id_ref, id_campos ".
        'FROM referencias LEFT JOIN ref_relacion '.
        'ON referencias.id_referencia = ref_relacion.id_ref '.
        'WHERE referencia_cruzada=0 AND id_ref_bibtex ="'.$id_ref_bibtex.'"';
      
      // realiza consulta en Base de datos
      $resultado = mysql_query($consulta_identificacion, $conexion);      
      
      // si hay identificador, es una actualización
      if ($identificador_tmp = mysql_fetch_row($resultado))
      {
         $id_ref   = $identificador_tmp[0];
         $id_campo = $identificador_tmp[1];
         
         // borra todas las referencias cruzadas
         $consultas_borrar[1] = "DELETE FROM ref_relacion WHERE ".
          "referencia_cruzada=1 AND id_ref=".$id_ref;         
         // Borra todos los campos del registro
         $consultas_borrar[2] = "DELETE FROM ref_campos WHERE id_campo_ref=".
           $id_campo;
           
         // ejecuta consultas
         for ($i=1; $i<3; $i++)
         {
            $resultado = mysql_query($consultas_borrar[$i], $conexion);
            if (!$resultado)
            {
               $acciones[$contador_acciones] = array (0,"ERROR de actualización: ".
                  $id_ref_bibtex." .No se pudo realizar la consulta ".
                  $consultas_borrar[$i]);
               $contador_acciones++;
            }
         } 
         
         // realiza la consulta de actualización
         $consulta_update = "UPDATE referencias SET tipo='".$tipo_busqueda.
           "', tipo_bibtex='".$tipo_reg."', fecha_publicacion=".
           $fecha_publicacion.", visible=".$visibilidad.', idioma="'.
           $idioma_pub.'", estado="'.$estado_pub.'",tipo_link="'.$tipo_link_pub.
           '", link_referencia="'.$link_referencia_pub.
           '" WHERE id_referencia='.$id_ref;
        
         // ejecuta consulta
         $resultado = mysql_query($consulta_update, $conexion); 
         
         // actualiza el log de acciones
         if (!$resultado)
         {
            $acciones[$contador_acciones] = array (0,"ERROR de actualización: ".
               $id_ref_bibtex." .No se pudo realizar la consulta ".
               $consulta_update);
         } 
         else
         {
            $acciones[$contador_acciones] = array(1,
              "Actualización de <a href='public_editar.php?id_ref=".
              $id_ref."'>".$id_ref_bibtex.
              "</a> realizada correctamente");
         }
         $contador_acciones++;
      }
      else // si no, es una inserción
      {
   
         // inserta el registro en la TABLA referencias
         $consulta_insertar = 'INSERT INTO referencias(id_ref_bibtex, tipo,'.
           'tipo_bibtex, fecha_publicacion, visible, idioma, estado,'.
           'tipo_link, link_referencia) values("'.
           $id_ref_bibtex.'","'.$tipo_busqueda.'","'.$tipo_reg.'",'.
           $fecha_publicacion .','.$visibilidad.',"'.$idioma_pub.'","'.
           $estado_pub.'","'.$tipo_link_pub.'","'.$link_referencia_pub.'")';
   
         // inserta consulta en Base de datos
         $resultado = mysql_query($consulta_insertar, $conexion);

         // actualiza el log de acciones
         if (!$resultado)
         {
            $acciones[$contador_acciones] = array (0,"ERROR de inserción: ".
               $id_ref_bibtex." .No se pudo realizar la consulta ".
               $consulta_insertar);
            $id_ref = 0;
         } 
         else
         {
            //obtiene el valor de ID de la insercion
            $id_ref = mysql_insert_id();
              
            $acciones[$contador_acciones] = array(2,
            "Inserción de <a href='public_editar.php?id_ref=".$id_ref.
            "'>".$id_ref_bibtex."</a> realizada correctamente");
         }
         $contador_acciones++;
      
         if ($id_ref != 0)
         {
           // obtiene un identificador valido para los campos e inserta
           // la referencia general con ese identificador
           $consulta_id = 'SELECT MAX(id_campos) FROM ref_relacion';
           $resultado =  mysql_query($consulta_id, $conexion);
           $identificador_tmp = mysql_fetch_row($resultado);
           $id_campo = $identificador_tmp[0] + 1;
           
           $consulta_cross = 'INSERT INTO ref_relacion(id_ref,'.
            'id_campos, referencia_cruzada, id_ref_cruzada) VALUES('.
            $id_ref.','.$id_campo.',0,0)';
            
           $resultado =  mysql_query($consulta_cross, $conexion);
           
           if (! $resultado)
           {
            $acciones[$contador_acciones] = array (0,"ERROR de inserción: ".
               $id_ref_bibtex." .No se pudo realizar la consulta ".
               $consulta_cross);
            $contador_acciones++;             
           }
         }
      }

      // ------------------------------------------------------------
      // Ejecuta la consulta de Insercion de Campos
      // ------------------------------------------------------------ 
      // verifica si se inserto correctamente
      if ($acciones[$contador_acciones - 1][0] != 0)
      {
        
         // recorre todos los campos e insertalos en
         // la tabla REF_CAMPOS salvo el campo OPTidioma y OPTestado
         for (reset($registros[$tipo_reg][$id_ref_bibtex]); 
                    $campo = key($registros[$tipo_reg][$id_ref_bibtex]); 
                    next($registros[$tipo_reg][$id_ref_bibtex]))
         {
            if (($campo != 'OPTidioma')&&
                ($campo != 'OPTestado')&&
                ($campo != 'OPTenlace'))
            {
               // obtiene valor de array
               $valor = $registros[$tipo_reg][$id_ref_bibtex][$campo];
               $valor = addslashes($valor);
               
               // prepara la consulta de insercion
               $consulta_insertar = "INSERT INTO ref_campos(id_campo_ref,".
                "campo, valor) values(".$id_campo.",'".$campo."','".$valor.
                "') ";
               
               // inserta consulta en BD
               $resultado = mysql_query($consulta_insertar, $conexion); 
               
               // verifica resultado
               if (!$resultado)
               {
                  $acciones[$contador_acciones] =array (0, 
                     "ERROR de inserción de campo: ".
                     $id_ref_bibtex." .No se pudo realizar la consulta ".
                     $consulta_insertar);
                  $contador_acciones++;
               }
               
               // si el campo es un crossref, insertamos referencia cruzada
               if ($campo == 'crossref')
               {
	         $lista_crossref[$valor]=$id_ref;
               }
               
            }  
         }
      }
      
      // Da un aviso si el registro es visible y no tiene fecha
      if (($visibilidad == 1)&&($fecha_publicacion == "'9999-01-01'"))
      {
         $acciones[$contador_acciones] = array (3,"AVISO de actualización: ".
               $id_ref_bibtex." esta publicado sin fecha");
         $contador_acciones++;         
      }            
   }
  }
  
  // inserta todas las crossref
  for (reset($lista_crossref);
       $valor = key($lista_crossref);
       next($lista_crossref))
  {
     $id_ref = $lista_crossref[$valor];
     $resultado = Inserta_Crossref($valor, $id_ref, $conexion);
                
     if ($resultado == 1)
     {
                  $acciones[$contador_acciones] =array (0, 
                     "ERROR realizando referencia cruzada: ".
                     $id_ref_bibtex." .No se pudo realizar la consulta");
                  $contador_acciones++;
     }
     else if ($resultado == 2)
     {
                  $acciones[$contador_acciones] =array (0, 
                     "ERROR realizando referencia cruzada: ".
                     $id_ref_bibtex." .No se encontro destino -> ".$valor);
                  $contador_acciones++;                  
     }
  }  
  // cierra conexion MySQL
  mysql_close($conexion);

}