/modules/custom-post-types/portfolios.php

  1. <?php 
  2.  
  3. class Jetpack_Portfolio { 
  4.   const CUSTOM_POST_TYPE = 'jetpack-portfolio'; 
  5.   const CUSTOM_TAXONOMY_TYPE = 'jetpack-portfolio-type'; 
  6.   const CUSTOM_TAXONOMY_TAG = 'jetpack-portfolio-tag'; 
  7.   const OPTION_NAME = 'jetpack_portfolio'; 
  8.   const OPTION_READING_SETTING = 'jetpack_portfolio_posts_per_page'; 
  9.  
  10.   public $version = '0.1'; 
  11.  
  12.   static function init() { 
  13.       static $instance = false; 
  14.  
  15.       if ( ! $instance ) { 
  16.           $instance = new Jetpack_Portfolio; 
  17.       } 
  18.  
  19.       return $instance; 
  20.   } 
  21.  
  22.   /** 
  23.    * Conditionally hook into WordPress. 
  24.    * 
  25.    * Setup user option for enabling CPT 
  26.    * If user has CPT enabled, show in admin 
  27.    */ 
  28.   function __construct() { 
  29.       // Add an option to enable the CPT 
  30.       add_action( 'admin_init', array( $this, 'settings_api_init' ) ); 
  31.  
  32.       // Check on theme switch if theme supports CPT and setting is disabled 
  33.       add_action( 'after_switch_theme', array( $this, 'activation_post_type_support' ) ); 
  34.  
  35.       // Make sure the post types are loaded for imports 
  36.       add_action( 'import_start', array( $this, 'register_post_types' ) ); 
  37.  
  38.       $setting = get_option( self::OPTION_NAME, '0' ); 
  39.  
  40.       // Bail early if Portfolio option is not set and the theme doesn't declare support 
  41.       if ( empty( $setting ) && ! $this->site_supports_custom_post_type() ) { 
  42.           return; 
  43.       } 
  44.  
  45.       // Enable Omnisearch for Portfolio Items. 
  46.       if ( class_exists( 'Jetpack_Omnisearch_Posts' ) ) 
  47.           new Jetpack_Omnisearch_Posts( self::CUSTOM_POST_TYPE ); 
  48.  
  49.       // CPT magic 
  50.       $this->register_post_types(); 
  51.       add_action( sprintf( 'add_option_%s', self::OPTION_NAME ), array( $this, 'flush_rules_on_enable' ), 10 ); 
  52.       add_action( sprintf( 'update_option_%s', self::OPTION_NAME ), array( $this, 'flush_rules_on_enable' ), 10 ); 
  53.       add_action( sprintf( 'publish_%s', self::CUSTOM_POST_TYPE), array( $this, 'flush_rules_on_first_project' ) ); 
  54.       add_action( 'after_switch_theme', array( $this, 'flush_rules_on_switch' ) ); 
  55.  
  56.       // Admin Customization 
  57.       add_filter( 'post_updated_messages', array( $this, 'updated_messages' ) ); 
  58.       add_filter( sprintf( 'manage_%s_posts_columns', self::CUSTOM_POST_TYPE), array( $this, 'edit_admin_columns' ) ); 
  59.       add_filter( sprintf( 'manage_%s_posts_custom_column', self::CUSTOM_POST_TYPE), array( $this, 'image_column' ), 10, 2 ); 
  60.  
  61.       add_image_size( 'jetpack-portfolio-admin-thumb', 50, 50, true ); 
  62.       add_action( 'admin_enqueue_scripts', array( $this, 'enqueue_admin_styles' ) ); 
  63.  
  64.       // register jetpack_portfolio shortcode and portfolio shortcode (legacy) 
  65.       add_shortcode( 'portfolio', array( $this, 'portfolio_shortcode' ) ); 
  66.       add_shortcode( 'jetpack_portfolio', array( $this, 'portfolio_shortcode' ) ); 
  67.  
  68.       // Adjust CPT archive and custom taxonomies to obey CPT reading setting 
  69.       add_filter( 'pre_get_posts', array( $this, 'query_reading_setting' ) ); 
  70.  
  71.       // If CPT was enabled programatically and no CPT items exist when user switches away, disable 
  72.       if ( $setting && $this->site_supports_custom_post_type() ) { 
  73.           add_action( 'switch_theme', array( $this, 'deactivation_post_type_support' ) ); 
  74.       } 
  75.   } 
  76.  
  77.   /** 
  78.    * Add a checkbox field in 'Settings' > 'Writing' 
  79.    * for enabling CPT functionality. 
  80.    * 
  81.    * @return null 
  82.    */ 
  83.   function settings_api_init() { 
  84.       add_settings_field( 
  85.           self::OPTION_NAME,  
  86.           '<span class="cpt-options">' . __( 'Portfolio Projects', 'jetpack' ) . '</span>',  
  87.           array( $this, 'setting_html' ),  
  88.           'writing',  
  89.           'jetpack_cpt_section' 
  90.  ); 
  91.       register_setting( 
  92.           'writing',  
  93.           self::OPTION_NAME,  
  94.           'intval' 
  95.  ); 
  96.  
  97.       // Check if CPT is enabled first so that intval doesn't get set to NULL on re-registering 
  98.       if ( get_option( self::OPTION_NAME, '0' ) || current_theme_supports( self::CUSTOM_POST_TYPE ) ) { 
  99.           register_setting( 
  100.               'writing',  
  101.               self::OPTION_READING_SETTING,  
  102.               'intval' 
  103.  ); 
  104.       } 
  105.   } 
  106.  
  107.   /** 
  108.    * HTML code to display a checkbox true/false option 
  109.    * for the Portfolio CPT setting. 
  110.    * 
  111.    * @return html 
  112.    */ 
  113.   function setting_html() { 
  114.       if ( current_theme_supports( self::CUSTOM_POST_TYPE ) ) : ?> 
  115.           <p><?php printf( __( 'Your theme supports <strong>%s</strong>', 'jetpack' ), self::CUSTOM_POST_TYPE ); ?></p> 
  116.       <?php else : ?> 
  117.           <label for="<?php echo esc_attr( self::OPTION_NAME ); ?>"> 
  118.               <input name="<?php echo esc_attr( self::OPTION_NAME ); ?>" id="<?php echo esc_attr( self::OPTION_NAME ); ?>" <?php echo checked( get_option( self::OPTION_NAME, '0' ), true, false ); ?> type="checkbox" value="1" /> 
  119.               <?php esc_html_e( 'Enable Portfolio Projects for this site.', 'jetpack' ); ?> 
  120.               <a target="_blank" href="http://en.support.wordpress.com/portfolios/"><?php esc_html_e( 'Learn More', 'jetpack' ); ?></a> 
  121.           </label> 
  122.       <?php endif; 
  123.       if ( get_option( self::OPTION_NAME, '0' ) || current_theme_supports( self::CUSTOM_POST_TYPE ) ) : 
  124.           printf( '<p><label for="%1$s">%2$s</label></p>',  
  125.               esc_attr( self::OPTION_READING_SETTING ),  
  126.               sprintf( __( 'Portfolio pages display at most %1$s projects', 'jetpack' ),  
  127.                   sprintf( '<input name="%1$s" id="%1$s" type="number" step="1" min="1" value="%2$s" class="small-text" />',  
  128.                       esc_attr( self::OPTION_READING_SETTING ),  
  129.                       esc_attr( get_option( self::OPTION_READING_SETTING, '10' ) ) 
  130.  ) 
  131.  ) 
  132.  ); 
  133.       endif; 
  134.   } 
  135.  
  136.   /** 
  137.   * Should this Custom Post Type be made available? 
  138.   */ 
  139.   function site_supports_custom_post_type() { 
  140.       // If the current theme requests it. 
  141.       if ( current_theme_supports( self::CUSTOM_POST_TYPE ) || get_option( self::OPTION_NAME, '0' ) ) { 
  142.           return true; 
  143.       } 
  144.  
  145.       // Otherwise, say no unless something wants to filter us to say yes. 
  146.       /** This action is documented in modules/custom-post-types/nova.php */ 
  147.       return (bool) apply_filters( 'jetpack_enable_cpt', false, self::CUSTOM_POST_TYPE ); 
  148.   } 
  149.  
  150.   /** 
  151.    * Flush permalinks when CPT option is turned on/off 
  152.    */ 
  153.   function flush_rules_on_enable() { 
  154.       flush_rewrite_rules(); 
  155.   } 
  156.  
  157.   /** 
  158.    * Count published projects and flush permalinks when first projects is published 
  159.    */ 
  160.   function flush_rules_on_first_project() { 
  161.       $projects = get_transient( 'jetpack-portfolio-count-cache' ); 
  162.  
  163.       if ( false === $projects ) { 
  164.           flush_rewrite_rules(); 
  165.           $projects = (int) wp_count_posts( self::CUSTOM_POST_TYPE )->publish; 
  166.  
  167.           if ( ! empty( $projects ) ) { 
  168.               set_transient( 'jetpack-portfolio-count-cache', $projects, HOUR_IN_SECONDS * 12 ); 
  169.           } 
  170.       } 
  171.   } 
  172.  
  173.   /** 
  174.    * Flush permalinks when CPT supported theme is activated 
  175.    */ 
  176.   function flush_rules_on_switch() { 
  177.       if ( current_theme_supports( self::CUSTOM_POST_TYPE ) ) { 
  178.           flush_rewrite_rules(); 
  179.       } 
  180.   } 
  181.  
  182.   /** 
  183.    * On plugin/theme activation, check if current theme supports CPT 
  184.    */ 
  185.   static function activation_post_type_support() { 
  186.       if ( current_theme_supports( self::CUSTOM_POST_TYPE ) ) { 
  187.           update_option( self::OPTION_NAME, '1' ); 
  188.       } 
  189.   } 
  190.  
  191.   /** 
  192.    * On theme switch, check if CPT item exists and disable if not 
  193.    */ 
  194.   function deactivation_post_type_support() { 
  195.       $portfolios = get_posts( array( 
  196.           'fields' => 'ids',  
  197.           'posts_per_page' => 1,  
  198.           'post_type' => self::CUSTOM_POST_TYPE,  
  199.           'suppress_filters' => false 
  200.  ) ); 
  201.  
  202.       if ( empty( $portfolios ) ) { 
  203.           update_option( self::OPTION_NAME, '0' ); 
  204.       } 
  205.   } 
  206.  
  207.   /** 
  208.    * Register Post Type 
  209.    */ 
  210.   function register_post_types() { 
  211.       if ( post_type_exists( self::CUSTOM_POST_TYPE ) ) { 
  212.           return; 
  213.       } 
  214.  
  215.       register_post_type( self::CUSTOM_POST_TYPE, array( 
  216.           'description' => __( 'Portfolio Items', 'jetpack' ),  
  217.           'labels' => array( 
  218.               'name' => esc_html__( 'Projects', 'jetpack' ),  
  219.               'singular_name' => esc_html__( 'Project', 'jetpack' ),  
  220.               'menu_name' => esc_html__( 'Portfolio', 'jetpack' ),  
  221.               'all_items' => esc_html__( 'All Projects', 'jetpack' ),  
  222.               'add_new' => esc_html__( 'Add New', 'jetpack' ),  
  223.               'add_new_item' => esc_html__( 'Add New Project', 'jetpack' ),  
  224.               'edit_item' => esc_html__( 'Edit Project', 'jetpack' ),  
  225.               'new_item' => esc_html__( 'New Project', 'jetpack' ),  
  226.               'view_item' => esc_html__( 'View Project', 'jetpack' ),  
  227.               'search_items' => esc_html__( 'Search Projects', 'jetpack' ),  
  228.               'not_found' => esc_html__( 'No Projects found', 'jetpack' ),  
  229.               'not_found_in_trash' => esc_html__( 'No Projects found in Trash', 'jetpack' ),  
  230.               'filter_items_list' => esc_html__( 'Filter projects list', 'jetpack' ),  
  231.               'items_list_navigation' => esc_html__( 'Project list navigation', 'jetpack' ),  
  232.               'items_list' => esc_html__( 'Projects list', 'jetpack' ),  
  233.  ),  
  234.           'supports' => array( 
  235.               'title',  
  236.               'editor',  
  237.               'thumbnail',  
  238.               'comments',  
  239.               'publicize',  
  240.               'wpcom-markdown',  
  241.  ),  
  242.           'rewrite' => array( 
  243.               'slug' => 'portfolio',  
  244.               'with_front' => false,  
  245.               'feeds' => true,  
  246.               'pages' => true,  
  247.  ),  
  248.           'public' => true,  
  249.           'show_ui' => true,  
  250.           'menu_position' => 20, // below Pages 
  251.           'menu_icon' => 'dashicons-portfolio', // 3.8+ dashicon option 
  252.           'capability_type' => 'page',  
  253.           'map_meta_cap' => true,  
  254.           'taxonomies' => array( self::CUSTOM_TAXONOMY_TYPE, self::CUSTOM_TAXONOMY_TAG ),  
  255.           'has_archive' => true,  
  256.           'query_var' => 'portfolio',  
  257.  ) ); 
  258.  
  259.       register_taxonomy( self::CUSTOM_TAXONOMY_TYPE, self::CUSTOM_POST_TYPE, array( 
  260.           'hierarchical' => true,  
  261.           'labels' => array( 
  262.               'name' => esc_html__( 'Project Types', 'jetpack' ),  
  263.               'singular_name' => esc_html__( 'Project Type', 'jetpack' ),  
  264.               'menu_name' => esc_html__( 'Project Types', 'jetpack' ),  
  265.               'all_items' => esc_html__( 'All Project Types', 'jetpack' ),  
  266.               'edit_item' => esc_html__( 'Edit Project Type', 'jetpack' ),  
  267.               'view_item' => esc_html__( 'View Project Type', 'jetpack' ),  
  268.               'update_item' => esc_html__( 'Update Project Type', 'jetpack' ),  
  269.               'add_new_item' => esc_html__( 'Add New Project Type', 'jetpack' ),  
  270.               'new_item_name' => esc_html__( 'New Project Type Name', 'jetpack' ),  
  271.               'parent_item' => esc_html__( 'Parent Project Type', 'jetpack' ),  
  272.               'parent_item_colon' => esc_html__( 'Parent Project Type:', 'jetpack' ),  
  273.               'search_items' => esc_html__( 'Search Project Types', 'jetpack' ),  
  274.               'items_list_navigation' => esc_html__( 'Project type list navigation', 'jetpack' ),  
  275.               'items_list' => esc_html__( 'Project type list', 'jetpack' ),  
  276.  ),  
  277.           'public' => true,  
  278.           'show_ui' => true,  
  279.           'show_in_nav_menus' => true,  
  280.           'show_admin_column' => true,  
  281.           'query_var' => true,  
  282.           'rewrite' => array( 'slug' => 'project-type' ),  
  283.  ) ); 
  284.  
  285.       register_taxonomy( self::CUSTOM_TAXONOMY_TAG, self::CUSTOM_POST_TYPE, array( 
  286.           'hierarchical' => false,  
  287.           'labels' => array( 
  288.               'name' => esc_html__( 'Project Tags', 'jetpack' ),  
  289.               'singular_name' => esc_html__( 'Project Tag', 'jetpack' ),  
  290.               'menu_name' => esc_html__( 'Project Tags', 'jetpack' ),  
  291.               'all_items' => esc_html__( 'All Project Tags', 'jetpack' ),  
  292.               'edit_item' => esc_html__( 'Edit Project Tag', 'jetpack' ),  
  293.               'view_item' => esc_html__( 'View Project Tag', 'jetpack' ),  
  294.               'update_item' => esc_html__( 'Update Project Tag', 'jetpack' ),  
  295.               'add_new_item' => esc_html__( 'Add New Project Tag', 'jetpack' ),  
  296.               'new_item_name' => esc_html__( 'New Project Tag Name', 'jetpack' ),  
  297.               'search_items' => esc_html__( 'Search Project Tags', 'jetpack' ),  
  298.               'popular_items' => esc_html__( 'Popular Project Tags', 'jetpack' ),  
  299.               'separate_items_with_commas' => esc_html__( 'Separate tags with commas', 'jetpack' ),  
  300.               'add_or_remove_items' => esc_html__( 'Add or remove tags', 'jetpack' ),  
  301.               'choose_from_most_used' => esc_html__( 'Choose from the most used tags', 'jetpack' ),  
  302.               'not_found' => esc_html__( 'No tags found.', 'jetpack' ),  
  303.               'items_list_navigation' => esc_html__( 'Project tag list navigation', 'jetpack' ),  
  304.               'items_list' => esc_html__( 'Project tag list', 'jetpack' ),  
  305.  ),  
  306.           'public' => true,  
  307.           'show_ui' => true,  
  308.           'show_in_nav_menus' => true,  
  309.           'show_admin_column' => true,  
  310.           'query_var' => true,  
  311.           'rewrite' => array( 'slug' => 'project-tag' ),  
  312.  ) ); 
  313.   } 
  314.  
  315.   /** 
  316.    * Update messages for the Portfolio admin. 
  317.    */ 
  318.   function updated_messages( $messages ) { 
  319.       global $post; 
  320.  
  321.       $messages[self::CUSTOM_POST_TYPE] = array( 
  322.           0 => '', // Unused. Messages start at index 1. 
  323.           1 => sprintf( __( 'Project updated. <a href="%s">View item</a>', 'jetpack'), esc_url( get_permalink( $post->ID ) ) ),  
  324.           2 => esc_html__( 'Custom field updated.', 'jetpack' ),  
  325.           3 => esc_html__( 'Custom field deleted.', 'jetpack' ),  
  326.           4 => esc_html__( 'Project updated.', 'jetpack' ),  
  327.           /** translators: %s: date and time of the revision */ 
  328.           5 => isset( $_GET['revision'] ) ? sprintf( esc_html__( 'Project restored to revision from %s', 'jetpack'), wp_post_revision_title( (int) $_GET['revision'], false ) ) : false,  
  329.           6 => sprintf( __( 'Project published. <a href="%s">View project</a>', 'jetpack' ), esc_url( get_permalink( $post->ID ) ) ),  
  330.           7 => esc_html__( 'Project saved.', 'jetpack' ),  
  331.           8 => sprintf( __( 'Project submitted. <a target="_blank" href="%s">Preview project</a>', 'jetpack'), esc_url( add_query_arg( 'preview', 'true', get_permalink( $post->ID ) ) ) ),  
  332.           9 => sprintf( __( 'Project scheduled for: <strong>%1$s</strong>. <a target="_blank" href="%2$s">Preview project</a>', 'jetpack' ),  
  333.           // translators: Publish box date format, see http://php.net/date 
  334.           date_i18n( __( 'M j, Y @ G:i', 'jetpack' ), strtotime( $post->post_date ) ), esc_url( get_permalink( $post->ID ) ) ),  
  335.           10 => sprintf( __( 'Project item draft updated. <a target="_blank" href="%s">Preview project</a>', 'jetpack' ), esc_url( add_query_arg( 'preview', 'true', get_permalink( $post->ID ) ) ) ),  
  336.  ); 
  337.  
  338.       return $messages; 
  339.   } 
  340.  
  341.   /** 
  342.    * Change *Title* column label 
  343.    * Add Featured Image column 
  344.    */ 
  345.   function edit_admin_columns( $columns ) { 
  346.       // change 'Title' to 'Project' 
  347.       $columns['title'] = __( 'Project', 'jetpack' ); 
  348.       if ( current_theme_supports( 'post-thumbnails' ) ) { 
  349.           // add featured image before 'Project' 
  350.           $columns = array_slice( $columns, 0, 1, true ) + array( 'thumbnail' => '' ) + array_slice( $columns, 1, NULL, true ); 
  351.       } 
  352.  
  353.       return $columns; 
  354.   } 
  355.  
  356.   /** 
  357.    * Add featured image to column 
  358.    */ 
  359.   function image_column( $column, $post_id ) { 
  360.       global $post; 
  361.       switch ( $column ) { 
  362.           case 'thumbnail': 
  363.               echo get_the_post_thumbnail( $post_id, 'jetpack-portfolio-admin-thumb' ); 
  364.               break; 
  365.       } 
  366.   } 
  367.  
  368.   /** 
  369.    * Adjust image column width 
  370.    */ 
  371.   function enqueue_admin_styles( $hook ) { 
  372.       $screen = get_current_screen(); 
  373.  
  374.       if ( 'edit.php' == $hook && self::CUSTOM_POST_TYPE == $screen->post_type && current_theme_supports( 'post-thumbnails' ) ) { 
  375.           wp_add_inline_style( 'wp-admin', '.manage-column.column-thumbnail { width: 50px; } @media screen and (max-width: 360px) { .column-thumbnail{ display:none; } }' ); 
  376.       } 
  377.   } 
  378.  
  379.   /** 
  380.    * Follow CPT reading setting on CPT archive and taxonomy pages 
  381.    */ 
  382.   function query_reading_setting( $query ) { 
  383.       if ( ! is_admin() && 
  384.           $query->is_main_query() && 
  385.           ( $query->is_post_type_archive( self::CUSTOM_POST_TYPE ) || $query->is_tax( self::CUSTOM_TAXONOMY_TYPE ) || $query->is_tax( self::CUSTOM_TAXONOMY_TAG ) ) 
  386.  ) { 
  387.           $query->set( 'posts_per_page', get_option( self::OPTION_READING_SETTING, '10' ) ); 
  388.       } 
  389.   } 
  390.  
  391.   /** 
  392.    * Our [portfolio] shortcode. 
  393.    * Prints Portfolio data styled to look good on *any* theme. 
  394.    * 
  395.    * @return portfolio_shortcode_html 
  396.    */ 
  397.   static function portfolio_shortcode( $atts ) { 
  398.       // Default attributes 
  399.       $atts = shortcode_atts( array( 
  400.           'display_types' => true,  
  401.           'display_tags' => true,  
  402.           'display_content' => true,  
  403.           'show_filter' => false,  
  404.           'include_type' => false,  
  405.           'include_tag' => false,  
  406.           'columns' => 2,  
  407.           'showposts' => -1,  
  408.           'order' => 'asc',  
  409.           'orderby' => 'date',  
  410.  ), $atts, 'portfolio' ); 
  411.  
  412.       // A little sanitization 
  413.       if ( $atts['display_types'] && 'true' != $atts['display_types'] ) { 
  414.           $atts['display_types'] = false; 
  415.       } 
  416.  
  417.       if ( $atts['display_tags'] && 'true' != $atts['display_tags'] ) { 
  418.           $atts['display_tags'] = false; 
  419.       } 
  420.  
  421.       if ( $atts['display_content'] && 'true' != $atts['display_content'] && 'full' != $atts['display_content'] ) { 
  422.           $atts['display_content'] = false; 
  423.       } 
  424.  
  425.       if ( $atts['include_type'] ) { 
  426.           $atts['include_type'] = explode( ', ', str_replace( ' ', '', $atts['include_type'] ) ); 
  427.       } 
  428.  
  429.       if ( $atts['include_tag'] ) { 
  430.           $atts['include_tag'] = explode( ', ', str_replace( ' ', '', $atts['include_tag'] ) ); 
  431.       } 
  432.  
  433.       $atts['columns'] = absint( $atts['columns'] ); 
  434.  
  435.       $atts['showposts'] = intval( $atts['showposts'] ); 
  436.  
  437.  
  438.       if ( $atts['order'] ) { 
  439.           $atts['order'] = urldecode( $atts['order'] ); 
  440.           $atts['order'] = strtoupper( $atts['order'] ); 
  441.           if ( 'DESC' != $atts['order'] ) { 
  442.               $atts['order'] = 'ASC'; 
  443.           } 
  444.       } 
  445.  
  446.       if ( $atts['orderby'] ) { 
  447.           $atts['orderby'] = urldecode( $atts['orderby'] ); 
  448.           $atts['orderby'] = strtolower( $atts['orderby'] ); 
  449.           $allowed_keys = array( 'author', 'date', 'title', 'rand' ); 
  450.  
  451.           $parsed = array(); 
  452.           foreach ( explode( ', ', $atts['orderby'] ) as $portfolio_index_number => $orderby ) { 
  453.               if ( ! in_array( $orderby, $allowed_keys ) ) { 
  454.                   continue; 
  455.               } 
  456.               $parsed[] = $orderby; 
  457.           } 
  458.  
  459.           if ( empty( $parsed ) ) { 
  460.               unset( $atts['orderby'] ); 
  461.           } else { 
  462.               $atts['orderby'] = implode( ' ', $parsed ); 
  463.           } 
  464.       } 
  465.  
  466.       // enqueue shortcode styles when shortcode is used 
  467.       wp_enqueue_style( 'jetpack-portfolio-style', plugins_url( 'css/portfolio-shortcode.css', __FILE__ ), array(), '20140326' ); 
  468.  
  469.       return self::portfolio_shortcode_html( $atts ); 
  470.   } 
  471.  
  472.   /** 
  473.    * Query to retrieve entries from the Portfolio post_type. 
  474.    * 
  475.    * @return object 
  476.    */ 
  477.   static function portfolio_query( $atts ) { 
  478.       // Default query arguments 
  479.       $default = array( 
  480.           'order' => $atts['order'],  
  481.           'orderby' => $atts['orderby'],  
  482.           'posts_per_page' => $atts['showposts'],  
  483.  ); 
  484.  
  485.       $args = wp_parse_args( $atts, $default ); 
  486.       $args['post_type'] = self::CUSTOM_POST_TYPE; // Force this post type 
  487.  
  488.       if ( false != $atts['include_type'] || false != $atts['include_tag'] ) { 
  489.           $args['tax_query'] = array(); 
  490.       } 
  491.  
  492.       // If 'include_type' has been set use it on the main query 
  493.       if ( false != $atts['include_type'] ) { 
  494.           array_push( $args['tax_query'], array( 
  495.               'taxonomy' => self::CUSTOM_TAXONOMY_TYPE,  
  496.               'field' => 'slug',  
  497.               'terms' => $atts['include_type'],  
  498.  ) ); 
  499.       } 
  500.  
  501.       // If 'include_tag' has been set use it on the main query 
  502.       if ( false != $atts['include_tag'] ) { 
  503.           array_push( $args['tax_query'], array( 
  504.               'taxonomy' => self::CUSTOM_TAXONOMY_TAG,  
  505.               'field' => 'slug',  
  506.               'terms' => $atts['include_tag'],  
  507.  ) ); 
  508.       } 
  509.  
  510.       if ( false != $atts['include_type'] && false != $atts['include_tag'] ) { 
  511.           $args['tax_query']['relation'] = 'AND'; 
  512.       } 
  513.  
  514.       // Run the query and return 
  515.       $query = new WP_Query( $args ); 
  516.       return $query; 
  517.   } 
  518.  
  519.   /** 
  520.    * The Portfolio shortcode loop. 
  521.    * 
  522.    * @todo add theme color styles 
  523.    * @return html 
  524.    */ 
  525.   static function portfolio_shortcode_html( $atts ) { 
  526.  
  527.       $query = self::portfolio_query( $atts ); 
  528.       $portfolio_index_number = 0; 
  529.  
  530.       ob_start(); 
  531.  
  532.       // If we have posts, create the html 
  533.       // with hportfolio markup 
  534.       if ( $query->have_posts() ) { 
  535.  
  536.           // Render styles 
  537.           //self::themecolor_styles(); 
  538.  
  539.       ?> 
  540.           <div class="jetpack-portfolio-shortcode column-<?php echo esc_attr( $atts['columns'] ); ?>"> 
  541.           <?php  // open .jetpack-portfolio 
  542.  
  543.           // Construct the loop... 
  544.           while ( $query->have_posts() ) { 
  545.               $query->the_post(); 
  546.               $post_id = get_the_ID(); 
  547.               ?> 
  548.               <div class="portfolio-entry <?php echo esc_attr( self::get_project_class( $portfolio_index_number, $atts['columns'] ) ); ?>"> 
  549.                   <header class="portfolio-entry-header"> 
  550.                   <?php 
  551.                   // Featured image 
  552.                   echo self::get_portfolio_thumbnail_link( $post_id ); 
  553.                   ?> 
  554.  
  555.                   <h2 class="portfolio-entry-title"><a href="<?php echo esc_url( get_permalink() ); ?>" title="<?php echo esc_attr( the_title_attribute( ) ); ?>"><?php the_title(); ?></a></h2> 
  556.  
  557.                       <div class="portfolio-entry-meta"> 
  558.                       <?php 
  559.                       if ( false != $atts['display_types'] ) { 
  560.                           echo self::get_project_type( $post_id ); 
  561.                       } 
  562.  
  563.                       if ( false != $atts['display_tags'] ) { 
  564.                           echo self::get_project_tags( $post_id ); 
  565.                       } 
  566.                       ?> 
  567.                       </div> 
  568.  
  569.                   </header> 
  570.  
  571.               <?php 
  572.               // The content 
  573.               if ( false !== $atts['display_content'] ) { 
  574.                   if ( 'full' === $atts['display_content'] ) { 
  575.                       echo '<div class="portfolio-entry-content">' . the_content() . '</div>'; 
  576.                   } else { 
  577.                       echo '<div class="portfolio-entry-content">' . the_excerpt() . '</div>'; 
  578.                   } 
  579.               } ?> 
  580.               </div><!-- close .portfolio-entry --> 
  581.               <?php $portfolio_index_number++; 
  582.           } // end of while loop 
  583.  
  584.           wp_reset_postdata(); 
  585.           ?> 
  586.           </div><!-- close .jetpack-portfolio --> 
  587.       <?php 
  588.       } else { ?> 
  589.           <p><em><?php _e( 'Your Portfolio Archive currently has no entries. You can start creating them on your dashboard.', 'jetpack' ); ?></p></em> 
  590.       <?php 
  591.       } 
  592.       $html = ob_get_clean(); 
  593.  
  594.       // If there is a [portfolio] within a [portfolio], remove the shortcode 
  595.       if ( has_shortcode( $html, 'portfolio' ) ) { 
  596.           remove_shortcode( 'portfolio' ); 
  597.       } 
  598.  
  599.       // Return the HTML block 
  600.       return $html; 
  601.   } 
  602.  
  603.   /** 
  604.    * Individual project class 
  605.    * 
  606.    * @return string 
  607.    */ 
  608.   static function get_project_class( $portfolio_index_number, $columns ) { 
  609.       $project_types = wp_get_object_terms( get_the_ID(), self::CUSTOM_TAXONOMY_TYPE, array( 'fields' => 'slugs' ) ); 
  610.       $class = array(); 
  611.  
  612.       $class[] = 'portfolio-entry-column-'.$columns; 
  613.       // add a type- class for each project type 
  614.       foreach ( $project_types as $project_type ) { 
  615.           $class[] = 'type-' . esc_html( $project_type ); 
  616.       } 
  617.       if( $columns > 1) { 
  618.           if ( ( $portfolio_index_number % 2 ) == 0 ) { 
  619.               $class[] = 'portfolio-entry-mobile-first-item-row'; 
  620.           } else { 
  621.               $class[] = 'portfolio-entry-mobile-last-item-row'; 
  622.           } 
  623.       } 
  624.  
  625.       // add first and last classes to first and last items in a row 
  626.       if ( ( $portfolio_index_number % $columns ) == 0 ) { 
  627.           $class[] = 'portfolio-entry-first-item-row'; 
  628.       } elseif ( ( $portfolio_index_number % $columns ) == ( $columns - 1 ) ) { 
  629.           $class[] = 'portfolio-entry-last-item-row'; 
  630.       } 
  631.  
  632.  
  633.       /** 
  634.        * Filter the class applied to project div in the portfolio 
  635.        * 
  636.        * @module custom-content-types 
  637.        * 
  638.        * @since 3.1.0 
  639.        * 
  640.        * @param string $class class name of the div. 
  641.        * @param int $portfolio_index_number iterator count the number of columns up starting from 0. 
  642.        * @param int $columns number of columns to display the content in. 
  643.        * 
  644.        */ 
  645.       return apply_filters( 'portfolio-project-post-class', implode( " ", $class ) , $portfolio_index_number, $columns ); 
  646.   } 
  647.  
  648.   /** 
  649.    * Displays the project type that a project belongs to. 
  650.    * 
  651.    * @return html 
  652.    */ 
  653.   static function get_project_type( $post_id ) { 
  654.       $project_types = get_the_terms( $post_id, self::CUSTOM_TAXONOMY_TYPE ); 
  655.  
  656.       // If no types, return empty string 
  657.       if ( empty( $project_types ) || is_wp_error( $project_types ) ) { 
  658.           return; 
  659.       } 
  660.  
  661.       $html = '<div class="project-types"><span>' . __( 'Types', 'jetpack' ) . ':</span>'; 
  662.       $types = array(); 
  663.       // Loop thorugh all the types 
  664.       foreach ( $project_types as $project_type ) { 
  665.           $project_type_link = get_term_link( $project_type, self::CUSTOM_TAXONOMY_TYPE ); 
  666.  
  667.           if ( is_wp_error( $project_type_link ) ) { 
  668.               return $project_type_link; 
  669.           } 
  670.  
  671.           $types[] = '<a href="' . esc_url( $project_type_link ) . '" rel="tag">' . esc_html( $project_type->name ) . '</a>'; 
  672.       } 
  673.       $html .= ' '.implode( ', ', $types ); 
  674.       $html .= '</div>'; 
  675.  
  676.       return $html; 
  677.   } 
  678.  
  679.   /** 
  680.    * Displays the project tags that a project belongs to. 
  681.    * 
  682.    * @return html 
  683.    */ 
  684.   static function get_project_tags( $post_id ) { 
  685.       $project_tags = get_the_terms( $post_id, self::CUSTOM_TAXONOMY_TAG ); 
  686.  
  687.       // If no tags, return empty string 
  688.       if ( empty( $project_tags ) || is_wp_error( $project_tags ) ) { 
  689.           return false; 
  690.       } 
  691.  
  692.       $html = '<div class="project-tags"><span>' . __( 'Tags', 'jetpack' ) . ':</span>'; 
  693.       $tags = array(); 
  694.       // Loop thorugh all the tags 
  695.       foreach ( $project_tags as $project_tag ) { 
  696.           $project_tag_link = get_term_link( $project_tag, self::CUSTOM_TAXONOMY_TYPE ); 
  697.  
  698.           if ( is_wp_error( $project_tag_link ) ) { 
  699.               return $project_tag_link; 
  700.           } 
  701.  
  702.           $tags[] = '<a href="' . esc_url( $project_tag_link ) . '" rel="tag">' . esc_html( $project_tag->name ) . '</a>'; 
  703.       } 
  704.       $html .= ' '. implode( ', ', $tags ); 
  705.       $html .= '</div>'; 
  706.  
  707.       return $html; 
  708.   } 
  709.  
  710.   /** 
  711.    * Display the featured image if it's available 
  712.    * 
  713.    * @return html 
  714.    */ 
  715.   static function get_portfolio_thumbnail_link( $post_id ) { 
  716.       if ( has_post_thumbnail( $post_id ) ) { 
  717.           /** 
  718.            * Change the Portfolio thumbnail size. 
  719.            * 
  720.            * @module custom-content-types 
  721.            * 
  722.            * @since 3.4.0 
  723.            * 
  724.            * @param string|array $var Either a registered size keyword or size array. 
  725.            */ 
  726.           return '<a class="portfolio-featured-image" href="' . esc_url( get_permalink( $post_id ) ) . '">' . get_the_post_thumbnail( $post_id, apply_filters( 'jetpack_portfolio_thumbnail_size', 'large' ) ) . '</a>'; 
  727.       } 
  728.   } 
  729. } 
  730.  
  731. add_action( 'init', array( 'Jetpack_Portfolio', 'init' ) ); 
  732.  
  733. // Check on plugin activation if theme supports CPT 
  734. register_activation_hook( __FILE__, array( 'Jetpack_Portfolio', 'activation_post_type_support' ) ); 
  735. add_action( 'jetpack_activate_module_custom-content-types', array( 'Jetpack_Portfolio', 'activation_post_type_support' ) ); 
.