1: <?php
  2: 
  3: /**
  4:  * Core class that handle core post data.
  5:  */
  6: class Papi_Core_Data_Handler {
  7: 
  8:     /**
  9:      * The fields that should be overwritten.
 10:      *
 11:      * @var array
 12:      */
 13:     protected $overwrite = [];
 14: 
 15:     /**
 16:      * Decode property.
 17:      *
 18:      * @param string $key
 19:      * @param string $value
 20:      *
 21:      * @return mixed
 22:      */
 23:     protected function decode_property( $key, $value ) {
 24:         if ( papi_is_property_type_key( $key ) && is_string( $value ) ) {
 25:             $value = base64_decode( $value );
 26:             $value = papi_maybe_json_decode( $value );
 27:         }
 28: 
 29:         return $value;
 30:     }
 31: 
 32:     /**
 33:      * Get post data.
 34:      *
 35:      * @param  string $pattern
 36:      *
 37:      * @return array
 38:      */
 39:     protected function get_post_data( $pattern = '/^papi\_.*/' ) {
 40:         $data = [];
 41:         $keys = preg_grep( $pattern, array_keys( $_POST ) );
 42: 
 43:         foreach ( $keys as $key ) {
 44:             // Fix for input fields that should be true on `on` value.
 45:             if ( $_POST[ $key ] === 'on' ) {
 46:                 $data[ $key ] = true;
 47:             } else {
 48:                 $value = $this->decode_property( $key, $_POST[ $key ] );
 49:                 $data[ $key ] = $this->prepare_post_data( $value );
 50:             }
 51:         }
 52: 
 53:         // Don't wont to save meta nonce field.
 54:         if ( isset( $data['papi_meta_nonce'] ) ) {
 55:             unset( $data['papi_meta_nonce'] );
 56:         }
 57: 
 58:         return $data;
 59:     }
 60: 
 61:     /**
 62:      * Pre get deep keys and value.
 63:      *
 64:      * Used for saving pre data when properties are in a flexible or repeater.
 65:      *
 66:      * @param  array $arr
 67:      *
 68:      * @return array
 69:      */
 70:     protected function get_pre_deep_keys_value( array $arr ) {
 71:         $keys  = [];
 72:         $value = null;
 73: 
 74:         foreach ( $arr as $key => $v ) {
 75:             if ( is_array( $v ) ) {
 76:                 $keys[] = $key;
 77:                 list( $ks, $val ) = $this->get_pre_deep_keys_value( $v );
 78:                 $keys   = array_merge( $keys, $ks );
 79:                 $value  = $val;
 80:             } else {
 81:                 $keys[] = $key;
 82:                 $value  = $v;
 83:             }
 84:         }
 85: 
 86:         return [$keys, $value];
 87:     }
 88: 
 89:     /**
 90:      * Prepare post data.
 91:      * Will decode property options recursive.
 92:      *
 93:      * @param  mixed $data
 94:      *
 95:      * @return mixed
 96:      */
 97:     protected function prepare_post_data( $data ) {
 98:         if ( ! is_array( $data ) ) {
 99:             return $data;
100:         }
101: 
102:         foreach ( $data as $key => $value ) {
103:             if ( is_array( $value ) ) {
104:                 $data[$key] = $this->prepare_post_data( $value );
105:             } else {
106:                 $data[$key] = $this->decode_property( $key, $value );
107:             }
108:         }
109: 
110:         return $data;
111:     }
112: 
113:     /**
114:      * Prepare properties data for saving.
115:      *
116:      * @param  array $data
117:      * @param  int   $post_id
118:      *
119:      * @return array
120:      */
121:     protected function prepare_properties_data( array $data = [], $post_id = 0 ) {
122:         // Since we are storing witch property it is in the $data array
123:         // we need to remove that and set the property type to the property
124:         // and make a array of the property type and the value.
125:         foreach ( $data as $key => $value ) {
126:             $property_type_key = papi_get_property_type_key();
127: 
128:             if ( strpos( $key, $property_type_key ) === false ) {
129:                 continue;
130:             }
131: 
132:             $property_key = str_replace( $property_type_key, '', $key );
133: 
134:             // Check if value exists.
135:             if ( isset( $data[$property_key] ) ) {
136:                 $data[$property_key] = [
137:                     'type'  => $value,
138:                     'value' => $data[$property_key]
139:                 ];
140:             }
141: 
142:             unset( $data[$key] );
143:         }
144: 
145:         foreach ( $data as $key => $item ) {
146:             $property = papi_get_property_type( $item['type'] );
147: 
148:             unset( $data[ $key ] );
149: 
150:             if ( papi_is_property( $property ) ) {
151:                 // Run `update_value` method on the property class.
152:                 $data[$key] = $property->update_value(
153:                     $item['value'],
154:                     papi_remove_papi( $key ),
155:                     $post_id
156:                 );
157: 
158:                 // Apply `update_value` filter so this can be changed from the theme for specified property type.
159:                 $data[$key] = papi_filter_update_value(
160:                     $item['type']->type,
161:                     $data[$key],
162:                     papi_remove_papi( $key ),
163:                     $post_id
164:                 );
165: 
166:                 if ( $item['type']->overwrite ) {
167:                     $slug = papi_remove_papi( $key );
168:                     $this->overwrite[$slug] = $data[$key];
169:                 }
170:             }
171:         }
172: 
173:         return $data;
174:     }
175: 
176:     /**
177:      * Get pre data that should be saved before all properties data.
178:      */
179:     protected function get_pre_data() {
180:         return $this->get_post_data( '/^\_papi\_.*/' );
181:     }
182: }
183: