Aggiorna plug-in dall'API personale


9

Al momento sto sviluppando un plugin per wordpress che non voglio nel repository dei plugin di Wordpress. Tuttavia, voglio ancora essere in grado di inviare aggiornamenti ai miei clienti dal mio repository API.

Ho letto un bel po 'su questo, e una cosa che sembra essere qualcosa è il pre_set_site_transient_update_pluginsfiltro, tuttavia non riesco a trovare molte informazioni al riguardo. Ho provato questo tutorial ( http://konstruktors.com/blog/wordpress/2538-automatic-updates-for-plugins-and-themes-hosted-outside-wordpress-extend/ ) che non riuscivo a far funzionare. Dai commenti posso dire che altri possono effettivamente farlo funzionare con quella che deve essere quasi l'attuale versione di WP (ultima risposta il 22 aprile).

Ho provato a installare il plug-in dal sito e a posizionare la cartella API su un secondo dominio, ma la notifica di aggiornamento che di solito ricevo quando è disponibile un aggiornamento, non viene visualizzata da nessuna parte.

Non sono sicuro che sia possibile avere plug-in personalizzati per eseguire l'aggiornamento automatico da altri repository, quindi vorrei sapere se qualcuno qui ha qualche esperienza con queste cose? La soluzione nel tutorial sembrava essere una soluzione semplice: mi chiedo se sia in qualche modo possibile farlo in un modo più avanzato?

Qualsiasi aiuto per ottenere questo aggiornamento automatico dal mio repository funzionante sarebbe molto apprezzato!

(PS: sto eseguendo WP versione 3.1.3)


Potrei essere in ritardo alla festa, ma puoi trovare un plugin che ho creato esattamente per questo: WP Plugin Update Server
froger.me,

Risposte:



2

Sì, questo è possibile. C'è un intero capitolo nello sviluppo professionale dei plugin di WordPress dedicato a questo. Se non l'hai già fatto, prendine una copia. Sarà sicuramente di aiuto.


In realtà ho trovato una versione PDF di questo online, ma non sembra funzionare neanche per me.
Simon,

Funziona se lo fai bene, l'ho fatto, guarda l'API HTTP, codex.wordpress.org/HTTP_API
Wyck,

Ho appena ricominciato. Quello che ho ottenuto finora è collegarmi al controllo dell'aggiornamento del plugin usando add_filter("pre_set_site_transient_update_plugins","dne_altapi_check"); Dopo che ho la funzione dne_altapi_check che contiene print_r("hi");- tuttavia quando premo il pulsante "Controlla di nuovo" sotto gli aggiornamenti, non stampa nulla affatto. stai facendo qualcosa di sbagliato quando ti colleghi al controllo aggiornamenti?
Simon,

Ricordo che qualcuno ha scritto delle lezioni per il personale addetto all'aggiornamento dei plugin, ma posso trovare il link per quel post: /
Mamaduka,

1

Esiste questo gestore di API commerciale per l'aggiornamento di plugin e temi per WooCommerce che funziona in modo specifico se il plugin o il tema non è ospitato su wordpress.org. È progettato per fornire aggiornamenti per plugin e temi self-hosted. Il plugin è per coloro che non vogliono scriverlo da soli e hanno bisogno di molte funzionalità, oltre a esempi funzionanti per plugin e temi che vengono venduti.

http://www.toddlahman.com/shop/wordpress-automatic-update-api-manager/


1

C'è anche un servizio accurato su http://wp-updates.com/ : ottieni un tema o un plug-in gratuitamente. Cordiali saluti - questo non è il mio sito ma l'ho provato qualche tempo fa e mi è sembrato abbastanza buono.


Sembra un buon servizio, ma non ho notato (quasi sul piano gratuito) HTTPS nel pannello di controllo web né nelle comunicazioni: inoltre non ho trovato alcun tipo di controllo della proprietà durante il controllo dell'aggiornamento (mi sembra molto semplice Richiesta POST), ritengo che le cose potrebbero essere rubate, conoscendo il nome del plugin e facendo alcune ipotesi. Mi sarebbe piaciuto usarlo, se mi fosse sembrato un po 'più professionale dal punto di vista della sicurezza.
reallynice

1

Per un'installazione su sito singolo (non l'ho testato su un sito multiplo), ci sono solo due hook da aggiornare da un servizio esterno come github o gitlab. Nel codice qui sotto, uso gitlab poiché è quello che uso per ospitare il mio codice in questo momento. Probabilmente dovrei sottrarre le parti di gitlab ...

Il primo gancio che dovrai usare è pre_set_site_transient_update_themes. Questo è il filtro che WordPress utilizza per impostare site_transient per mostrare se sono disponibili aggiornamenti. Usa questo hook per connetterti alla tua versione remota e vedere se ci sono aggiornamenti disponibili. Se ci sono, modifica il transitorio in modo che WordPress sappia che ci sono aggiornamenti e può mostrare l'avviso all'utente.

L'altro gancio che dovrai usare è upgrader_source_selection. Questo filtro è necessario, comunque per gitlab, perché il nome della cartella scaricata non è lo stesso del tema, quindi usiamo questo hook per rinominarlo con il nome corretto. Se il tuo repository remoto fornisce una zip con il nome corretto, non hai nemmeno bisogno di questo hook.

Il terzo hook facoltativo che è possibile utilizzare è auto_update_themese si desidera aggiornare automaticamente il tema. Nell'esempio seguente, utilizzo questo hook per aggiornare automaticamente solo questo tema specifico.

Questo codice è stato testato solo con WordPress 4.9.x. Richiede 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 );
  }
}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.