1: <?php
  2: 
  3: /**
  4:  * Papi Porter class that handle import and export
  5:  * of properties data.
  6:  */
  7: final class Papi_Porter extends Papi_Container {
  8: 
  9:     /**
 10:      * The driver that should be used.
 11:      *
 12:      * @var Papi_Porter_Driver
 13:      */
 14:     protected $driver;
 15: 
 16:     /**
 17:      * The constructor.
 18:      */
 19:     public function __construct() {
 20:         $this->add_driver( new Papi_Porter_Driver_Core );
 21:         $this->use_driver( 'core' );
 22:         $this->driver->bootstrap();
 23:     }
 24: 
 25:     /**
 26:      * Add Porter Driver.
 27:      *
 28:      * @param  Papi_Porter_Driver $driver
 29:      *
 30:      * @return Papi_Porter
 31:      */
 32:     public function add_driver( Papi_Porter_Driver $driver ) {
 33:         $driver->set_porter( $this );
 34:         return $this;
 35:     }
 36: 
 37:     /**
 38:      * Add after filter.
 39:      *
 40:      * @param  string  $filter
 41:      * @param  Closure $closure
 42:      * @param  int     $priority
 43:      * @param  int     $accepted_args
 44:      *
 45:      * @return bool
 46:      */
 47:     public function after( $filter, Closure $closure, $priority = 10, $accepted_args = 2 ) {
 48:         $filter = $this->driver->filter( 'after', $filter );
 49:         return add_filter( $filter, $closure, $priority, $accepted_args );
 50:     }
 51: 
 52:     /**
 53:      * Add before filter.
 54:      *
 55:      * @param  string  $filter
 56:      * @param  Closure $closure
 57:      * @param  int     $priority
 58:      * @param  int     $accepted_args
 59:      *
 60:      * @return bool
 61:      */
 62:     public function before( $filter, Closure $closure, $priority = 10, $accepted_args = 2 ) {
 63:         $filter = $this->driver->filter( 'before', $filter );
 64:         return add_filter( $filter, $closure, $priority, $accepted_args );
 65:     }
 66: 
 67:     /**
 68:      * Alias for `add_driver` or `use_driver` method.
 69:      *
 70:      * @param  string|Papi_Porter_Driver $driver
 71:      *
 72:      * @return Papi_Porter
 73:      */
 74:     public function driver( $driver ) {
 75:         return $driver instanceof Papi_Porter_Driver ?
 76:             $this->add_driver( $driver ) :
 77:             $this->use_driver( $driver );
 78:     }
 79: 
 80:     /**
 81:      * Check if a driver exists or not.
 82:      *
 83:      * @param  string $driver
 84:      *
 85:      * @return bool
 86:      */
 87:     public function driver_exists( $driver ) {
 88:         return is_string( $driver ) && $this->exists( 'driver.' . $driver );
 89:     }
 90: 
 91:     /**
 92:      * Export data from Papi. With or without all property options.
 93:      *
 94:      * @param  mixed $post_id
 95:      * @param  bool  $only_values
 96:      *
 97:      * @return array
 98:      */
 99:     public function export( $post_id, $only_values = false ) {
100:         $post_id = papi_get_post_id( $post_id );
101: 
102:         if ( empty( $post_id ) ) {
103:             return [];
104:         }
105: 
106:         $slugs = papi_get_slugs( $post_id );
107: 
108:         foreach ( $slugs as $key => $box ) {
109:             foreach ( $box as $index => $slug ) {
110:                 unset( $slugs[$key][$index] );
111:                 $value = papi_get_field( $post_id, $slug, null );
112: 
113:                 if ( $only_values === true ) {
114:                     $slugs[$key][$slug] = $value;
115:                 } else {
116:                     $page = papi_get_page( $post_id );
117: 
118:                     // @codeCoverageIgnoreStart
119:                     if ( is_null( $page ) ) {
120:                         continue;
121:                     }
122:                     // @codeCoverageIgnoreEnd
123: 
124:                     $property = $page->get_property( $slug );
125: 
126:                     // @codeCoverageIgnoreStart
127:                     if ( ! papi_is_property( $property ) ) {
128:                         continue;
129:                     }
130:                     // @codeCoverageIgnoreEnd
131: 
132:                     $options = clone $property->get_options();
133:                     $options->value = $value;
134:                     $slugs[$key][$slug] = $options;
135:                 }
136:             }
137:         }
138: 
139:         return $slugs;
140:     }
141: 
142:     /**
143:      * Fire filter.
144:      *
145:      * @param  array $options
146:      *
147:      * @throws Exception if `filter` is missing from options array.
148:      * @throws Exception if `value` is missing from options array.
149:      *
150:      * @return mixed
151:      */
152:     public function fire_filter( array $options ) {
153:         if ( ! isset( $options['type'] ) ) {
154:             $options['type'] = 'after';
155:         }
156: 
157:         if ( ! isset( $options['filter'] ) ) {
158:             throw new Exception( 'Missing `filter` in options array.' );
159:         }
160: 
161:         if ( ! isset( $options['value'] ) ) {
162:             throw new Exception( 'Missing `value` in options array.' );
163:         }
164: 
165:         $arguments = [
166:             $this->driver->filter( $options['type'], $options['filter'] ),
167:         ];
168: 
169:         $value = $options['value'];
170: 
171:         foreach ( papi_to_array( $value ) as $val ) {
172:             $arguments[] = $val;
173:         }
174: 
175:         return call_user_func_array( 'apply_filters', $arguments );
176:     }
177: 
178:     /**
179:      * Get import options.
180:      *
181:      * @param  mixed $options
182:      *
183:      * @return array
184:      */
185:     protected function get_import_options( $options ) {
186:         $default_options = [
187:             'post_id'       => 0,
188:             'page_type'     => '',
189:             'update_arrays' => false
190:         ];
191: 
192:         if ( ! is_array( $options ) ) {
193:             $options = array_merge( $default_options, [
194:                 'post_id' => papi_get_post_id( $options )
195:             ] );
196:         }
197: 
198:         return $options;
199:     }
200: 
201:     /**
202:      * Get value that should be saved.
203:      *
204:      * @param  array $options
205:      *
206:      * @return mixed
207:      */
208:     protected function get_value( array $options ) {
209:         return $this->driver->get_value( $options );
210:     }
211: 
212:     /**
213:      * Import data to Papi.
214:      *
215:      * @param  mixed $options
216:      * @param  array $fields
217:      *
218:      * @return bool
219:      */
220:     public function import( $options, array $fields = [] ) {
221:         $options   = $this->get_import_options( $options );
222:         $post_id   = $options['post_id'];
223:         $page_type = $options['page_type'];
224: 
225:         if ( isset( $options['update_arrays'] ) ) {
226:             $this->driver->set_options( [
227:                 'update_array' => $options['update_arrays']
228:             ] );
229:         }
230: 
231:         if ( empty( $post_id ) || empty( $fields ) ) {
232:             return false;
233:         }
234: 
235:         if ( empty( $page_type ) ) {
236:             $page_type = papi_get_page_type_by_post_id( $options['post_id'] );
237:         }
238: 
239:         if ( is_string( $page_type ) ) {
240:             $page_type = papi_get_page_type_by_id( $page_type );
241:         }
242: 
243:         if ( ! papi_is_page_type( $page_type ) ) {
244:             return false;
245:         }
246: 
247:         $result = true;
248: 
249:         foreach ( $fields as $slug => $value ) {
250:             if ( ! is_string( $slug ) || papi_is_empty( $value ) ) {
251:                 continue;
252:             }
253: 
254:             $property = $page_type->get_property( $slug );
255: 
256:             if ( ! papi_is_property( $property ) ) {
257:                 $result = false;
258:                 continue;
259:             }
260: 
261:             $value = $this->fire_filter( [
262:                 'filter' => 'driver:value',
263:                 'type'   => 'before',
264:                 'value'  => [
265:                     $value,
266:                     $slug
267:                 ]
268:             ] );
269: 
270:             $value = $this->get_value( [
271:                 'post_id'  => $post_id,
272:                 'property' => $property,
273:                 'slug'     => $slug,
274:                 'value'    => $value
275:             ] );
276: 
277:             $value = $this->fire_filter( [
278:                 'filter' => 'driver:value',
279:                 'type'   => 'after',
280:                 'value'  => [
281:                     $value,
282:                     $slug
283:                 ]
284:             ] );
285: 
286:             $out = papi_update_property_meta_value( [
287:                 'post_id' => $post_id,
288:                 'slug'    => $slug,
289:                 'value'   => $value
290:             ] );
291: 
292:             $result = $out ? $result : $out;
293:         }
294: 
295:         return $result;
296:     }
297: 
298:     /**
299:      * Add options per property.
300:      *
301:      * @param  array $options
302:      *
303:      * @return Papi_Porter
304:      */
305:     public function options( array $options = [] ) {
306:         $this->driver->set_options( [
307:             'custom' => $options
308:         ] );
309:         return $this;
310:     }
311: 
312:     /**
313:      * Change Porter driver.
314:      *
315:      * @param  string $driver
316:      *
317:      * @throws InvalidArgumentException if an argument is not of the expected type.
318:      * @throws Exception if driver name does not exist.
319:      *
320:      * @return Papi_Porter
321:      */
322:     public function use_driver( $driver ) {
323:         if ( ! is_string( $driver ) ) {
324:             throw new InvalidArgumentException(
325:                 'Invalid argument. Must be string.'
326:             );
327:         }
328: 
329:         $driver = strtolower( $driver );
330: 
331:         if ( ! $this->exists( 'driver.' . $driver ) ) {
332:             throw new Exception( sprintf(
333:                 '`%s` driver does not exist.',
334:                 $driver
335:             ) );
336:         }
337: 
338:         $class = $this->make( 'driver.' . $driver );
339: 
340:         if ( class_exists( $class ) ) {
341:             $this->driver = new $class( $this );
342:             $this->driver->bootstrap();
343:         }
344: 
345:         return $this;
346:     }
347: }
348: