Atualizar o plugin da API pessoal

9

Estou desenvolvendo um plugin do wordpress no momento que não quero no repositório de plugins do Wordpress. No entanto, eu ainda quero poder enviar atualizações para meus clientes do meu próprio repositório de APIs.

Eu tenho lido bastante sobre isso, e uma coisa que parece ser sobre o filtro pre_set_site_transient_update_plugins , no entanto, não consigo encontrar muita informação sobre isso. Eu tentei este tutorial ( enlace ) que eu não consegui trabalhar. Eu posso dizer pelos comentários que outros podem realmente trabalhar com o que deve ser quase a versão atual do WP (última resposta, 22 de abril).

Eu tentei instalar o plug-in do site e colocar a pasta da API em um segundo domínio, mas a notificação de atualização que normalmente recebo quando uma atualização está disponível, não foi mostrada em lugar nenhum.

Não tenho certeza se é realmente possível ter plugins personalizados executando a atualização automática de outros repositórios, então gostaria de saber se alguém aqui tem alguma experiência com essas coisas? A solução no tutorial parecia ser uma solução fácil - gostaria de saber se é possível fazê-lo de uma forma mais avançada?

Qualquer ajuda para obter essa atualização automática do meu próprio repositório seria muito apreciada!

(PS: estou executando o WP versão 3.1.3)

    
por Simon 29.05.2011 / 22:41

5 respostas

7

Para o benefício de outras pessoas que encontrarem esta página, sugiro que aqueles que desejarem fornecer suas próprias atualizações fora do repositório oficial do WP verifiquem este projeto no GitHub, que demonstre a funcionalidade:

enlace

    
por k3davis 17.08.2012 / 16:44
2

Sim, isso é possível. Há um capítulo inteiro em Desenvolvimento de Plugin para WordPress Profissional dedicado a isso. Se você ainda não o fez, pegue uma cópia. Isso definitivamente ajudará.

    
por EAMann 29.05.2011 / 22:54
1

Existe esse gerenciador de APIs de plugins e temas para o WooCommerce que funciona especificamente se o plug-in ou o tema não estiver hospedado no wordpress.org. Ele é projetado para fornecer atualizações para plug-ins e temas hospedados automaticamente. O plug-in é para quem não quer escrever e precisa de muitos recursos, além de exemplos de trabalho para plugins e temas que estão sendo vendidos.

enlace

    
por Todd Lahman 15.07.2013 / 10:25
1

Há também um ótimo serviço no enlace - você recebe um tema ou plug-in gratuitamente. FYI - este não é o meu site, mas já tentei há algum tempo e parecia muito bom.

    
por cwd 24.09.2013 / 05:53
1

Para uma instalação de site único (não testei em um site múltiplo), existem apenas dois ganchos que você precisa atualizar de um serviço externo, como github ou gitlab. No código abaixo, eu uso o gitlab, já que é o que eu uso para hospedar meu código agora. Eu provavelmente deveria abstrair as partes do gitlab ...

O primeiro gancho que você precisará usar é pre_set_site_transient_update_themes . Este é o filtro que o WordPress usa para definir o site_transient para mostrar se há atualizações disponíveis. Use este gancho para se conectar à sua versão remota e ver se há atualizações disponíveis. Se houver, modifique o transitório para que o WordPress saiba que há atualizações e mostre o aviso ao usuário.

O outro gancho que você precisará usar é upgrader_source_selection . Este filtro é necessário, para o gitlab, porque o nome da pasta baixada não é o mesmo que o tema, então usamos esse gancho para renomeá-lo para o nome correto. Se o seu repositório remoto fornece um zip com o nome correto, você nem precisa desse gancho.

O terceiro gancho opcional que você pode usar é auto_update_theme se você quiser atualizar automaticamente seu tema. No exemplo abaixo, eu uso esse gancho para atualizar automaticamente apenas este tema específico.

Este código só foi testado com o WordPress 4.9.x. Requer PHP > 7.0.

functions.php

//* Load the updater.
require PATH_TO . 'updater.php';
$updater = new updater();
\add_action( 'init', [ $updater, 'init' ] );

updater.php

/**
 * @package StackExchange\WordPress
 */
declare( strict_types = 1 );
namespace StackExchange\WordPress;

/**
 * Class for updating the theme.
 */
class updater {

  /**
   * @var Theme slug.
   */
  protected $theme = 'theme';

  /**
   * @var Theme repository name.
   */
  protected $repository = 'project/theme';

  /**
   * @var Repository domain.
   */
  protected $domain = 'https://gitlab.com/';

  /**
   * @var CSS endpoint for repository.
   */
  protected $css_endpoint = '/raw/master/style.css';

  /**
   * @var ZIP endpoint for repository.
   */
  protected $zip_endpoint = '/repository/archive.zip';

  /**
   * @var Remote CSS URI.
   */
  protected $remote_css_uri;

  /**
   * @var Remote ZIP URI.
   */
  protected $remote_zip_uri;

  /**
   * @var Remote version.
   */
  protected $remote_version;

  /**
   * @var Local version.
   */
  protected $local_version;

  /**
   * Method called from the init hook to initiate the updater
   */
  public function init() {
    \add_filter( 'auto_update_theme', [ $this, 'auto_update_theme' ], 20, 2 );
    \add_filter( 'upgrader_source_selection', [ $this, 'upgrader_source_selection' ], 10, 4 );
    \add_filter( 'pre_set_site_transient_update_themes', [ $this, 'pre_set_site_transient_update_themes' ] );
  }

  /**
   * Method called from the auto_update_theme hook.
   * Only auto update this theme.
   * This hook and method are only needed if you want to auto update the theme.
   *
   * @return bool Whether to update the theme.
   */
  public function auto_update_theme( bool $update, \stdClass $item ) : bool {
    return $this->theme === $item->theme;
  }

  /**
   * Rename the unzipped folder to be the same as the existing folder
   *
   * @param string       $source        File source location
   * @param string       $remote_source Remote file source location
   * @param \WP_Upgrader $upgrader      \WP_Upgrader instance
   * @param array        $hook_extra    Extra arguments passed to hooked filters
   *
   * @return string | \WP_Error The updated source location or a \WP_Error object on failure
   */
  public function upgrader_source_selection( string $source, string $remote_source, \WP_Upgrader $upgrader, array $hook_extra ) {
    global $wp_filesystem;

    $update = [ 'update-selected', 'update-selected-themes', 'upgrade-theme' ];

    if( ! isset( $_GET[ 'action' ] ) || ! in_array( $_GET[ 'action' ], $update, true ) ) {
      return $source;
    }

    if( ! isset( $source, $remote_source ) ) {
      return $source;
    }

    if( false === stristr( basename( $source ), $this->theme ) ) {
      return $source;
    }

    $basename = basename( $source );
    $upgrader->skin->feedback( esc_html_e( 'Renaming theme directory.', 'bootstrap' ) );
    $corrected_source = str_replace( $basename, $this->theme, $source );

    if( $wp_filesystem->move( $source, $corrected_source, true ) ) {
      $upgrader->skin->feedback( esc_html_e( 'Rename successful.', 'bootstrap' ) );
      return $corrected_source;
    }

    return new \WP_Error();
  }

  /**
   * Add respoinse to update transient if theme has an update.
   *
   * @param $transient
   *
   * @return
   */
  public function pre_set_site_transient_update_themes( $transient ) {
    require_once ABSPATH . 'wp-admin/includes/class-wp-upgrader.php';
    $this->local_version = ( \wp_get_theme( $this->theme ) )->get( 'Version' );

    if( $this->hasUpdate() ) {
      $response = [
        'theme'       => $this->theme,
        'new_version' => $this->remote_version,
        'url'         => $this->construct_repository_uri(),
        'package'     => $this->construct_remote_zip_uri(),
        'branch'      => 'master',
      ];
      $transient->response[ $this->theme ] = $response;
    }

    return $transient;
  }

  /**
   * Construct and return the URI to the remote stylesheet
   *
   * @return string The remote stylesheet URI
   */
  protected function construct_remote_stylesheet_uri() : string {
    return $this->remote_css_uri = $this->domain . $this->repository . $this->css_endpoint;
  }

  /**
   * Construct and return the URI to the remote ZIP file
   *
   * @return string The remote ZIP URI
   */
  protected function construct_remote_zip_uri() : string {
    return $this->remote_zip_uri = $this->domain . $this->repository . $this->zip_endpoint;
  }

  /**
   * Construct and return the URI to remote repository
   *
   * @access protected
   * @since  1.0
   *
   * @return string The remote repository URI
   */
  protected function construct_repository_uri() : string {
    return $this->repository_uri = $this->domain . \trailingslashit( $this->repository );
  }

  /**
   * Get and return the remote version
   *
   * @return string The remote version
   */
  protected function get_remote_version() : string {
    $this->remote_stylesheet_uri = $this->construct_remote_stylesheet_uri();
    $response = $this->remote_get( $this->remote_stylesheet_uri );
    $response = str_replace( "\r", "\n", \wp_remote_retrieve_body( $response ) );
    $headers = [ 'Version' => 'Version' ];

    foreach( $headers as $field => $regex ) {
      if( preg_match( '/^[ \t\/*#@]*' . preg_quote( $regex, '/' ) . ':(.*)$/mi', $response, $match ) && $match[1] ) {
        $headers[ $field ] = _cleanup_header_comment( $match[1] );
      }
      else {
        $headers[ $field ] = '';
      }
    }

    return $this->remote_version = ( '' === $headers[ 'Version' ] ) ? '' : $headers[ 'Version' ];
  }

  /**
   * Return whether the theme has an update
   *
   * @return bool Whether the theme has an update
   */
  protected function hasUpdate() : bool {
    if( ! $this->remote_version ) $this->remote_version = $this->get_remote_version();
    return version_compare( $this->remote_version, $this->local_version, '>' );
  }

  /**
   * Wrapper for \wp_remote_get()
   *
   * @param string $url  The URL to get
   * @param array  $args Array or arguments to pass through to \wp_remote_get()
   *
   * @return array|WP_Error Return the request or an error object
   */
  protected function remote_get( string $url, array $args = [] ) {
    return \wp_remote_get( $url, $args );
  }
}
    
por Nathan Johnson 03.03.2018 / 19:37