1: <?php
  2: 
  3: /**
  4:  * Base Papi type implementation of meta data
  5:  * for a page type.
  6:  */
  7: class Papi_Page_Type_Meta extends Papi_Core_Type {
  8: 
  9:     /**
 10:      * The meta method to call.
 11:      *
 12:      * @var string
 13:      */
 14:     public $_meta_method = 'page_type';
 15: 
 16:     /**
 17:      * Capabilities list.
 18:      *
 19:      * @var array
 20:      */
 21:     public $capabilities = [];
 22: 
 23:     /**
 24:      * The page types that lives under this page type.
 25:      *
 26:      * @var array
 27:      */
 28:     public $child_types = [];
 29: 
 30:     /**
 31:      * The description of the page type.
 32:      *
 33:      * @var string
 34:      */
 35:     public $description = '';
 36: 
 37:     /**
 38:      * Fill labels.
 39:      *
 40:      * @var bool
 41:      */
 42:     public $fill_labels = false;
 43: 
 44:     /**
 45:      * Labels, the same labels that post type object uses.
 46:      *
 47:      * @var array
 48:      */
 49:     public $labels = [];
 50: 
 51:     /**
 52:      * The name of the page type.
 53:      *
 54:      * @var string
 55:      */
 56:     public $name = '';
 57: 
 58:     /**
 59:      * The post types to register the page type with.
 60:      *
 61:      * @var array
 62:      */
 63:     public $post_type = ['page'];
 64: 
 65:     /**
 66:      * The sort order of the page type.
 67:      *
 68:      * @var int
 69:      */
 70:     public $sort_order = null;
 71: 
 72:     /**
 73:      * Show standard page type or not.
 74:      *
 75:      * @var bool
 76:      */
 77:     public $standard_type = false;
 78: 
 79:     /**
 80:      * The template of the page type.
 81:      *
 82:      * @var string
 83:      */
 84:     public $template = '';
 85: 
 86:     /**
 87:      * The page type thumbnail.
 88:      *
 89:      * @var string
 90:      */
 91:     public $thumbnail = '';
 92: 
 93:     /**
 94:      * The constructor.
 95:      *
 96:      * Load a page type by the file.
 97:      *
 98:      * @param string $file_path
 99:      */
100:     public function __construct( $file_path = '' ) {
101:         parent::__construct( $file_path );
102:         $this->setup_page_type();
103:         $this->setup_post_types();
104:     }
105: 
106:     /**
107:      * Is the user allowed to view this page type?
108:      *
109:      * @return bool
110:      */
111:     public function current_user_is_allowed() {
112:         foreach ( $this->capabilities as $capability ) {
113:             if ( ! current_user_can( $capability ) ) {
114:                 return false;
115:             }
116:         }
117: 
118:         return true;
119:     }
120: 
121:     /**
122:      * Get child page types that lives under the current page type.
123:      *
124:      * @return array
125:      */
126:     public function get_child_types() {
127:         $child_types = [];
128: 
129:         foreach ( papi_to_array( $this->child_types ) as $id ) {
130:             $child_type = papi_get_page_type_by_id( $id );
131: 
132:             if ( papi_is_page_type( $child_type ) ) {
133:                 $child_types[] = $child_type;
134:             }
135:         }
136: 
137:         return $child_types;
138:     }
139: 
140:     /**
141:      * Get labels that should be changed
142:      * when using `fill_labels` option.
143:      *
144:      * @return array
145:      */
146:     public function get_labels() {
147:         if ( ! $this->fill_labels ) {
148:             return $this->labels;
149:         }
150: 
151:         return array_merge( $this->labels, [
152:             'add_new_item' => sprintf(
153:                 '%s %s',
154:                 __( 'Add New', 'papi' ),
155:                 $this->name
156:             ),
157:             'edit_item' => sprintf(
158:                 '%s %s',
159:                 __( 'Edit', 'papi' ),
160:                 $this->name
161:             ),
162:             'view_item' => sprintf(
163:                 '%s %s',
164:                 __( 'View', 'papi' ),
165:                 $this->name
166:             )
167:         ] );
168:     }
169: 
170:     /**
171:      * Get page type image thumbnail.
172:      *
173:      * @return string
174:      */
175:     public function get_thumbnail() {
176:         if ( empty( $this->thumbnail ) ) {
177:             return '';
178:         }
179: 
180:         return $this->thumbnail;
181:     }
182: 
183:     /**
184:      * Check so we have a name on the page type.
185:      *
186:      * @return bool
187:      */
188:     public function has_name() {
189:         return ! empty( $this->name );
190:     }
191: 
192:     /**
193:      * Check if the given post is allowed to use the page type.
194:      *
195:      * @param string $post_type
196:      *
197:      * @return bool
198:      */
199:     public function has_post_type( $post_type ) {
200:         return in_array( $post_type, $this->post_type );
201:     }
202: 
203:     /**
204:      * Setup page type variables.
205:      */
206:     private function setup_page_type() {
207:         if ( is_null( $this->sort_order ) ) {
208:             $this->sort_order = papi_filter_settings_sort_order();
209:         }
210:     }
211: 
212:     /**
213:      * Setup post types array.
214:      */
215:     private function setup_post_types() {
216:         $this->post_type = papi_to_array( $this->post_type );
217: 
218:         // Set a default value to post types array
219:         // if we don't have a array or a empty array.
220:         if ( empty( $this->post_type ) ) {
221:             $this->post_type = ['page'];
222:         }
223:     }
224: }
225: