source: extensions/autoupdate/branches/2.0/include/autoupdate.class.php @ 10029

<?php

if (!defined('PHPWG_ROOT_PATH')) die('Hacking attempt!');

class autoupdate
{
  var $types = array();
  var $plugins;
  var $themes;
  var $languages;
  var $missing = array();
  var $default_plugins = array();
  var $default_themes = array();

  function autoupdate()
  {
    if (version_compare(PHPWG_VERSION, '2.1', '>='))
    {
      $this->types = array('plugins', 'themes');
      $this->default_themes = array('clear', 'dark', 'Sylvia');
      $this->default_plugins = array('admin_multi_view', 'c13y_upgrade', 'language_switch', 'LocalFilesEditor');
    }
    else
    {
      $this->types = array('plugins');
      $this->default_plugins = array('admin_multi_view', 'c13y_upgrade', 'language_switch', 'LocalFilesEditor', 'event_tracer', 'admin_advices', 'add_index');
    }

    foreach ($this->types as $type)
    {
      include_once(PHPWG_ROOT_PATH.'admin/include/'.$type.'.class.php');
      $this->$type = new $type();
    }
  }

  function check_piwigo_upgrade()
  {
    $_SESSION['need_update'] = null;

    if (preg_match('/(\d+\.\d+)\.(\d+)/', PHPWG_VERSION, $matches)
      and @fetchRemote(PHPWG_URL.'/download/all_versions.php', $result))
    {
      $all_versions = @explode("\n", $result);
      $new_version = trim($all_versions[0]);
      $_SESSION['need_update'] = version_compare(PHPWG_VERSION, $new_version, '<');
    }
  }

  function get_server_extensions($version=PHPWG_VERSION)
  {
    global $user;

    // Retrieve PEM versions
    $versions_to_check = array();
    $url = PEM_URL . '/api/get_version_list.php?format=php';
    if (fetchRemote($url, $result) and $pem_versions = @unserialize($result))
    {
      if (!preg_match('/^\d+\.\d+\.\d+/', $version))
      {
        $version = $pem_versions[0]['name'];
      }
      $branch = substr($version, 0, strrpos($version, '.'));
      foreach ($pem_versions as $pem_version)
      {
        if (strpos($pem_version['name'], $branch) === 0)
        {
          $versions_to_check[] = $pem_version['id'];
        }
      }
    }
    if (empty($versions_to_check))
    {
      return false;
    }

    // Extensions to check
    $ext_to_check = array();
    foreach ($this->types as $type)
    {
      $fs = 'fs_'.$type;
      foreach ($this->$type->$fs as $ext)
      {
        if (isset($ext['extension']))
        {
          $ext_to_check[$ext['extension']] = $type;
        }
      }
    }

    // Retrieve PEM plugins infos
    $url = PEM_URL . '/api/get_revision_list.php'
      . '?format=php'
      . '&last_revision_only=true'
      . '&version='.implode(',', $versions_to_check)
      . '&lang='.substr($user['language'], 0, 2)
      . '&get_nb_downloads=true';

    if (!empty($ext_to_check))
    {
      $get_data['extension_include'] = implode(',', array_keys($ext_to_check));
    }

    if (fetchRemote($url, $result, $get_data))
    {
      $pem_exts = @unserialize($result);
      if (!is_array($pem_exts))
      {
        return false;
      }
      foreach ($pem_exts as $ext)
      {
        if (isset($ext_to_check[$ext['extension_id']]))
        {
          $server = 'server_'.$ext_to_check[$ext['extension_id']];
          $this->$ext_to_check[$ext['extension_id']]->$server += array($ext['extension_id'] => $ext);
          unset($ext_to_check[$ext['extension_id']]);
        }
      }
      $this->check_missing_extensions($ext_to_check);
      return true;
    }
    return false;
  }

  // Check all extensions upgrades
  function check_extensions()
  {
    global $conf;

    if (!$this->get_server_extensions())
    {
      autoupdate_error();
    }

    $_SESSION['extensions_need_update'] = array();

    foreach ($this->types as $type)
    {
      $fs = 'fs_'.$type;
      $server = 'server_'.$type;
      $server_ext = $this->$type->$server;
      $fs_ext = $this->$type->$fs;

      $ignore_list = array();
      $need_upgrade = array();

      foreach($fs_ext as $ext_id => $fs_ext)
      {
        if (isset($fs_ext['extension']) and isset($server_ext[$fs_ext['extension']]))
        {
          $ext_info = $server_ext[$fs_ext['extension']];

          if (!$this->version_compare($fs_ext['version'], $ext_info['revision_name'], $type))
          {
            if (in_array($ext_id, $conf['AU_ignore'][$type]))
            {
              array_push($ignore_list, $ext_id);
            }
            else
            {
              $_SESSION['extensions_need_update'][$type][$ext_id] = $ext_info['revision_name'];
            }
          }
        }
      }
      $conf['AU_ignore'][$type] = $ignore_list;
    }
    conf_update_param('autoupdate_ignore_list', pwg_db_real_escape_string(serialize($conf['AU_ignore'])));
  }

  // Check if extension have been upgraded since last check
  function check_updated_extensions()
  {
    foreach ($this->types as $type)
    {
      if (!empty($_SESSION['extensions_need_update'][$type]))
      {
        $fs = 'fs_'.$type;
        foreach($this->$type->$fs as $ext_id => $fs_ext)
        {
          if (isset($_SESSION['extensions_need_update'][$type][$ext_id])
            and $this->version_compare($fs_ext['version'], $_SESSION['extensions_need_update'][$type][$ext_id], $type))
          {
            // Extension have been upgraded
            $this->check_extensions();
            break;
          }
        }
      }
    }
  }

  function check_missing_extensions($missing)
  {
    foreach ($missing as $id => $type)
    {
      $fs = 'fs_'.$type;
      $default = 'default_'.$type;
      foreach ($this->$type->$fs as $ext_id => $ext)
      {
        if (isset($ext['extension']) and $id == $ext['extension'] and !in_array($ext_id, $this->$default))
        {
          $this->missing[$type][] = $ext;
          break;
        }
      }
    }
  }

  function version_compare($a, $b, $type)
  {
    $version_compare = rtrim($type, 's').'_version_compare';

    return $this->$type->$version_compare($a, $b);
  }
}

?>