wpdk-post.php

Go to the documentation of this file.

<?php

class WPDKPost extends WPDKObject {

  const COLUMN_COMMENT_COUNT         = 'comment_count';
  const COLUMN_COMMENT_STATUS        = 'comment_status';
  const COLUMN_GUID                  = 'guid';
  const COLUMN_ID                    = 'ID';
  const COLUMN_MENU_ORDER            = 'menu_order';
  const COLUMN_PINGED                = 'pinged';
  const COLUMN_PING_STATUS           = 'ping_status';
  const COLUMN_POST_AUTHOR           = 'post_author';
  const COLUMN_POST_CONTENT          = 'post_content';
  const COLUMN_POST_CONTENT_FILTERED = 'post_content_filtered';
  const COLUMN_POST_DATE             = 'post_date';
  const COLUMN_POST_DATE_GMT         = 'post_date_gmt';
  const COLUMN_POST_EXCERPT          = 'post_excerpt';
  const COLUMN_POST_MIME_TYPE        = 'post_mime_type';
  const COLUMN_POST_MODIFIED         = 'post_modified';
  const COLUMN_POST_MODIFIED_GMT     = 'post_modified_gmt';
  const COLUMN_POST_NAME             = 'post_name';
  const COLUMN_POST_PARENT           = 'post_parent';
  const COLUMN_POST_PASSWORD         = 'post_password';
  const COLUMN_POST_STATUS           = 'post_status';
  const COLUMN_POST_TITLE            = 'post_title';
  const COLUMN_POST_TYPE             = 'post_type';
  const COLUMN_TO_PING               = 'to_ping';

  public $__version = '1.0.2';

  public $ID;
  public $comment_count;
  public $comment_status;
  public $guid;
  public $menu_order;
  public $ping_status;
  public $pinged;
  public $post_author;
  public $post_category;
  public $post_content;
  public $post_content_filtered;
  public $post_date;
  public $post_date_gmt;
  public $post_excerpt;
  public $post_mime_type;
  public $post_modified;
  public $post_modified_gmt;
  public $post_name;
  public $post_parent;
  public $post_password;
  public $post_status;
  public $post_title;
  public $post_type;
  public $to_ping;

  public function __construct( $record = null, $post_type = 'page' )
  {

    /* Get post by id. */
    if ( !is_null( $record ) && is_numeric( $record ) ) {
      $this->initPostByID( absint( $record ) );
    }

    /* Get post from database record. */
    elseif ( !is_null( $record ) && is_object( $record ) && isset( $record->ID ) ) {
      $this->initPostByPost( $record );
    }

    /* Get post by name. */
    elseif ( !is_null( $record ) && is_string( $record ) ) {
      /* @todo Use get by name */
      $object = get_page_by_path( $record, OBJECT, $post_type );
      $this->initPostByPost( $object );
    }

    /* Create an empty post. */
    elseif ( is_null( $record ) ) {
      /* Create a new onfly post */
      $defaults = $this->postEmpty();
      $this->initPostByArgs( $defaults );
    }
  }

  // -----------------------------------------------------------------------------------------------------------------
  // Create/Get Post
  // -----------------------------------------------------------------------------------------------------------------

  private function initPostByID( $id_post )
  {
    if ( isset( $GLOBALS[__CLASS__][$id_post] ) ) {
      $post = $GLOBALS[__CLASS__][$id_post];
    }
    else {
      $GLOBALS[__CLASS__][$id_post] = $post = get_post( $id_post );
    }
    $this->initPostByPost( $post );
  }

  private function initPostByPost( $post )
  {
    if ( is_object( $post ) ) {
      /* Get properties. */
      foreach ( $post as $property => $value ) {
        $this->$property = $value;
      }
    }
  }

  private function postEmpty()
  {
    $args = array(
      'ID'                    => 0,
      'post_author'           => 0,
      'post_date'             => '0000-00-00 00:00:00',
      'post_date_gmt'         => '0000-00-00 00:00:00',
      'post_content'          => '',
      'post_title'            => '',
      'post_excerpt'          => '',
      'post_status'           => WPDKPostStatus::PUBLISH,
      'comment_status'        => 'open',
      'ping_status'           => 'open',
      'post_password'         => '',
      'post_name'             => '',
      'to_ping'               => '',
      'pinged'                => '',
      'post_modified'         => '0000-00-00 00:00:00',
      'post_modified_gmt'     => '0000-00-00 00:00:00',
      'post_content_filtered' => '',
      'post_parent'           => 0,
      'guid'                  => '',
      'menu_order'            => 0,
      'post_type'             => WPDKPostType::POST,
      'post_mime_type'        => '',
      'comment_count'         => 0
    );
    return $args;
  }

  // -----------------------------------------------------------------------------------------------------------------
  // Empty Post
  // -----------------------------------------------------------------------------------------------------------------

  private function initPostByArgs( $args )
  {
    foreach ( $args as $property => $value ) {
      $this->$property = $value;
    }
  }

  // -----------------------------------------------------------------------------------------------------------------
  // CRUD
  // -----------------------------------------------------------------------------------------------------------------

  public function delete()
  {
    return wp_delete_post( $this->ID, true );
  }

  public function trash()
  {
    return wp_trash_post( $this->ID );
  }

  public function untrash()
  {
    return wp_untrash_post( $this->ID );
  }

  public function update()
  {
    /* Avoid update when we are in admin backend area. */
    global $pagenow;

    if ( 'post.php' != $pagenow ) {
      return wp_update_post( $this, true );
    }
  }

  public function updateMeta( $args = array() )
  {
    self::updateMetaWithID( $this->ID, $args );
  }

  public static function updateMetaWithID( $post_id, $args = array() )
  {
    if ( !empty( $post_id ) && !empty( $args ) ) {
      foreach ( $args as $meta_key => $meta_value ) {
        update_post_meta( $post_id, $meta_key, $meta_value );
      }
    }
  }

  public function metaValue( $meta_key )
  {
    if ( empty( $this->ID ) ) {
      return false;
    }
    if ( func_num_args() > 1 ) {
      $value = func_get_arg( 1 );
      return update_post_meta( $this->ID, $meta_key, $value );
    }
    return get_post_meta( $this->ID, $meta_key, true );
  }

  public function metaValues( $meta_key )
  {
    if ( empty( $this->ID ) ) {
      return false;
    }
    if ( func_num_args() > 1 ) {
      $value = func_get_arg( 1 );
      return update_post_meta( $this->ID, $meta_key, $value );
    }
    return get_post_meta( $this->ID, $meta_key );
  }

  public function thumbnail( $size = 'full' )
  {
    return self::thumbnailWithID( $this->ID, $size );
  }

  public static function thumbnailWithID( $post_id, $size = 'full' )
  {
    if ( empty( $post_id ) || $post_id != absint( $post_id ) ) {
      return false;
    }

    if ( function_exists( 'has_post_thumbnail' ) ) {
      if ( has_post_thumbnail( $post_id ) ) {
        $thumbnail_id = get_post_thumbnail_id( $post_id );
        $image        = wp_get_attachment_image_src( $thumbnail_id, $size );

        /* Get src attribute */
        $src = $image[0];

        /* Get the attachment alt text. */
        $alt = trim( strip_tags( get_post_meta( $thumbnail_id, '_wp_attachment_image_alt', true ) ) );

        /* Get the attachment caption. */
        $caption = get_post_field( 'post_excerpt', $thumbnail_id );

        $img = new WPDKHTMLTagImg( $src, $alt );
        if ( !empty( $caption ) ) {
          $img->addData( 'caption', $caption );
        }
        $img->addData( 'thumbnail_id', $thumbnail_id );
        $img->addData( 'post_id', $post_id );
        $img->addData( 'size', $size );

        return $img;
      }
    }
    return false;
  }

  public function imageAttachments( $size = 'full', $index = 1 )
  {
    return self::imageAttachmentsWithID( $this->ID, $size, $index );
  }

  public static function imageAttachmentsWithID( $post_id, $size = 'full', $index = 1 )
  {
    /* Check for support */
    if ( function_exists( 'wp_get_attachment_image' ) ) {
      $args     = array(
        'post_parent'    => $post_id,
        'post_type'      => WPDKPostType::ATTACHMENT,
        'numberposts'    => -1,
        'post_status'    => WPDKPostStatus::INHERIT,
        'post_mime_type' => 'image',
        'order'          => 'ASC',
        'orderby'        => 'menu_order ASC'
      );
      $children = get_children( $args );

      if ( empty( $children ) || !is_array( $children ) ) {
        return false;
      }

      /* Get the first */
      $item = current( $children );

      /* Try to get the $index element */
      if ( $index > 1 ) {
        $item = current( array_slice( $children, $index - 1, 1 ) );
      }

      if ( is_object( $item ) && isset( $item->ID ) ) {
        $thumbnail_id = $item->ID;

        $image = wp_get_attachment_image_src( $thumbnail_id, $size );
        $src = $image[0];

        /* Get the attachment alt text. */
        $alt = trim( strip_tags( get_post_meta( $thumbnail_id, '_wp_attachment_image_alt', true ) ) );

        /* Get the attachment caption. */
        $caption = get_post_field( 'post_excerpt', $thumbnail_id );

        $img = new WPDKHTMLTagImg( $src, $alt );
        if ( !empty( $caption ) ) {
          $img->addData( 'caption', $caption );
        }
        $img->addData( 'thumbnail_id', $thumbnail_id );
        $img->addData( 'post_id', $post_id );
        $img->addData( 'size', $size );

        return $img;
      }
    }
    return false;
  }

  public function imageContent()
  {
    return self::imageContentWithID( $this->ID );
  }

  public static function imageContentWithID( $post_id )
  {
    /* Search the post's content for the <img /> tag and get its URL. */
    preg_match_all( '|<img.*?src=[\'"](.*?)[\'"].*?>|i', get_post_field( 'post_content', $post_id ), $matches );

    /* If there is a match for the image, return its URL. */
    if ( isset( $matches ) && is_array( $matches ) && !empty( $matches[1][0] ) ) {
      $src = $matches[1][0];

      $img = new WPDKHTMLTagImg( $src, '' );
      $img->addData( 'post_id', $post_id );

      return $img;
    }
    return false;
  }

}

class WPDKPostStatus {
  const AUTO_DRAFT = 'auto-draft';
  const DRAFT      = 'draft';
  const FUTURE     = 'future';
  const INHERIT    = 'inherit';
  const PENDING    = 'pending';
  const PRIVATE_ = 'private';
  const PUBLISH  = 'publish';
  const TRASH    = 'trash';

  public static function statuses()
  {
    $statuses = array(
      self::AUTO_DRAFT => __( 'A newly created post, with no content', WPDK_TEXTDOMAIN ),
      self::DRAFT      => __( 'The post is draft', WPDK_TEXTDOMAIN ),
      self::FUTURE     => __( 'The post to publish in the future', WPDK_TEXTDOMAIN ),
      self::INHERIT    => __( 'The post is a revision', WPDK_TEXTDOMAIN ),
      self::PENDING    => __( 'The post is pending review', WPDK_TEXTDOMAIN ),
      self::PRIVATE_   => __( 'Not visible to users who are not logged in', WPDK_TEXTDOMAIN ),
      self::PUBLISH    => __( 'A published post or page', WPDK_TEXTDOMAIN ),
      self::TRASH      => __( 'The post is in trashbin', WPDK_TEXTDOMAIN ),
    );

    return apply_filters( 'wpdk-posts-statuses', $statuses );
  }
}

/* Backward copatibility */
class _WPDKPost extends WPDKPost {}

class WPDKPostType {
  const ATTACHMENT    = 'attachment';
  const NAV_MENU_ITEM = 'nav_menu_item';
  const PAGE          = 'page';
  const POST          = 'post';
  const REVISION      = 'revision';
}


class WPDKPosts {

  public function __construct()
  {
  }

}


class WPDKPostMeta {

  private $_post;

  public function __construct( $post )
  {
    $this->_post = new WPDKPost( $post );
  }

  public static function updatePostMetaWithDeleteIfNotSet( $id_post, $meta_key, $meta_value = null )
  {

    /* Sanitize post id. */
    $id_post = absint( $id_post );

    if ( !empty( $id_post ) ) {
      /* Se il parametro meta_value è null elimino il post meta. */
      if ( is_null( $meta_value ) ) {
        delete_post_meta( $id_post, $meta_key );
      }
      else {
        /* Sanitizo il nome della meta key che potrebbe arrivara come name di un campo input array. */
        if ( substr( $meta_key, -2 ) == '[]' ) {
          $meta_key = substr( $meta_key, 0, strlen( $meta_key ) - 2 );
        }
        update_post_meta( $id_post, $meta_key, $meta_value );
      }
    }
  }

  public function value( $key )
  {
    if ( !empty( $key ) && !empty( $this->_post ) ) {
      return get_post_meta( $this->_post->ID, $key, true );
    }
    return null;
  }

  // -----------------------------------------------------------------------------------------------------------------
  // Utility
  // -----------------------------------------------------------------------------------------------------------------

  public function values( $key )
  {
    if ( !empty( $key ) && !empty( $this->_post ) ) {
      return get_post_meta( $this->_post->ID, $key, false );
    }
    return null;
  }
}