Primeiro você precisa obter as imagens. Como obter todas as imagens de uma galeria é descrito aqui .
O WordPress usa duas classes para descompactar arquivos. O PHP foi incorporado ZipArchive()(uso, veja David Walsh). E PclZip , você pode encontrar esta classe em wp-admin/includes/class-pclzip.php. Se você tiver problemas com ZipArchive()a classe PclZip.
Agora você só precisa colar os dois juntos. Talvez eu possa postar algum código de exemplo mais tarde, atualmente não estou na minha mesa.
Atualizar
Sua pergunta pode ser dividida em duas partes. O primeiro é obter todas as imagens de uma galeria. O segundo é fechar as imagens e enviar o arquivo zip.
Explicarei apenas a primeira parte, obtendo todas as imagens de uma galeria, porque compactar os arquivos é um pouco offtopic.
Talvez haja outras soluções, mas neste exemplo eu substituo o código de acesso da galeria original por um personalizado para obter as imagens. O motivo é que o WordPress mudou um pouco as galerias na v3.5.
Antes da versão 3.5, as imagens de uma galeria são anexos da postagem. Depois da versão 3.5, as imagens são passadas para o código curto como um atributo. Como o WP3.5 não pode mais obter as imagens anexadas de uma postagem, precisamos buscar a lista nos atributos de código curto. Minha estratégia é substituir o código de acesso original por um código de acesso personalizado, pegar os atributos e chamar o código de acesso original para obter a saída da galeria.
Todas as coisas relacionadas à galeria estão dentro de uma classe. Para criar um arquivo zip, podemos usar outra classe que usa como entrada a saída da classe da galeria. Vamos começar com uma classe e um construtor simples.
class GalleryZip
{
private static $instance = null;
public static $images = array();
public static function get_instance() {
if ( ! session_id() )
session_start();
if ( null === self::$instance )
self::$instance = new self();
return self::$instance;
}
private final function __construct() {
remove_shortcode( 'gallery' );
add_shortcode( 'gallery', array( __CLASS__, 'gallery_zip_shortcode' ) );
}
}
Chamaremos o método get_instance()posteriormente no plugin com o gancho plugins_loaded. No construtor, removemos o código de acesso original e o substituímos por nosso código de acesso personalizado gallery_zip_shortcode(). Agora precisamos do retorno de chamada de código curto
public static function gallery_zip_shortcode( $atts ) {
$post = get_post();
if ( ! function_exists( 'gallery_shortcode' ) )
require_once ABSPATH . 'wp-includes/media.php';
self::get_gallery_images_from_shortcode( $post->ID, $atts );
$output = gallery_shortcode( $atts );
$gallery_id = count( self::$images[$post->ID] ) - 1;
$link = sprintf( '<div><a href="#" gallery-id="%d" post-id="%d" class="gallery-zip">%s</a></div>', $gallery_id, $post->ID, __( 'Get as Zip' ) );
$output .= $link;
return $output;
}
A primeira coisa nesse método é obter a postagem porque precisamos do ID da postagem. Do que incluímos wp-includes/media.php, esse arquivo contém a função de retorno de chamada para o código de acesso da galeria original. Agora, chamamos um método para obter uma matriz com todas as imagens, criar a saída da galeria chamando o retorno de chamada da galeria original, criar um link e anexar o link à saída da galeria. As imagens em si, respectivamente os caminhos para as imagens, são armazenadas na variável de classe $images, precisamos dessa matriz posteriormente.
A variável de classe $imagemantém uma entrada para cada postagem com uma galeria, para que possamos usar a função na primeira página ou na visualização única. Cada entrada contém uma matriz para cada galeria, porque pode haver mais de uma galeria em cada postagem.
O núcleo do plugin é o método para obter as imagens do shortcode.
protected static function get_gallery_images_from_shortcode( $id, $atts ) {
// use the post ID if the attribute 'ids' is not set or empty
$id = ( ! isset( $atts['ids'] ) || empty( $atts['ids'] ) ) ?
(int) $id : $atts['ids'];
$exclude = ( isset( $atts['exclude'] ) && ! empty( $atts['exclude'] ) ) ?
$atts['exclude'] : '';
if ( ! isset( self::$images[$id] ) || ! is_array( self::$images[$id] ) )
self::$images[$id] = array();
$images = self::get_gallery_images( $id, $exclude );
array_push( self::$images[$id], $images );
return $images;
}
Inicialmente, decidimos se é uma postagem única ou uma lista de IDs de postagem. Se for uma lista de IDs de postagem, lidamos com uma galeria do WP3.5 +. Depois disso, temos que lidar com o excludeatributo Depois de configurar todas as variáveis, podemos finalmente obter as imagens da galeria. As imagens recuperadas serão enviadas para a classe var $imagespara uso posterior.
protected static function get_gallery_images( $id, $exclude ) {
$images = array();
$query_args = array(
'post_status' => 'inherit',
'post_type' => 'attachment',
'post_mime_type' => 'image',
);
// handle gallery WP3.5+
// if $id contains an comma, it is a list of post IDs
if ( false !== strpos( $id, ',' ) ) {
$query_args['include'] = $id;
} elseif ( ! empty( $exclude ) ) {
// handle excluding posts
$query_args['post_parent'] = $id;
$query_args['exclude'] = $exclude;
} else {
// handle gallery before WP3.5
$query_args['post_parent'] = $id;
}
$attachments = get_posts( $query_args );
$img_sizes = array_merge( array( 'full' ), get_intermediate_image_sizes() );
$img_size = ( in_array( self::IMAGE_SIZE, $img_sizes ) ) ?
self::IMAGE_SIZE : 'full';
foreach ( $attachments as $key => $post ) {
$img = wp_get_attachment_image_src( $post->ID, $img_size, false, false );
$images[] = sprintf( '%s/%s', dirname( get_attached_file( $post->ID ) ), basename( $img[0] ) );
}
return $images;
}
Este é o ouro do plugin. Basta configurar uma matriz com argumentos de consulta, obter os anexos get_posts()e percorrer os anexos recuperados. Para lidar com tamanhos diferentes, obtemos a imagem do anexo e a faixa do URL. No arquivo anexado, pegamos o caminho e o juntamos ao nome do arquivo. $imagesAgora, na matriz, estão todas as imagens e seus caminhos da galeria.
Basicamente, sua pergunta é respondida neste momento. Mas você também deseja criar um arquivo zip a partir das imagens. Você pode criar um arquivo zip a partir da matriz $imagesno último método. Mas esse método é chamado sempre que uma galeria é exibida e a criação de um arquivo zip pode demorar um pouco. Talvez ninguém solicite o arquivo zip que você criou aqui, isso é um desperdício de recursos.
Como podemos fazer melhor? Você se lembra que eu coloquei todas as imagens na variável de classe $images? Podemos usar essa classe var para uma solicitação ajax. Mas uma solicitação ajax é apenas outra carga de página e podemos acessar as imagens somente quando a saída da galeria é criada. Temos que salvar nossas imagens em um local onde possamos acessá-las mesmo após uma solicitação de outra página.
Neste exemplo, eu uso uma variável de sessão para armazenar a matriz com imagens. Uma variável de sessão pode ser acessada mesmo após outra página ser recarregada. Para armazenar as imagens, registro um método com o shutdowngancho. Depois que o WordPress terminar de renderizar a página, o shutdowngancho será chamado. Neste ponto, deveríamos ter coletado todas as imagens de todas as galerias exibidas. Simplesmente armazenamos as imagens e podemos acessá-las em uma solicitação ajax.
Quando a solicitação ajax é acionada, lembramos a sessão var e criamos um arquivo zip a partir dos dados. Mas este é um tópico pouco interessante para esta pergunta.
Eu criei um repositório no GitHub com o código completo do plugin. Espero que você aponte na direção certa.