gravityview /
GravityView
Complex classes like GravityView_Edit_Entry_Render often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use GravityView_Edit_Entry_Render, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 16 | class GravityView_Edit_Entry_Render { |
||
| 17 | |||
| 18 | /** |
||
| 19 | * @var GravityView_Edit_Entry |
||
| 20 | */ |
||
| 21 | protected $loader; |
||
| 22 | |||
| 23 | /** |
||
| 24 | * @var string String used to generate unique nonce for the entry/form/view combination. Allows access to edit page. |
||
| 25 | */ |
||
| 26 | static $nonce_key; |
||
| 27 | |||
| 28 | /** |
||
| 29 | * @since 1.9 |
||
| 30 | * @var string String used for check valid edit entry form submission. Allows saving edit form values. |
||
| 31 | */ |
||
| 32 | private static $nonce_field = 'is_gv_edit_entry'; |
||
| 33 | |||
| 34 | /** |
||
| 35 | * @since 1.9 |
||
| 36 | * @var bool Whether to allow save and continue functionality |
||
| 37 | */ |
||
| 38 | private static $supports_save_and_continue = false; |
||
| 39 | |||
| 40 | /** |
||
| 41 | * Gravity Forms entry array |
||
| 42 | * |
||
| 43 | * @var array |
||
| 44 | */ |
||
| 45 | public $entry; |
||
| 46 | |||
| 47 | /** |
||
| 48 | * Gravity Forms entry array (it won't get changed during this class lifecycle) |
||
| 49 | * @since 1.17.2 |
||
| 50 | * @var array |
||
| 51 | */ |
||
| 52 | private static $original_entry = array(); |
||
| 53 | |||
| 54 | /** |
||
| 55 | * Gravity Forms form array (GravityView modifies the content through this class lifecycle) |
||
| 56 | * |
||
| 57 | * @var array |
||
| 58 | */ |
||
| 59 | public $form; |
||
| 60 | |||
| 61 | /** |
||
| 62 | * Gravity Forms form array (it won't get changed during this class lifecycle) |
||
| 63 | * @since 1.16.2.1 |
||
| 64 | * @var array |
||
| 65 | */ |
||
| 66 | private static $original_form; |
||
| 67 | |||
| 68 | /** |
||
| 69 | * Gravity Forms form array after the form validation process |
||
| 70 | * @since 1.13 |
||
| 71 | * @var array |
||
| 72 | */ |
||
| 73 | public $form_after_validation = null; |
||
| 74 | |||
| 75 | /** |
||
| 76 | * Hold an array of GF field objects that have calculation rules |
||
| 77 | * @var array |
||
| 78 | */ |
||
| 79 | public $fields_with_calculation = array(); |
||
| 80 | |||
| 81 | /** |
||
| 82 | * Gravity Forms form id |
||
| 83 | * |
||
| 84 | * @var int |
||
| 85 | */ |
||
| 86 | public $form_id; |
||
| 87 | |||
| 88 | /** |
||
| 89 | * ID of the current view |
||
| 90 | * |
||
| 91 | * @var int |
||
| 92 | */ |
||
| 93 | public $view_id; |
||
| 94 | |||
| 95 | /** |
||
| 96 | * Updated entry is valid (GF Validation object) |
||
| 97 | * |
||
| 98 | * @var array |
||
| 99 | */ |
||
| 100 | public $is_valid = NULL; |
||
| 101 | |||
| 102 | 3 | function __construct( GravityView_Edit_Entry $loader ) { |
|
| 105 | |||
| 106 | 3 | function load() { |
|
| 107 | |||
| 108 | /** @define "GRAVITYVIEW_DIR" "../../../" */ |
||
| 109 | 3 | include_once( GRAVITYVIEW_DIR .'includes/class-admin-approve-entries.php' ); |
|
| 110 | |||
| 111 | // Don't display an embedded form when editing an entry |
||
| 112 | 3 | add_action( 'wp_head', array( $this, 'prevent_render_form' ) ); |
|
| 113 | 3 | add_action( 'wp_footer', array( $this, 'prevent_render_form' ) ); |
|
| 114 | |||
| 115 | // Stop Gravity Forms processing what is ours! |
||
| 116 | 3 | add_filter( 'wp', array( $this, 'prevent_maybe_process_form'), 8 ); |
|
| 117 | |||
| 118 | 3 | add_filter( 'gravityview_is_edit_entry', array( $this, 'is_edit_entry') ); |
|
| 119 | |||
| 120 | 3 | add_action( 'gravityview_edit_entry', array( $this, 'init' ) ); |
|
| 121 | |||
| 122 | // Disable conditional logic if needed (since 1.9) |
||
| 123 | 3 | add_filter( 'gform_has_conditional_logic', array( $this, 'manage_conditional_logic' ), 10, 2 ); |
|
| 124 | |||
| 125 | // Make sure GF doesn't validate max files (since 1.9) |
||
| 126 | 3 | add_filter( 'gform_plupload_settings', array( $this, 'modify_fileupload_settings' ), 10, 3 ); |
|
| 127 | |||
| 128 | // Add fields expected by GFFormDisplay::validate() |
||
| 129 | 3 | add_filter( 'gform_pre_validation', array( $this, 'gform_pre_validation') ); |
|
| 130 | |||
| 131 | // Fix multiselect value for GF 2.2 |
||
| 132 | 3 | add_filter( 'gravityview/edit_entry/field_value_multiselect', array( $this, 'fix_multiselect_value_serialization' ), 10, 3 ); |
|
| 133 | 3 | } |
|
| 134 | |||
| 135 | /** |
||
| 136 | * Don't show any forms embedded on a page when GravityView is in Edit Entry mode |
||
| 137 | * |
||
| 138 | * Adds a `__return_empty_string` filter on the Gravity Forms shortcode on the `wp_head` action |
||
| 139 | * And then removes it on the `wp_footer` action |
||
| 140 | * |
||
| 141 | * @since 1.16.1 |
||
| 142 | * |
||
| 143 | * @return void |
||
| 144 | */ |
||
| 145 | 1 | public function prevent_render_form() { |
|
| 146 | 1 | if( $this->is_edit_entry() ) { |
|
| 147 | 1 | if( 'wp_head' === current_filter() ) { |
|
| 148 | 1 | add_filter( 'gform_shortcode_form', '__return_empty_string' ); |
|
| 149 | } else { |
||
| 150 | 1 | remove_filter( 'gform_shortcode_form', '__return_empty_string' ); |
|
| 151 | } |
||
| 152 | } |
||
| 153 | 1 | } |
|
| 154 | |||
| 155 | /** |
||
| 156 | * Because we're mimicking being a front-end Gravity Forms form while using a Gravity Forms |
||
| 157 | * backend form, we need to prevent them from saving twice. |
||
| 158 | * @return void |
||
| 159 | */ |
||
| 160 | public function prevent_maybe_process_form() { |
||
| 161 | |||
| 162 | if( ! empty( $_POST ) ) { |
||
| 163 | do_action( 'gravityview_log_debug', 'GravityView_Edit_Entry[prevent_maybe_process_form] $_POSTed data (sanitized): ', esc_html( print_r( $_POST, true ) ) ); |
||
| 164 | } |
||
| 165 | |||
| 166 | if( $this->is_edit_entry_submission() ) { |
||
| 167 | remove_action( 'wp', array( 'RGForms', 'maybe_process_form'), 9 ); |
||
| 168 | remove_action( 'wp', array( 'GFForms', 'maybe_process_form'), 9 ); |
||
| 169 | } |
||
| 170 | } |
||
| 171 | |||
| 172 | /** |
||
| 173 | * Is the current page an Edit Entry page? |
||
| 174 | * @return boolean |
||
| 175 | */ |
||
| 176 | 4 | public function is_edit_entry() { |
|
| 177 | |||
| 178 | 4 | $is_edit_entry = GravityView_frontend::is_single_entry() && ! empty( $_GET['edit'] ); |
|
| 179 | |||
| 180 | 4 | return ( $is_edit_entry || $this->is_edit_entry_submission() ); |
|
| 181 | } |
||
| 182 | |||
| 183 | /** |
||
| 184 | * Is the current page an Edit Entry page? |
||
| 185 | * @since 1.9 |
||
| 186 | * @return boolean |
||
| 187 | */ |
||
| 188 | 3 | public function is_edit_entry_submission() { |
|
| 189 | 3 | return !empty( $_POST[ self::$nonce_field ] ); |
|
| 190 | } |
||
| 191 | |||
| 192 | /** |
||
| 193 | * When Edit entry view is requested setup the vars |
||
| 194 | */ |
||
| 195 | 3 | private function setup_vars() { |
|
| 196 | 3 | $gravityview_view = GravityView_View::getInstance(); |
|
| 197 | |||
| 198 | |||
| 199 | 3 | $entries = $gravityview_view->getEntries(); |
|
| 200 | 3 | self::$original_entry = $entries[0]; |
|
| 201 | 3 | $this->entry = $entries[0]; |
|
| 202 | |||
| 203 | 3 | self::$original_form = $gravityview_view->getForm(); |
|
| 204 | 3 | $this->form = $gravityview_view->getForm(); |
|
| 205 | 3 | $this->form_id = $gravityview_view->getFormId(); |
|
| 206 | 3 | $this->view_id = $gravityview_view->getViewId(); |
|
| 207 | |||
| 208 | 3 | self::$nonce_key = GravityView_Edit_Entry::get_nonce_key( $this->view_id, $this->form_id, $this->entry['id'] ); |
|
| 209 | 3 | } |
|
| 210 | |||
| 211 | |||
| 212 | /** |
||
| 213 | * Load required files and trigger edit flow |
||
| 214 | * |
||
| 215 | * Run when the is_edit_entry returns true. |
||
| 216 | * |
||
| 217 | * @param GravityView_View_Data $gv_data GravityView Data object |
||
| 218 | * @return void |
||
| 219 | */ |
||
| 220 | 4 | public function init( $gv_data ) { |
|
| 221 | |||
| 222 | 4 | require_once( GFCommon::get_base_path() . '/form_display.php' ); |
|
| 223 | 4 | require_once( GFCommon::get_base_path() . '/entry_detail.php' ); |
|
| 224 | |||
| 225 | 4 | $this->setup_vars(); |
|
| 226 | |||
| 227 | // Multiple Views embedded, don't proceed if nonce fails |
||
| 228 | 4 | $multiple_views = defined( 'GRAVITYVIEW_FUTURE_CORE_LOADED' ) ? gravityview()->views->count() > 1 : $gv_data->has_multiple_views(); |
|
| 229 | 4 | if( $multiple_views && ! wp_verify_nonce( $_GET['edit'], self::$nonce_key ) ) { |
|
| 230 | do_action('gravityview_log_error', __METHOD__ . ': Nonce validation failed for the Edit Entry request; returning' ); |
||
| 231 | return; |
||
| 232 | } |
||
| 233 | |||
| 234 | // Sorry, you're not allowed here. |
||
| 235 | 4 | if( false === $this->user_can_edit_entry( true ) ) { |
|
| 236 | 1 | do_action('gravityview_log_error', __METHOD__ . ': User is not allowed to edit this entry; returning', $this->entry ); |
|
| 237 | 1 | return; |
|
| 238 | } |
||
| 239 | |||
| 240 | 4 | $this->print_scripts(); |
|
| 241 | |||
| 242 | 4 | $this->process_save(); |
|
| 243 | |||
| 244 | 4 | $this->edit_entry_form(); |
|
| 245 | |||
| 246 | 4 | } |
|
| 247 | |||
| 248 | |||
| 249 | /** |
||
| 250 | * Force Gravity Forms to output scripts as if it were in the admin |
||
| 251 | * @return void |
||
| 252 | */ |
||
| 253 | 3 | private function print_scripts() { |
|
| 254 | 3 | $gravityview_view = GravityView_View::getInstance(); |
|
| 255 | |||
| 256 | 3 | wp_register_script( 'gform_gravityforms', GFCommon::get_base_url().'/js/gravityforms.js', array( 'jquery', 'gform_json', 'gform_placeholder', 'sack', 'plupload-all', 'gravityview-fe-view' ) ); |
|
| 257 | |||
| 258 | 3 | GFFormDisplay::enqueue_form_scripts($gravityview_view->getForm(), false); |
|
| 259 | |||
| 260 | // Sack is required for images |
||
| 261 | 3 | wp_print_scripts( array( 'sack', 'gform_gravityforms' ) ); |
|
| 262 | 3 | } |
|
| 263 | |||
| 264 | |||
| 265 | /** |
||
| 266 | * Process edit entry form save |
||
| 267 | */ |
||
| 268 | 4 | private function process_save() { |
|
| 269 | |||
| 270 | 4 | if( empty( $_POST ) || ! isset( $_POST['lid'] ) ) { |
|
| 271 | 4 | return; |
|
| 272 | } |
||
| 273 | |||
| 274 | // Make sure the entry, view, and form IDs are all correct |
||
| 275 | 4 | $valid = $this->verify_nonce(); |
|
| 276 | |||
| 277 | 4 | if( !$valid ) { |
|
| 278 | do_action('gravityview_log_error', __METHOD__ . ' Nonce validation failed.' ); |
||
| 279 | return; |
||
| 280 | } |
||
| 281 | |||
| 282 | 4 | if( $this->entry['id'] !== $_POST['lid'] ) { |
|
| 283 | do_action('gravityview_log_error', __METHOD__ . ' Entry ID did not match posted entry ID.' ); |
||
| 284 | return; |
||
| 285 | } |
||
| 286 | |||
| 287 | 4 | do_action('gravityview_log_debug', __METHOD__ . ': $_POSTed data (sanitized): ', esc_html( print_r( $_POST, true ) ) ); |
|
| 288 | |||
| 289 | 4 | $this->process_save_process_files( $this->form_id ); |
|
| 290 | |||
| 291 | 4 | $this->validate(); |
|
| 292 | |||
| 293 | 4 | if( $this->is_valid ) { |
|
| 294 | |||
| 295 | 4 | do_action('gravityview_log_debug', __METHOD__ . ': Submission is valid.' ); |
|
| 296 | |||
| 297 | /** |
||
| 298 | * @hack This step is needed to unset the adminOnly from form fields, to add the calculation fields |
||
| 299 | */ |
||
| 300 | 4 | $form = $this->form_prepare_for_save(); |
|
| 301 | |||
| 302 | /** |
||
| 303 | * @hack to avoid the capability validation of the method save_lead for GF 1.9+ |
||
| 304 | */ |
||
| 305 | 4 | unset( $_GET['page'] ); |
|
| 306 | |||
| 307 | 4 | $date_created = $this->entry['date_created']; |
|
| 308 | |||
| 309 | /** |
||
| 310 | * @hack to force Gravity Forms to use $read_value_from_post in GFFormsModel::save_lead() |
||
| 311 | * @since 1.17.2 |
||
| 312 | */ |
||
| 313 | 4 | unset( $this->entry['date_created'] ); |
|
| 314 | |||
| 315 | 4 | GFFormsModel::save_lead( $form, $this->entry ); |
|
| 316 | |||
| 317 | // Delete the values for hidden inputs |
||
| 318 | 4 | $this->unset_hidden_field_values(); |
|
| 319 | |||
| 320 | 4 | $this->entry['date_created'] = $date_created; |
|
| 321 | |||
| 322 | // Process calculation fields |
||
| 323 | 4 | $this->update_calculation_fields(); |
|
| 324 | |||
| 325 | // Perform actions normally performed after updating a lead |
||
| 326 | 4 | $this->after_update(); |
|
| 327 | |||
| 328 | /** |
||
| 329 | * Must be AFTER after_update()! |
||
| 330 | * @see https://github.com/gravityview/GravityView/issues/764 |
||
| 331 | */ |
||
| 332 | 4 | $this->maybe_update_post_fields( $form ); |
|
| 333 | |||
| 334 | /** |
||
| 335 | * @action `gravityview/edit_entry/after_update` Perform an action after the entry has been updated using Edit Entry |
||
| 336 | * @param array $form Gravity Forms form array |
||
| 337 | * @param string $entry_id Numeric ID of the entry that was updated |
||
| 338 | * @param GravityView_Edit_Entry_Render $this This object |
||
| 339 | */ |
||
| 340 | 4 | do_action( 'gravityview/edit_entry/after_update', $this->form, $this->entry['id'], $this ); |
|
| 341 | |||
| 342 | } else { |
||
| 343 | do_action('gravityview_log_error', __METHOD__ . ': Submission is NOT valid.', $this->entry ); |
||
| 344 | } |
||
| 345 | |||
| 346 | 4 | } // process_save |
|
| 347 | |||
| 348 | /** |
||
| 349 | * Delete the value of fields hidden by conditional logic when the entry is edited |
||
| 350 | * |
||
| 351 | * @uses GFFormsModel::update_lead_field_value() |
||
| 352 | * |
||
| 353 | * @since 1.17.4 |
||
| 354 | * |
||
| 355 | * @return void |
||
| 356 | */ |
||
| 357 | 3 | private function unset_hidden_field_values() { |
|
| 358 | 3 | global $wpdb; |
|
| 359 | |||
| 360 | 3 | if ( method_exists( 'GFFormsModel', 'get_entry_meta_table_name' ) ) { |
|
| 361 | $entry_meta_table = GFFormsModel::get_entry_meta_table_name(); |
||
| 362 | $current_fields = $wpdb->get_results( $wpdb->prepare( "SELECT meta_key, meta_value FROM $entry_meta_table WHERE entry_id=%d", $this->entry['id'] ) ); |
||
| 363 | } else { |
||
| 364 | 3 | $lead_detail_table = GFFormsModel::get_lead_details_table_name(); |
|
| 365 | 3 | $current_fields = $wpdb->get_results( $wpdb->prepare( "SELECT id, field_number FROM $lead_detail_table WHERE lead_id=%d", $this->entry['id'] ) ); |
|
| 366 | } |
||
| 367 | |||
| 368 | 3 | foreach ( $this->entry as $input_id => $field_value ) { |
|
| 369 | |||
| 370 | 3 | $field = RGFormsModel::get_field( $this->form, $input_id ); |
|
| 371 | |||
| 372 | // Reset fields that are hidden |
||
| 373 | // Don't pass $entry as fourth parameter; force using $_POST values to calculate conditional logic |
||
| 374 | 3 | if ( GFFormsModel::is_field_hidden( $this->form, $field, array(), NULL ) ) { |
|
| 375 | |||
| 376 | // List fields are stored as empty arrays when empty |
||
| 377 | $empty_value = $this->is_field_json_encoded( $field ) ? '[]' : ''; |
||
| 378 | |||
| 379 | $lead_detail_id = GFFormsModel::get_lead_detail_id( $current_fields, $input_id ); |
||
| 380 | |||
| 381 | GFFormsModel::update_lead_field_value( $this->form, $this->entry, $field, $lead_detail_id, $input_id, $empty_value ); |
||
| 382 | |||
| 383 | // Prevent the $_POST values of hidden fields from being used as default values when rendering the form |
||
| 384 | // after submission |
||
| 385 | $post_input_id = 'input_' . str_replace( '.', '_', $input_id ); |
||
| 386 | 3 | $_POST[ $post_input_id ] = ''; |
|
| 387 | } |
||
| 388 | } |
||
| 389 | 3 | } |
|
| 390 | |||
| 391 | /** |
||
| 392 | * Have GF handle file uploads |
||
| 393 | * |
||
| 394 | * Copy of code from GFFormDisplay::process_form() |
||
| 395 | * |
||
| 396 | * @param int $form_id |
||
| 397 | */ |
||
| 398 | 3 | private function process_save_process_files( $form_id ) { |
|
| 399 | |||
| 400 | //Loading files that have been uploaded to temp folder |
||
| 401 | 3 | $files = GFCommon::json_decode( stripslashes( RGForms::post( 'gform_uploaded_files' ) ) ); |
|
| 402 | 3 | if ( ! is_array( $files ) ) { |
|
| 403 | 2 | $files = array(); |
|
| 404 | } |
||
| 405 | |||
| 406 | /** |
||
| 407 | * Make sure the fileuploads are not overwritten if no such request was done. |
||
| 408 | * @since 1.20.1 |
||
| 409 | */ |
||
| 410 | 3 | add_filter( "gform_save_field_value_$form_id", array( $this, 'save_field_value' ), 99, 5 ); |
|
| 411 | |||
| 412 | 3 | RGFormsModel::$uploaded_files[ $form_id ] = $files; |
|
| 413 | 3 | } |
|
| 414 | |||
| 415 | /** |
||
| 416 | * Make sure the fileuploads are not overwritten if no such request was done. |
||
| 417 | * |
||
| 418 | * TO ONLY BE USED INTERNALLY; DO NOT DEVELOP ON; MAY BE REMOVED AT ANY TIME. |
||
| 419 | * |
||
| 420 | * @since 1.20.1 |
||
| 421 | * |
||
| 422 | * @param string $value Field value |
||
| 423 | * @param array $entry GF entry array |
||
| 424 | * @param GF_Field_FileUpload $field |
||
| 425 | * @param array $form GF form array |
||
| 426 | * @param string $input_id ID of the input being saved |
||
| 427 | * |
||
| 428 | * @return string |
||
| 429 | */ |
||
| 430 | 3 | public function save_field_value( $value = '', $entry = array(), $field = null, $form = array(), $input_id = '' ) { |
|
| 431 | |||
| 432 | 3 | if ( ! $field || $field->type != 'fileupload' ) { |
|
| 433 | 3 | return $value; |
|
| 434 | } |
||
| 435 | |||
| 436 | 1 | $input_name = 'input_' . str_replace( '.', '_', $input_id ); |
|
| 437 | |||
| 438 | 1 | if ( $field->multipleFiles ) { |
|
| 439 | if ( empty( $value ) ) { |
||
| 440 | return json_decode( $entry[ $input_id ], true ); |
||
| 441 | } |
||
| 442 | return $value; |
||
| 443 | } |
||
| 444 | |||
| 445 | /** No file is being uploaded. */ |
||
| 446 | 1 | if ( empty( $_FILES[ $input_name ]['name'] ) ) { |
|
| 447 | /** So return the original upload */ |
||
| 448 | 1 | return $entry[ $input_id ]; |
|
| 449 | } |
||
| 450 | |||
| 451 | 1 | return $value; |
|
| 452 | } |
||
| 453 | |||
| 454 | /** |
||
| 455 | * Remove max_files validation (done on gravityforms.js) to avoid conflicts with GravityView |
||
| 456 | * Late validation done on self::custom_validation |
||
| 457 | * |
||
| 458 | * @param $plupload_init array Plupload settings |
||
| 459 | * @param $form_id |
||
| 460 | * @param $instance |
||
| 461 | * @return mixed |
||
| 462 | */ |
||
| 463 | 1 | public function modify_fileupload_settings( $plupload_init, $form_id, $instance ) { |
|
| 464 | 1 | if( ! $this->is_edit_entry() ) { |
|
| 465 | return $plupload_init; |
||
| 466 | } |
||
| 467 | |||
| 468 | 1 | $plupload_init['gf_vars']['max_files'] = 0; |
|
| 469 | |||
| 470 | 1 | return $plupload_init; |
|
| 471 | } |
||
| 472 | |||
| 473 | |||
| 474 | /** |
||
| 475 | * Unset adminOnly and convert field input key to string |
||
| 476 | * @return array $form |
||
| 477 | */ |
||
| 478 | 3 | private function form_prepare_for_save() { |
|
| 479 | |||
| 480 | 3 | $form = $this->form; |
|
| 481 | |||
| 482 | /** @var GF_Field $field */ |
||
| 483 | 3 | foreach( $form['fields'] as $k => &$field ) { |
|
| 484 | |||
| 485 | /** |
||
| 486 | * Remove the fields with calculation formulas before save to avoid conflicts with GF logic |
||
| 487 | * @since 1.16.3 |
||
| 488 | * @var GF_Field $field |
||
| 489 | */ |
||
| 490 | 3 | if( $field->has_calculation() ) { |
|
| 491 | unset( $form['fields'][ $k ] ); |
||
| 492 | } |
||
| 493 | |||
| 494 | 3 | $field->adminOnly = false; |
|
| 495 | |||
| 496 | 3 | if( isset( $field->inputs ) && is_array( $field->inputs ) ) { |
|
| 497 | foreach( $field->inputs as $key => $input ) { |
||
| 498 | 3 | $field->inputs[ $key ][ 'id' ] = (string)$input['id']; |
|
| 499 | } |
||
| 500 | } |
||
| 501 | } |
||
| 502 | |||
| 503 | 3 | return $form; |
|
| 504 | } |
||
| 505 | |||
| 506 | 3 | private function update_calculation_fields() { |
|
| 507 | |||
| 508 | 3 | $form = self::$original_form; |
|
| 509 | 3 | $update = false; |
|
| 510 | |||
| 511 | // get the most up to date entry values |
||
| 512 | 3 | $entry = GFAPI::get_entry( $this->entry['id'] ); |
|
| 513 | |||
| 514 | 3 | if( !empty( $this->fields_with_calculation ) ) { |
|
| 515 | $update = true; |
||
| 516 | foreach ( $this->fields_with_calculation as $calc_field ) { |
||
| 517 | $inputs = $calc_field->get_entry_inputs(); |
||
| 518 | if ( is_array( $inputs ) ) { |
||
| 519 | foreach ( $inputs as $input ) { |
||
| 520 | $input_name = 'input_' . str_replace( '.', '_', $input['id'] ); |
||
| 521 | $entry[ strval( $input['id'] ) ] = RGFormsModel::prepare_value( $form, $calc_field, '', $input_name, $entry['id'], $entry ); |
||
| 522 | } |
||
| 523 | } else { |
||
| 524 | $input_name = 'input_' . str_replace( '.', '_', $calc_field->id); |
||
| 525 | $entry[ strval( $calc_field->id ) ] = RGFormsModel::prepare_value( $form, $calc_field, '', $input_name, $entry['id'], $entry ); |
||
| 526 | } |
||
| 527 | } |
||
| 528 | |||
| 529 | } |
||
| 530 | |||
| 531 | 3 | if( $update ) { |
|
| 532 | |||
| 533 | $return_entry = GFAPI::update_entry( $entry ); |
||
| 534 | |||
| 535 | if( is_wp_error( $return_entry ) ) { |
||
| 536 | do_action( 'gravityview_log_error', 'Updating the entry calculation fields failed', $return_entry ); |
||
| 537 | } else { |
||
| 538 | do_action( 'gravityview_log_debug', 'Updating the entry calculation fields succeeded' ); |
||
| 539 | } |
||
| 540 | } |
||
| 541 | 3 | } |
|
| 542 | |||
| 543 | /** |
||
| 544 | * Handle updating the Post Image field |
||
| 545 | * |
||
| 546 | * Sets a new Featured Image if configured in Gravity Forms; otherwise uploads/updates media |
||
| 547 | * |
||
| 548 | * @since 1.17 |
||
| 549 | * |
||
| 550 | * @uses GFFormsModel::media_handle_upload |
||
| 551 | * @uses set_post_thumbnail |
||
| 552 | * |
||
| 553 | * @param array $form GF Form array |
||
| 554 | * @param GF_Field $field GF Field |
||
| 555 | * @param string $field_id Numeric ID of the field |
||
| 556 | * @param string $value |
||
| 557 | * @param array $entry GF Entry currently being edited |
||
| 558 | * @param int $post_id ID of the Post being edited |
||
| 559 | * |
||
| 560 | * @return mixed|string |
||
| 561 | */ |
||
| 562 | 1 | private function update_post_image( $form, $field, $field_id, $value, $entry, $post_id ) { |
|
| 563 | |||
| 564 | 1 | $input_name = 'input_' . $field_id; |
|
| 565 | |||
| 566 | 1 | if ( !empty( $_FILES[ $input_name ]['name'] ) ) { |
|
| 567 | |||
| 568 | // We have a new image |
||
| 569 | |||
| 570 | $value = RGFormsModel::prepare_value( $form, $field, $value, $input_name, $entry['id'] ); |
||
| 571 | |||
| 572 | $ary = ! empty( $value ) ? explode( '|:|', $value ) : array(); |
||
| 573 | $img_url = rgar( $ary, 0 ); |
||
| 574 | |||
| 575 | $img_title = count( $ary ) > 1 ? $ary[1] : ''; |
||
| 576 | $img_caption = count( $ary ) > 2 ? $ary[2] : ''; |
||
| 577 | $img_description = count( $ary ) > 3 ? $ary[3] : ''; |
||
| 578 | |||
| 579 | $image_meta = array( |
||
| 580 | 'post_excerpt' => $img_caption, |
||
| 581 | 'post_content' => $img_description, |
||
| 582 | ); |
||
| 583 | |||
| 584 | //adding title only if it is not empty. It will default to the file name if it is not in the array |
||
| 585 | if ( ! empty( $img_title ) ) { |
||
| 586 | $image_meta['post_title'] = $img_title; |
||
| 587 | } |
||
| 588 | |||
| 589 | /** |
||
| 590 | * todo: As soon as \GFFormsModel::media_handle_upload becomes a public method, move this call to \GFFormsModel::media_handle_upload and remove the hack from this class. |
||
| 591 | * Note: the method became public in GF 1.9.17.7, but we don't require that version yet. |
||
| 592 | */ |
||
| 593 | require_once GRAVITYVIEW_DIR . 'includes/class-gravityview-gfformsmodel.php'; |
||
| 594 | $media_id = GravityView_GFFormsModel::media_handle_upload( $img_url, $post_id, $image_meta ); |
||
| 595 | |||
| 596 | // is this field set as featured image? |
||
| 597 | if ( $media_id && $field->postFeaturedImage ) { |
||
| 598 | set_post_thumbnail( $post_id, $media_id ); |
||
| 599 | } |
||
| 600 | |||
| 601 | 1 | } elseif ( !empty( $_POST[ $input_name ] ) && is_array( $value ) ) { |
|
| 602 | |||
| 603 | 1 | $img_url = $_POST[ $input_name ]; |
|
| 604 | |||
| 605 | 1 | $img_title = rgar( $_POST, $input_name.'_1' ); |
|
| 606 | 1 | $img_caption = rgar( $_POST, $input_name .'_4' ); |
|
| 607 | 1 | $img_description = rgar( $_POST, $input_name .'_7' ); |
|
| 608 | |||
| 609 | 1 | $value = ! empty( $img_url ) ? $img_url . "|:|" . $img_title . "|:|" . $img_caption . "|:|" . $img_description : ''; |
|
| 610 | |||
| 611 | 1 | if ( $field->postFeaturedImage ) { |
|
| 612 | |||
| 613 | $image_meta = array( |
||
| 614 | 1 | 'ID' => get_post_thumbnail_id( $post_id ), |
|
| 615 | 1 | 'post_title' => $img_title, |
|
| 616 | 1 | 'post_excerpt' => $img_caption, |
|
| 617 | 1 | 'post_content' => $img_description, |
|
| 618 | ); |
||
| 619 | |||
| 620 | // update image title, caption or description |
||
| 621 | 1 | wp_update_post( $image_meta ); |
|
| 622 | } |
||
| 623 | } else { |
||
| 624 | |||
| 625 | // if we get here, image was removed or not set. |
||
| 626 | $value = ''; |
||
| 627 | |||
| 628 | if ( $field->postFeaturedImage ) { |
||
| 629 | delete_post_thumbnail( $post_id ); |
||
| 630 | } |
||
| 631 | } |
||
| 632 | |||
| 633 | 1 | return $value; |
|
| 634 | } |
||
| 635 | |||
| 636 | /** |
||
| 637 | * Loop through the fields being edited and if they include Post fields, update the Entry's post object |
||
| 638 | * |
||
| 639 | * @param array $form Gravity Forms form |
||
| 640 | * |
||
| 641 | * @return void |
||
| 642 | */ |
||
| 643 | 3 | private function maybe_update_post_fields( $form ) { |
|
| 644 | |||
| 645 | 3 | if( empty( $this->entry['post_id'] ) ) { |
|
| 646 | 2 | do_action( 'gravityview_log_debug', __METHOD__ . ': This entry has no post fields. Continuing...' ); |
|
| 647 | 2 | return; |
|
| 648 | } |
||
| 649 | |||
| 650 | 1 | $post_id = $this->entry['post_id']; |
|
| 651 | |||
| 652 | // Security check |
||
| 653 | 1 | if( false === GVCommon::has_cap( 'edit_post', $post_id ) ) { |
|
| 654 | do_action( 'gravityview_log_error', 'The current user does not have the ability to edit Post #'.$post_id ); |
||
| 655 | return; |
||
| 656 | } |
||
| 657 | |||
| 658 | 1 | $update_entry = false; |
|
| 659 | |||
| 660 | 1 | $updated_post = $original_post = get_post( $post_id ); |
|
| 661 | |||
| 662 | 1 | foreach ( $this->entry as $field_id => $value ) { |
|
| 663 | |||
| 664 | 1 | $field = RGFormsModel::get_field( $form, $field_id ); |
|
| 665 | |||
| 666 | 1 | if( ! $field ) { |
|
| 667 | 1 | continue; |
|
| 668 | } |
||
| 669 | |||
| 670 | 1 | if( GFCommon::is_post_field( $field ) && 'post_category' !== $field->type ) { |
|
| 671 | |||
| 672 | // Get the value of the field, including $_POSTed value |
||
| 673 | 1 | $value = RGFormsModel::get_field_value( $field ); |
|
| 674 | |||
| 675 | // Use temporary entry variable, to make values available to fill_post_template() and update_post_image() |
||
| 676 | 1 | $entry_tmp = $this->entry; |
|
| 677 | 1 | $entry_tmp["{$field_id}"] = $value; |
|
| 678 | |||
| 679 | 1 | switch( $field->type ) { |
|
| 680 | |||
| 681 | 1 | case 'post_title': |
|
| 682 | $post_title = $value; |
||
| 683 | if( rgar( $form, 'postTitleTemplateEnabled' ) ) { |
||
| 684 | $post_title = $this->fill_post_template( $form['postTitleTemplate'], $form, $entry_tmp ); |
||
| 685 | } |
||
| 686 | $updated_post->post_title = $post_title; |
||
| 687 | $updated_post->post_name = $post_title; |
||
| 688 | unset( $post_title ); |
||
| 689 | break; |
||
| 690 | |||
| 691 | 1 | case 'post_content': |
|
| 692 | $post_content = $value; |
||
| 693 | if( rgar( $form, 'postContentTemplateEnabled' ) ) { |
||
| 694 | $post_content = $this->fill_post_template( $form['postContentTemplate'], $form, $entry_tmp, true ); |
||
| 695 | } |
||
| 696 | $updated_post->post_content = $post_content; |
||
| 697 | unset( $post_content ); |
||
| 698 | break; |
||
| 699 | 1 | case 'post_excerpt': |
|
| 700 | $updated_post->post_excerpt = $value; |
||
| 701 | break; |
||
| 702 | 1 | case 'post_tags': |
|
| 703 | wp_set_post_tags( $post_id, $value, false ); |
||
| 704 | break; |
||
| 705 | 1 | case 'post_category': |
|
| 706 | break; |
||
| 707 | 1 | case 'post_custom_field': |
|
| 708 | if ( is_array( $value ) && ( floatval( $field_id ) !== floatval( $field->id ) ) ) { |
||
| 709 | $value = $value[ $field_id ]; |
||
| 710 | } |
||
| 711 | |||
| 712 | if( ! empty( $field->customFieldTemplateEnabled ) ) { |
||
| 713 | $value = $this->fill_post_template( $field->customFieldTemplate, $form, $entry_tmp, true ); |
||
| 714 | } |
||
| 715 | |||
| 716 | if ( $this->is_field_json_encoded( $field ) && ! is_string( $value ) ) { |
||
| 717 | $value = function_exists('wp_json_encode') ? wp_json_encode( $value ) : json_encode( $value ); |
||
| 718 | } |
||
| 719 | |||
| 720 | update_post_meta( $post_id, $field->postCustomFieldName, $value ); |
||
| 721 | break; |
||
| 722 | |||
| 723 | 1 | case 'post_image': |
|
| 724 | 1 | $value = $this->update_post_image( $form, $field, $field_id, $value, $this->entry, $post_id ); |
|
| 725 | 1 | break; |
|
| 726 | |||
| 727 | } |
||
| 728 | |||
| 729 | // update entry after |
||
| 730 | 1 | $this->entry["{$field_id}"] = $value; |
|
| 731 | |||
| 732 | 1 | $update_entry = true; |
|
| 733 | |||
| 734 | 1 | unset( $entry_tmp ); |
|
| 735 | } |
||
| 736 | |||
| 737 | } |
||
| 738 | |||
| 739 | 1 | if( $update_entry ) { |
|
| 740 | |||
| 741 | 1 | $return_entry = GFAPI::update_entry( $this->entry ); |
|
| 742 | |||
| 743 | 1 | if( is_wp_error( $return_entry ) ) { |
|
| 744 | do_action( 'gravityview_log_error', 'Updating the entry post fields failed', array( '$this->entry' => $this->entry, '$return_entry' => $return_entry ) ); |
||
| 745 | } else { |
||
| 746 | 1 | do_action( 'gravityview_log_debug', 'Updating the entry post fields for post #'.$post_id.' succeeded' ); |
|
| 747 | } |
||
| 748 | |||
| 749 | } |
||
| 750 | |||
| 751 | 1 | $return_post = wp_update_post( $updated_post, true ); |
|
| 752 | |||
| 753 | 1 | if( is_wp_error( $return_post ) ) { |
|
| 754 | $return_post->add_data( $updated_post, '$updated_post' ); |
||
| 755 | do_action( 'gravityview_log_error', 'Updating the post content failed', compact( 'updated_post', 'return_post' ) ); |
||
| 756 | } else { |
||
| 757 | 1 | do_action( 'gravityview_log_debug', 'Updating the post content for post #'.$post_id.' succeeded', $updated_post ); |
|
| 758 | } |
||
| 759 | 1 | } |
|
| 760 | |||
| 761 | /** |
||
| 762 | * Is the field stored in a JSON-encoded manner? |
||
| 763 | * |
||
| 764 | * @param GF_Field $field |
||
| 765 | * |
||
| 766 | * @return bool True: stored in DB json_encode()'d; False: not encoded |
||
| 767 | */ |
||
| 768 | private function is_field_json_encoded( $field ) { |
||
| 785 | |||
| 786 | /** |
||
| 787 | * Convert a field content template into prepared output |
||
| 788 | * |
||
| 789 | * @uses GravityView_GFFormsModel::get_post_field_images() |
||
| 790 | * |
||
| 791 | * @since 1.17 |
||
| 792 | * |
||
| 793 | * @param string $template The content template for the field |
||
| 794 | * @param array $form Gravity Forms form |
||
| 795 | * @param bool $do_shortcode Whether to process shortcode inside content. In GF, only run on Custom Field and Post Content fields |
||
| 796 | * |
||
| 797 | * @return string |
||
| 798 | */ |
||
| 799 | private function fill_post_template( $template, $form, $entry, $do_shortcode = false ) { |
||
| 818 | |||
| 819 | |||
| 820 | /** |
||
| 821 | * Perform actions normally performed after updating a lead |
||
| 822 | * |
||
| 823 | * @since 1.8 |
||
| 824 | * |
||
| 825 | * @see GFEntryDetail::lead_detail_page() |
||
| 826 | * |
||
| 827 | * @return void |
||
| 828 | */ |
||
| 829 | 3 | private function after_update() { |
|
| 830 | |||
| 831 | 3 | do_action( 'gform_after_update_entry', $this->form, $this->entry['id'], self::$original_entry ); |
|
| 832 | 3 | do_action( "gform_after_update_entry_{$this->form['id']}", $this->form, $this->entry['id'], self::$original_entry ); |
|
| 833 | |||
| 834 | // Re-define the entry now that we've updated it. |
||
| 835 | 3 | $entry = RGFormsModel::get_lead( $this->entry['id'] ); |
|
| 849 | |||
| 850 | |||
| 851 | /** |
||
| 852 | * Display the Edit Entry form |
||
| 853 | * |
||
| 854 | * @return void |
||
| 855 | */ |
||
| 856 | 3 | public function edit_entry_form() { |
|
| 912 | |||
| 913 | /** |
||
| 914 | * Display success or error message if the form has been submitted |
||
| 915 | * |
||
| 916 | * @uses GVCommon::generate_notice |
||
| 917 | * |
||
| 918 | * @since 1.16.2.2 |
||
| 919 | * |
||
| 920 | * @return void |
||
| 921 | */ |
||
| 922 | 3 | private function maybe_print_message() { |
|
| 954 | |||
| 955 | /** |
||
| 956 | * Display the Edit Entry form in the original Gravity Forms format |
||
| 957 | * |
||
| 958 | * @since 1.9 |
||
| 959 | * |
||
| 960 | * @return void |
||
| 961 | */ |
||
| 962 | 3 | private function render_edit_form() { |
|
| 1004 | |||
| 1005 | /** |
||
| 1006 | * Display the Update/Cancel/Delete buttons for the Edit Entry form |
||
| 1007 | * @since 1.8 |
||
| 1008 | * @return string |
||
| 1009 | */ |
||
| 1010 | 3 | public function render_form_buttons() { |
|
| 1013 | |||
| 1014 | |||
| 1015 | /** |
||
| 1016 | * Modify the form fields that are shown when using GFFormDisplay::get_form() |
||
| 1017 | * |
||
| 1018 | * By default, all fields will be shown. We only want the Edit Tab configured fields to be shown. |
||
| 1019 | * |
||
| 1020 | * @param array $form |
||
| 1021 | * @param boolean $ajax Whether in AJAX mode |
||
| 1022 | * @param array|string $field_values Passed parameters to the form |
||
| 1023 | * |
||
| 1024 | * @since 1.9 |
||
| 1025 | * |
||
| 1026 | * @return array Modified form array |
||
| 1027 | */ |
||
| 1028 | 3 | public function filter_modify_form_fields( $form, $ajax = false, $field_values = '' ) { |
|
| 1048 | |||
| 1049 | /** |
||
| 1050 | * When displaying a field, check if it's a Post Field, and if so, make sure the post exists and current user has edit rights. |
||
| 1051 | * |
||
| 1052 | * @since 1.16.2.2 |
||
| 1053 | * |
||
| 1054 | * @param string $field_content Always empty. Returning not-empty overrides the input. |
||
| 1055 | * @param GF_Field $field |
||
| 1056 | * @param string|array $value If array, it's a field with multiple inputs. If string, single input. |
||
| 1057 | * @param int $lead_id Lead ID. Always 0 for the `gform_field_input` filter. |
||
| 1058 | * @param int $form_id Form ID |
||
| 1059 | * |
||
| 1060 | * @return string If error, the error message. If no error, blank string (modify_edit_field_input() runs next) |
||
| 1061 | */ |
||
| 1062 | 3 | public function verify_user_can_edit_post( $field_content = '', $field, $value, $lead_id = 0, $form_id ) { |
|
| 1092 | |||
| 1093 | /** |
||
| 1094 | * |
||
| 1095 | * Fill-in the saved values into the form inputs |
||
| 1096 | * |
||
| 1097 | * @param string $field_content Always empty. Returning not-empty overrides the input. |
||
| 1098 | * @param GF_Field $field |
||
| 1099 | * @param string|array $value If array, it's a field with multiple inputs. If string, single input. |
||
| 1100 | * @param int $lead_id Lead ID. Always 0 for the `gform_field_input` filter. |
||
| 1101 | * @param int $form_id Form ID |
||
| 1102 | * |
||
| 1103 | * @return mixed |
||
| 1104 | */ |
||
| 1105 | 3 | public function modify_edit_field_input( $field_content = '', $field, $value, $lead_id = 0, $form_id ) { |
|
| 1147 | |||
| 1148 | /** |
||
| 1149 | * Modify the value for the current field input |
||
| 1150 | * |
||
| 1151 | * @param GF_Field $field |
||
| 1152 | * |
||
| 1153 | * @return array|mixed|string |
||
| 1154 | */ |
||
| 1155 | 3 | private function get_field_value( $field ) { |
|
| 1235 | |||
| 1236 | |||
| 1237 | // ---- Entry validation |
||
| 1238 | |||
| 1239 | /** |
||
| 1240 | * Add field keys that Gravity Forms expects. |
||
| 1241 | * |
||
| 1242 | * @see GFFormDisplay::validate() |
||
| 1243 | * @param array $form GF Form |
||
| 1244 | * @return array Modified GF Form |
||
| 1245 | */ |
||
| 1246 | 3 | public function gform_pre_validation( $form ) { |
|
| 1333 | |||
| 1334 | |||
| 1335 | /** |
||
| 1336 | * Process validation for a edit entry submission |
||
| 1337 | * |
||
| 1338 | * Sets the `is_valid` object var |
||
| 1339 | * |
||
| 1340 | * @return void |
||
| 1341 | */ |
||
| 1342 | 4 | private function validate() { |
|
| 1378 | |||
| 1379 | |||
| 1380 | /** |
||
| 1381 | * Make validation work for Edit Entry |
||
| 1382 | * |
||
| 1383 | * Because we're calling the GFFormDisplay::validate() in an unusual way (as a front-end |
||
| 1384 | * form pretending to be a back-end form), validate() doesn't know we _can't_ edit post |
||
| 1385 | * fields. This goes through all the fields and if they're an invalid post field, we |
||
| 1386 | * set them as valid. If there are still issues, we'll return false. |
||
| 1387 | * |
||
| 1388 | * @param [type] $validation_results [description] |
||
| 1389 | * @return [type] [description] |
||
| 1390 | */ |
||
| 1391 | 4 | public function custom_validation( $validation_results ) { |
|
| 1515 | |||
| 1516 | |||
| 1517 | /** |
||
| 1518 | * TODO: This seems to be hacky... we should remove it. Entry is set when updating the form using setup_vars()! |
||
| 1519 | * Get the current entry and set it if it's not yet set. |
||
| 1520 | * @return array Gravity Forms entry array |
||
| 1521 | */ |
||
| 1522 | 1 | public function get_entry() { |
|
| 1531 | |||
| 1532 | |||
| 1533 | |||
| 1534 | // --- Filters |
||
| 1535 | |||
| 1536 | /** |
||
| 1537 | * Get the Edit Entry fields as configured in the View |
||
| 1538 | * |
||
| 1539 | * @since 1.8 |
||
| 1540 | * |
||
| 1541 | * @param int $view_id |
||
| 1542 | * |
||
| 1543 | * @return array Array of fields that are configured in the Edit tab in the Admin |
||
| 1544 | */ |
||
| 1545 | 4 | private function get_configured_edit_fields( $form, $view_id ) { |
|
| 1579 | |||
| 1580 | |||
| 1581 | /** |
||
| 1582 | * Filter area fields based on specified conditions |
||
| 1583 | * - This filter removes the fields that have calculation configured |
||
| 1584 | * |
||
| 1585 | * @uses GravityView_Edit_Entry::user_can_edit_field() Check caps |
||
| 1586 | * @access private |
||
| 1587 | * @param GF_Field[] $fields |
||
| 1588 | * @param array $configured_fields |
||
| 1589 | * @since 1.5 |
||
| 1590 | * @return array $fields |
||
| 1591 | */ |
||
| 1592 | 3 | private function filter_fields( $fields, $configured_fields ) { |
|
| 1640 | |||
| 1641 | /** |
||
| 1642 | * Override GF Form field properties with the ones defined on the View |
||
| 1643 | * @param GF_Field $field GF Form field object |
||
| 1644 | * @param array $field_setting GV field options |
||
| 1645 | * @since 1.5 |
||
| 1646 | * @return array|GF_Field |
||
| 1647 | */ |
||
| 1648 | private function merge_field_properties( $field, $field_setting ) { |
||
| 1671 | |||
| 1672 | /** |
||
| 1673 | * Remove fields that shouldn't be visible based on the Gravity Forms adminOnly field property |
||
| 1674 | * |
||
| 1675 | * @since 1.9.1 |
||
| 1676 | * |
||
| 1677 | * @param array|GF_Field[] $fields Gravity Forms form fields |
||
| 1678 | * @param array|null $edit_fields Fields for the Edit Entry tab configured in the View Configuration |
||
| 1679 | * @param array $form GF Form array |
||
| 1680 | * @param int $view_id View ID |
||
| 1681 | * |
||
| 1682 | * @return array Possibly modified form array |
||
| 1683 | */ |
||
| 1684 | 3 | private function filter_admin_only_fields( $fields = array(), $edit_fields = null, $form = array(), $view_id = 0 ) { |
|
| 1712 | |||
| 1713 | // --- Conditional Logic |
||
| 1714 | |||
| 1715 | /** |
||
| 1716 | * Conditional logic isn't designed to work with forms that already have content. When switching input values, |
||
| 1717 | * the dependent fields will be blank. |
||
| 1718 | * |
||
| 1719 | * Note: This is because GF populates a JavaScript variable with the input values. This is tough to filter at the input level; |
||
| 1720 | * via the `gform_field_value` filter; it requires lots of legwork. Doing it at the form level is easier. |
||
| 1721 | * |
||
| 1722 | * @since 1.17.4 |
||
| 1723 | * |
||
| 1724 | * @param array $form Gravity Forms array object |
||
| 1725 | * |
||
| 1726 | * @return array $form, modified to fix conditional |
||
| 1727 | */ |
||
| 1728 | 3 | function prefill_conditional_logic( $form ) { |
|
| 1776 | |||
| 1777 | /** |
||
| 1778 | * Remove the conditional logic rules from the form button and the form fields, if needed. |
||
| 1779 | * |
||
| 1780 | * @todo Merge with caller method |
||
| 1781 | * @since 1.9 |
||
| 1782 | * |
||
| 1783 | * @param array $form Gravity Forms form |
||
| 1784 | * @return array Modified form, if not using Conditional Logic |
||
| 1785 | */ |
||
| 1786 | 3 | private function filter_conditional_logic( $form ) { |
|
| 1810 | |||
| 1811 | /** |
||
| 1812 | * Disable the Gravity Forms conditional logic script and features on the Edit Entry screen |
||
| 1813 | * |
||
| 1814 | * @since 1.9 |
||
| 1815 | * |
||
| 1816 | * @param $has_conditional_logic |
||
| 1817 | * @param $form |
||
| 1818 | * @return mixed |
||
| 1819 | */ |
||
| 1820 | 3 | public function manage_conditional_logic( $has_conditional_logic, $form ) { |
|
| 1829 | |||
| 1830 | |||
| 1831 | // --- User checks and nonces |
||
| 1832 | |||
| 1833 | /** |
||
| 1834 | * Check if the user can edit the entry |
||
| 1835 | * |
||
| 1836 | * - Is the nonce valid? |
||
| 1837 | * - Does the user have the right caps for the entry |
||
| 1838 | * - Is the entry in the trash? |
||
| 1839 | * |
||
| 1840 | * @todo Move to GVCommon |
||
| 1841 | * |
||
| 1842 | * @param boolean $echo Show error messages in the form? |
||
| 1843 | * @return boolean True: can edit form. False: nope. |
||
| 1844 | */ |
||
| 1845 | 4 | private function user_can_edit_entry( $echo = false ) { |
|
| 1909 | |||
| 1910 | |||
| 1911 | /** |
||
| 1912 | * Check whether a field is editable by the current user, and optionally display an error message |
||
| 1913 | * @uses GravityView_Edit_Entry->check_user_cap_edit_field() Check user capabilities |
||
| 1914 | * @param array $field Field or field settings array |
||
| 1915 | * @param boolean $echo Whether to show error message telling user they aren't allowed |
||
| 1916 | * @return boolean True: user can edit the current field; False: nope, they can't. |
||
| 1917 | */ |
||
| 1918 | private function user_can_edit_field( $field, $echo = false ) { |
||
| 1940 | |||
| 1941 | |||
| 1942 | /** |
||
| 1943 | * checks if user has permissions to edit a specific field |
||
| 1944 | * |
||
| 1945 | * Needs to be used combined with GravityView_Edit_Entry::user_can_edit_field for maximum security!! |
||
| 1946 | * |
||
| 1947 | * @param [type] $field [description] |
||
| 1948 | * @return bool |
||
| 1949 | */ |
||
| 1950 | private function check_user_cap_edit_field( $field ) { |
||
| 1966 | |||
| 1967 | |||
| 1968 | /** |
||
| 1969 | * Is the current nonce valid for editing the entry? |
||
| 1970 | * @return boolean |
||
| 1971 | */ |
||
| 1972 | 3 | public function verify_nonce() { |
|
| 1998 | |||
| 1999 | |||
| 2000 | /** |
||
| 2001 | * Multiselect in GF 2.2 became a json_encoded value. Fix it. |
||
| 2002 | * |
||
| 2003 | * As a hack for now we'll implode it back. |
||
| 2004 | */ |
||
| 2005 | public function fix_multiselect_value_serialization( $field_value, $field, $_this ) { |
||
| 2018 | |||
| 2019 | |||
| 2020 | |||
| 2021 | } //end class |
||
| 2022 |
Loading history...
The PSR-1: Basic Coding Standard recommends that a file should either introduce new symbols, that is classes, functions, constants or similar, or have side effects. Side effects are anything that executes logic, like for example printing output, changing ini settings or writing to a file.
The idea behind this recommendation is that merely auto-loading a class should not change the state of an application. It also promotes a cleaner style of programming and makes your code less prone to errors, because the logic is not spread out all over the place.
To learn more about the PSR-1, please see the PHP-FIG site on the PSR-1.