GravityView  2.9.2
The best, easiest way to display Gravity Forms entries on your website.
class-edit-entry-render.php
Go to the documentation of this file.
1 <?php
2 /**
3  * GravityView Edit Entry - render frontend
4  *
5  * @package GravityView
6  * @license GPL2+
7  * @author GravityView <hello@gravityview.co>
8  * @link http://gravityview.co
9  * @copyright Copyright 2014, Katz Web Services, Inc.
10  */
11 
12 if ( ! defined( 'WPINC' ) ) {
13  die;
14 }
15 
17 
18  /**
19  * @var GravityView_Edit_Entry
20  */
21  protected $loader;
22 
23  /**
24  * @var string $nonce_key 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 $nonce_field 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  * The View.
49  *
50  * @var \GV\View.
51  * @since develop
52  */
53  public $view;
54 
55  /**
56  * Gravity Forms entry array (it won't get changed during this class lifecycle)
57  * @since 1.17.2
58  * @var array
59  */
60  private static $original_entry = array();
61 
62  /**
63  * Gravity Forms form array (GravityView modifies the content through this class lifecycle)
64  *
65  * @var array
66  */
67  public $form;
68 
69  /**
70  * Gravity Forms form array (it won't get changed during this class lifecycle)
71  * @since 1.16.2.1
72  * @var array
73  */
74  private static $original_form;
75 
76  /**
77  * Gravity Forms form array after the form validation process
78  * @since 1.13
79  * @var array
80  */
81  public $form_after_validation = null;
82 
83  /**
84  * Hold an array of GF field objects that have calculation rules
85  * @var array
86  */
87  public $fields_with_calculation = array();
88 
89  /**
90  * Gravity Forms form id
91  *
92  * @var int
93  */
94  public $form_id;
95 
96  /**
97  * ID of the current view
98  *
99  * @var int
100  */
101  public $view_id;
102 
103  /**
104  * ID of the current post. May also be ID of the current View.
105  *
106  * @since 2.0.13
107  *
108  * @var int
109  */
110  public $post_id;
111 
112  /**
113  * Updated entry is valid (GF Validation object)
114  *
115  * @var array
116  */
117  public $is_valid = NULL;
118 
119  /**
120  * Internal page button states.
121  *
122  * @var bool
123  *
124  * @since develop
125  */
130 
132  $this->loader = $loader;
133  }
134 
135  function load() {
136 
137  /** @define "GRAVITYVIEW_DIR" "../../../" */
138  include_once( GRAVITYVIEW_DIR .'includes/class-admin-approve-entries.php' );
139 
140  // Don't display an embedded form when editing an entry
141  add_action( 'wp_head', array( $this, 'prevent_render_form' ) );
142  add_action( 'wp_footer', array( $this, 'prevent_render_form' ) );
143 
144  // Stop Gravity Forms processing what is ours!
145  add_action( 'wp', array( $this, 'prevent_maybe_process_form' ), 8 );
146  add_action( 'admin_init', array( $this, 'prevent_maybe_process_form' ), 8 );
147 
148  add_filter( 'gravityview_is_edit_entry', array( $this, 'is_edit_entry') );
149 
150  add_action( 'gravityview_edit_entry', array( $this, 'init' ), 10, 4 );
151 
152  // Disable conditional logic if needed (since 1.9)
153  add_filter( 'gform_has_conditional_logic', array( $this, 'manage_conditional_logic' ), 10, 2 );
154 
155  // Make sure GF doesn't validate max files (since 1.9)
156  add_filter( 'gform_plupload_settings', array( $this, 'modify_fileupload_settings' ), 10, 3 );
157 
158  // Add fields expected by GFFormDisplay::validate()
159  add_filter( 'gform_pre_validation', array( $this, 'gform_pre_validation') );
160 
161  // Fix multiselect value for GF 2.2
162  add_filter( 'gravityview/edit_entry/field_value_multiselect', array( $this, 'fix_multiselect_value_serialization' ), 10, 3 );
163  }
164 
165  /**
166  * Don't show any forms embedded on a page when GravityView is in Edit Entry mode
167  *
168  * Adds a `__return_empty_string` filter on the Gravity Forms shortcode on the `wp_head` action
169  * And then removes it on the `wp_footer` action
170  *
171  * @since 1.16.1
172  *
173  * @return void
174  */
175  public function prevent_render_form() {
176  if( $this->is_edit_entry() ) {
177  if( 'wp_head' === current_filter() ) {
178  add_filter( 'gform_shortcode_form', '__return_empty_string' );
179  } else {
180  remove_filter( 'gform_shortcode_form', '__return_empty_string' );
181  }
182  }
183  }
184 
185  /**
186  * Because we're mimicking being a front-end Gravity Forms form while using a Gravity Forms
187  * backend form, we need to prevent them from saving twice.
188  * @return void
189  */
190  public function prevent_maybe_process_form() {
191 
192  if( ! $this->is_edit_entry_submission() ) {
193  return;
194  }
195 
196  gravityview()->log->debug( 'GravityView_Edit_Entry[prevent_maybe_process_form] Removing GFForms::maybe_process_form() action.' );
197 
198  remove_action( 'wp', array( 'RGForms', 'maybe_process_form'), 9 );
199  remove_action( 'wp', array( 'GFForms', 'maybe_process_form'), 9 );
200 
201  remove_action( 'admin_init', array( 'GFForms', 'maybe_process_form'), 9 );
202  remove_action( 'admin_init', array( 'RGForms', 'maybe_process_form'), 9 );
203  }
204 
205  /**
206  * Is the current page an Edit Entry page?
207  * @return boolean
208  */
209  public function is_edit_entry() {
210 
211  $is_edit_entry =
212  ( GravityView_frontend::is_single_entry() || ( ! empty( gravityview()->request->is_entry() ) ) )
213  && ( ! empty( $_GET['edit'] ) );
214 
215  return ( $is_edit_entry || $this->is_edit_entry_submission() );
216  }
217 
218  /**
219  * Is the current page an Edit Entry page?
220  * @since 1.9
221  * @return boolean
222  */
223  public function is_edit_entry_submission() {
224  return !empty( $_POST[ self::$nonce_field ] );
225  }
226 
227  /**
228  * When Edit entry view is requested setup the vars
229  */
230  private function setup_vars() {
231  global $post;
232 
234 
235 
236  $entries = $gravityview_view->getEntries();
237  self::$original_entry = $entries[0];
238  $this->entry = $entries[0];
239 
240  self::$original_form = GFAPI::get_form( $this->entry['form_id'] );
241  $this->form = $gravityview_view->getForm();
242  $this->form_id = $this->entry['form_id'];
243  $this->view_id = $gravityview_view->getViewId();
244  $this->post_id = \GV\Utils::get( $post, 'ID', null );
245 
246  self::$nonce_key = GravityView_Edit_Entry::get_nonce_key( $this->view_id, $this->form_id, $this->entry['id'] );
247  }
248 
249 
250  /**
251  * Load required files and trigger edit flow
252  *
253  * Run when the is_edit_entry returns true.
254  *
255  * @param \GravityView_View_Data $gv_data GravityView Data object
256  * @param \GV\Entry $entry The Entry.
257  * @param \GV\View $view The View.
258  * @param \GV\Request $request The Request.
259  *
260  * @since develop Added $entry, $view, $request adhocs.
261  *
262  * @return void
263  */
264  public function init( $gv_data = null, $entry = null, $view = null, $request = null ) {
265 
266  require_once( GFCommon::get_base_path() . '/form_display.php' );
267  require_once( GFCommon::get_base_path() . '/entry_detail.php' );
268 
269  $this->setup_vars();
270 
271  if ( ! $gv_data ) {
273  }
274 
275  // Multiple Views embedded, don't proceed if nonce fails
276  if ( $gv_data->has_multiple_views() && ! $this->verify_nonce() ) {
277  gravityview()->log->error( 'Nonce validation failed for the Edit Entry request; returning' );
278  return;
279  }
280 
281  // Sorry, you're not allowed here.
282  if ( false === $this->user_can_edit_entry( true ) ) {
283  gravityview()->log->error( 'User is not allowed to edit this entry; returning', array( 'data' => $this->entry ) );
284  return;
285  }
286 
287  $this->view = $view;
288 
289  $this->print_scripts();
290 
291  $this->process_save( $gv_data );
292 
293  $this->edit_entry_form();
294 
295  }
296 
297 
298  /**
299  * Force Gravity Forms to output scripts as if it were in the admin
300  * @return void
301  */
302  private function print_scripts() {
304 
305  wp_register_script( 'gform_gravityforms', GFCommon::get_base_url().'/js/gravityforms.js', array( 'jquery', 'gform_json', 'gform_placeholder', 'sack', 'plupload-all', 'gravityview-fe-view' ) );
306 
307  GFFormDisplay::enqueue_form_scripts( $gravityview_view->getForm(), false);
308 
309  wp_localize_script( 'gravityview-fe-view', 'gvGlobals', array( 'cookiepath' => COOKIEPATH ) );
310 
311  // Sack is required for images
312  wp_print_scripts( array( 'sack', 'gform_gravityforms', 'gravityview-fe-view' ) );
313  }
314 
315 
316  /**
317  * Process edit entry form save
318  *
319  * @param array $gv_data The View data.
320  */
321  private function process_save( $gv_data ) {
322 
323  if ( empty( $_POST ) || ! isset( $_POST['lid'] ) ) {
324  return;
325  }
326 
327  // Make sure the entry, view, and form IDs are all correct
328  $valid = $this->verify_nonce();
329 
330  if ( !$valid ) {
331  gravityview()->log->error( 'Nonce validation failed.' );
332  return;
333  }
334 
335  if ( $this->entry['id'] !== $_POST['lid'] ) {
336  gravityview()->log->error( 'Entry ID did not match posted entry ID.' );
337  return;
338  }
339 
340  gravityview()->log->debug( '$_POSTed data (sanitized): ', array( 'data' => esc_html( print_r( $_POST, true ) ) ) );
341 
342  $this->process_save_process_files( $this->form_id );
343 
344  $this->validate();
345 
346  if( $this->is_valid ) {
347 
348  gravityview()->log->debug( 'Submission is valid.' );
349 
350  /**
351  * @hack This step is needed to unset the adminOnly from form fields, to add the calculation fields
352  */
353  $form = $this->form_prepare_for_save();
354 
355  /**
356  * @hack to avoid the capability validation of the method save_lead for GF 1.9+
357  */
358  unset( $_GET['page'] );
359 
360  $date_created = $this->entry['date_created'];
361 
362  /**
363  * @hack to force Gravity Forms to use $read_value_from_post in GFFormsModel::save_lead()
364  * @since 1.17.2
365  */
366  unset( $this->entry['date_created'] );
367 
368  /**
369  * @action `gravityview/edit_entry/before_update` Perform an action before the entry has been updated using Edit Entry
370  * @since 2.1
371  * @param array $form Gravity Forms form array
372  * @param string $entry_id Numeric ID of the entry that is being updated
373  * @param GravityView_Edit_Entry_Render $this This object
374  * @param GravityView_View_Data $gv_data The View data
375  */
376  do_action( 'gravityview/edit_entry/before_update', $form, $this->entry['id'], $this, $gv_data );
377 
378  GFFormsModel::save_lead( $form, $this->entry );
379 
380  // Delete the values for hidden inputs
381  $this->unset_hidden_field_values();
382 
383  $this->entry['date_created'] = $date_created;
384 
385  // Process calculation fields
386  $this->update_calculation_fields();
387 
388  // Handle hidden approval fields (or their absense)
389  $this->preset_approval_fields();
390 
391  // Perform actions normally performed after updating a lead
392  $this->after_update();
393 
394  /**
395  * Must be AFTER after_update()!
396  * @see https://github.com/gravityview/GravityView/issues/764
397  */
399 
400  /**
401  * @action `gravityview/edit_entry/after_update` Perform an action after the entry has been updated using Edit Entry
402  * @since 2.1 Added $gv_data parameter
403  * @param array $form Gravity Forms form array
404  * @param string $entry_id Numeric ID of the entry that was updated
405  * @param GravityView_Edit_Entry_Render $this This object
406  * @param GravityView_View_Data $gv_data The View data
407  */
408  do_action( 'gravityview/edit_entry/after_update', $this->form, $this->entry['id'], $this, $gv_data );
409 
410  } else {
411  gravityview()->log->error( 'Submission is NOT valid.', array( 'entry' => $this->entry ) );
412  }
413 
414  } // process_save
415 
416  /**
417  * Delete the value of fields hidden by conditional logic when the entry is edited
418  *
419  * @uses GFFormsModel::update_lead_field_value()
420  *
421  * @since 1.17.4
422  *
423  * @return void
424  */
425  private function unset_hidden_field_values() {
426  global $wpdb;
427 
428  /**
429  * @filter `gravityview/edit_entry/unset_hidden_field_values` Whether to delete values of fields hidden by conditional logic
430  * @since 1.22.2
431  * @param bool $unset_hidden_field_values Default: true
432  * @param GravityView_Edit_Entry_Render $this This object
433  */
434  $unset_hidden_field_values = apply_filters( 'gravityview/edit_entry/unset_hidden_field_values', true, $this );
435 
436  $this->unset_hidden_calculations = array();
437 
438  if ( ! $unset_hidden_field_values ) {
439  return;
440  }
441 
442  if ( version_compare( GravityView_GFFormsModel::get_database_version(), '2.3-dev-1', '>=' ) && method_exists( 'GFFormsModel', 'get_entry_meta_table_name' ) ) {
443  $entry_meta_table = GFFormsModel::get_entry_meta_table_name();
444  $current_fields = $wpdb->get_results( $wpdb->prepare( "SELECT * FROM $entry_meta_table WHERE entry_id=%d", $this->entry['id'] ) );
445  } else {
446  $lead_detail_table = GFFormsModel::get_lead_details_table_name();
447  $current_fields = $wpdb->get_results( $wpdb->prepare( "SELECT * FROM $lead_detail_table WHERE lead_id=%d", $this->entry['id'] ) );
448  }
449 
450  foreach ( $this->entry as $input_id => $field_value ) {
451 
452  if ( ! is_numeric( $input_id ) ) {
453  continue;
454  }
455 
456  if ( ! $field = RGFormsModel::get_field( $this->form, $input_id ) ) {
457  continue;
458  }
459 
460  // Reset fields that are or would be hidden
461  if ( GFFormsModel::is_field_hidden( $this->form, $field, array(), $this->entry ) ) {
462 
463  $empty_value = $field->get_value_save_entry(
464  is_array( $field->get_entry_inputs() ) ? array() : '',
465  $this->form, '', $this->entry['id'], $this->entry
466  );
467 
468  if ( $field->has_calculation() ) {
469  $this->unset_hidden_calculations[] = $field->id; // Unset
470  $empty_value = '';
471  }
472 
473  $lead_detail_id = GFFormsModel::get_lead_detail_id( $current_fields, $input_id );
474 
475  GFFormsModel::update_lead_field_value( $this->form, $this->entry, $field, $lead_detail_id, $input_id, $empty_value );
476 
477  // Prevent the $_POST values of hidden fields from being used as default values when rendering the form
478  // after submission
479  $post_input_id = 'input_' . str_replace( '.', '_', $input_id );
480  $_POST[ $post_input_id ] = '';
481  }
482  }
483  }
484 
485  /**
486  * Leverage `gravityview/approve_entries/update_unapproved_meta` to prevent
487  * the missing/empty approval field to affect is_approved meta at all.
488  *
489  * Called before the Gravity Forms after_update triggers.
490  *
491  * @since 2.5
492  *
493  * @return void
494  */
495  private function preset_approval_fields() {
496  $has_approved_field = false;
497 
498  foreach ( self::$original_form['fields'] as $field ) {
499  if ( $field->gravityview_approved ) {
500  $has_approved_field = true;
501  break;
502  }
503  }
504 
505  if ( ! $has_approved_field ) {
506  return;
507  }
508 
509  $is_field_hidden = true;
510 
511  foreach ( $this->form['fields'] as $field ) {
512  if ( $field->gravityview_approved ) {
513  $is_field_hidden = false;
514  break;
515  }
516  }
517 
518  if ( ! $is_field_hidden ) {
519  return;
520  }
521 
522  add_filter( 'gravityview/approve_entries/update_unapproved_meta', array( $this, 'prevent_update_unapproved_meta' ), 9, 3 );
523  }
524 
525  /**
526  * Done once from self::preset_approval_fields
527  *
528  * @since 2.5
529  *
530  * @return string UNAPPROVED unless something else is inside the entry.
531  */
533 
534  remove_filter( 'gravityview/approve_entries/update_unapproved_meta', array( $this, 'prevent_update_unapproved_meta' ), 9 );
535 
536  if ( ! $value = gform_get_meta( $entry['id'], 'is_approved' ) ) {
537 
539 
540  $value = apply_filters( 'gravityview/approve_entries/after_submission/default_status', $value );
541  }
542 
543  return $value;
544  }
545 
546  /**
547  * Have GF handle file uploads
548  *
549  * Copy of code from GFFormDisplay::process_form()
550  *
551  * @param int $form_id
552  */
553  private function process_save_process_files( $form_id ) {
554 
555  //Loading files that have been uploaded to temp folder
556  $files = GFCommon::json_decode( stripslashes( RGForms::post( 'gform_uploaded_files' ) ) );
557  if ( ! is_array( $files ) ) {
558  $files = array();
559  }
560 
561  /**
562  * Make sure the fileuploads are not overwritten if no such request was done.
563  * @since 1.20.1
564  */
565  add_filter( "gform_save_field_value_$form_id", array( $this, 'save_field_value' ), 99, 5 );
566 
567  RGFormsModel::$uploaded_files[ $form_id ] = $files;
568  }
569 
570  /**
571  * Make sure the fileuploads are not overwritten if no such request was done.
572  *
573  * TO ONLY BE USED INTERNALLY; DO NOT DEVELOP ON; MAY BE REMOVED AT ANY TIME.
574  *
575  * @since 1.20.1
576  *
577  * @param string $value Field value
578  * @param array $entry GF entry array
579  * @param GF_Field_FileUpload $field
580  * @param array $form GF form array
581  * @param string $input_id ID of the input being saved
582  *
583  * @return string
584  */
585  public function save_field_value( $value = '', $entry = array(), $field = null, $form = array(), $input_id = '' ) {
586 
587  if ( ! $field || $field->type != 'fileupload' ) {
588  return $value;
589  }
590 
591  $input_name = 'input_' . str_replace( '.', '_', $input_id );
592 
593  if ( $field->multipleFiles ) {
594  if ( empty( $value ) ) {
595  return json_decode( \GV\Utils::get( $entry, $input_id, '' ), true );
596  }
597  return $value;
598  }
599 
600  /** No file is being uploaded. */
601  if ( empty( $_FILES[ $input_name ]['name'] ) ) {
602  /** So return the original upload, with $value as backup (it can be empty during edit form rendering) */
603  return rgar( $entry, $input_id, $value );
604  }
605 
606  return $value;
607  }
608 
609  /**
610  * Remove max_files validation (done on gravityforms.js) to avoid conflicts with GravityView
611  * Late validation done on self::custom_validation
612  *
613  * @param $plupload_init array Plupload settings
614  * @param $form_id
615  * @param $instance
616  * @return mixed
617  */
618  public function modify_fileupload_settings( $plupload_init, $form_id, $instance ) {
619  if( ! $this->is_edit_entry() ) {
620  return $plupload_init;
621  }
622 
623  $plupload_init['gf_vars']['max_files'] = 0;
624 
625  return $plupload_init;
626  }
627 
628 
629  /**
630  * Set visibility to visible and convert field input key to string
631  * @return array $form
632  */
633  private function form_prepare_for_save() {
634 
635  $form = $this->filter_conditional_logic( $this->form );
636 
637  /** @type GF_Field $field */
638  foreach( $form['fields'] as $k => &$field ) {
639 
640  /**
641  * Remove the fields with calculation formulas before save to avoid conflicts with GF logic
642  * @since 1.16.3
643  */
644  if( $field->has_calculation() ) {
645  unset( $form['fields'][ $k ] );
646  }
647 
648  $field->adminOnly = false;
649 
650  if( isset( $field->inputs ) && is_array( $field->inputs ) ) {
651  foreach( $field->inputs as $key => $input ) {
652  $field->inputs[ $key ][ 'id' ] = (string)$input['id'];
653  }
654  }
655  }
656 
657  $form['fields'] = array_values( $form['fields'] );
658 
659  return $form;
660  }
661 
662  private function update_calculation_fields() {
663  global $wpdb;
664 
665  $form = self::$original_form;
666  $update = false;
667 
668  // get the most up to date entry values
669  $entry = GFAPI::get_entry( $this->entry['id'] );
670 
671  if ( version_compare( GravityView_GFFormsModel::get_database_version(), '2.3-dev-1', '>=' ) && method_exists( 'GFFormsModel', 'get_entry_meta_table_name' ) ) {
672  $entry_meta_table = GFFormsModel::get_entry_meta_table_name();
673  $current_fields = $wpdb->get_results( $wpdb->prepare( "SELECT * FROM $entry_meta_table WHERE entry_id=%d", $entry['id'] ) );
674  } else {
675  $lead_detail_table = GFFormsModel::get_lead_details_table_name();
676  $current_fields = $wpdb->get_results( $wpdb->prepare( "SELECT * FROM $lead_detail_table WHERE lead_id=%d", $entry['id'] ) );
677  }
678 
679 
680  if ( ! empty( $this->fields_with_calculation ) ) {
681  $allowed_fields = $this->get_configured_edit_fields( $form, $this->view_id );
682  $allowed_fields = wp_list_pluck( $allowed_fields, 'id' );
683 
684  foreach ( $this->fields_with_calculation as $field ) {
685 
686  if ( in_array( $field->id, $this->unset_hidden_calculations, true ) ) {
687  continue;
688  }
689 
690  $inputs = $field->get_entry_inputs();
691  if ( is_array( $inputs ) ) {
692  foreach ( $inputs as $input ) {
693  list( $field_id, $input_id ) = rgexplode( '.', $input['id'], 2 );
694 
695  if ( 'product' === $field->type ) {
696  $input_name = 'input_' . str_replace( '.', '_', $input['id'] );
697 
698  // Only allow quantity to be set if it's allowed to be edited
699  if ( in_array( $field_id, $allowed_fields ) && $input_id == 3 ) {
700  } else { // otherwise set to what it previously was
701  $_POST[ $input_name ] = $entry[ $input['id'] ];
702  }
703  } else {
704  // Set to what it previously was if it's not editable
705  if ( ! in_array( $field_id, $allowed_fields ) ) {
706  $_POST[ $input_name ] = $entry[ $input['id'] ];
707  }
708  }
709 
710  GFFormsModel::save_input( $form, $field, $entry, $current_fields, $input['id'] );
711  }
712  } else {
713  // Set to what it previously was if it's not editable
714  if ( ! in_array( $field->id, $allowed_fields ) ) {
715  $_POST[ 'input_' . $field->id ] = $entry[ $field->id ];
716  }
717  GFFormsModel::save_input( $form, $field, $entry, $current_fields, $field->id );
718  }
719  }
720 
721  if ( method_exists( 'GFFormsModel', 'commit_batch_field_operations' ) ) {
722  GFFormsModel::commit_batch_field_operations();
723  }
724  }
725  }
726 
727  /**
728  * Handle updating the Post Image field
729  *
730  * Sets a new Featured Image if configured in Gravity Forms; otherwise uploads/updates media
731  *
732  * @since 1.17
733  *
734  * @uses GFFormsModel::media_handle_upload
735  * @uses set_post_thumbnail
736  *
737  * @param array $form GF Form array
738  * @param GF_Field $field GF Field
739  * @param string $field_id Numeric ID of the field
740  * @param string $value
741  * @param array $entry GF Entry currently being edited
742  * @param int $post_id ID of the Post being edited
743  *
744  * @return mixed|string
745  */
747 
748  $input_name = 'input_' . $field_id;
749 
750  if ( !empty( $_FILES[ $input_name ]['name'] ) ) {
751 
752  // We have a new image
753 
754  $value = RGFormsModel::prepare_value( $form, $field, $value, $input_name, $entry['id'] );
755 
756  $ary = ! empty( $value ) ? explode( '|:|', $value ) : array();
757  $ary = stripslashes_deep( $ary );
758  $img_url = \GV\Utils::get( $ary, 0 );
759 
760  $img_title = count( $ary ) > 1 ? $ary[1] : '';
761  $img_caption = count( $ary ) > 2 ? $ary[2] : '';
762  $img_description = count( $ary ) > 3 ? $ary[3] : '';
763 
764  $image_meta = array(
765  'post_excerpt' => $img_caption,
766  'post_content' => $img_description,
767  );
768 
769  //adding title only if it is not empty. It will default to the file name if it is not in the array
770  if ( ! empty( $img_title ) ) {
771  $image_meta['post_title'] = $img_title;
772  }
773 
774  /**
775  * 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.
776  * Note: the method became public in GF 1.9.17.7, but we don't require that version yet.
777  */
778  require_once GRAVITYVIEW_DIR . 'includes/class-gravityview-gfformsmodel.php';
780 
781  // is this field set as featured image?
782  if ( $media_id && $field->postFeaturedImage ) {
783  set_post_thumbnail( $post_id, $media_id );
784  }
785 
786  } elseif ( ! empty( $_POST[ $input_name ] ) && is_array( $value ) ) {
787 
788  $img_url = stripslashes_deep( $_POST[ $input_name ] );
789  $img_title = stripslashes_deep( \GV\Utils::_POST( $input_name . '_1' ) );
790  $img_caption = stripslashes_deep( \GV\Utils::_POST( $input_name . '_4' ) );
791  $img_description = stripslashes_deep( \GV\Utils::_POST( $input_name . '_7' ) );
792 
793  $value = ! empty( $img_url ) ? $img_url . "|:|" . $img_title . "|:|" . $img_caption . "|:|" . $img_description : '';
794 
795  if ( $field->postFeaturedImage ) {
796 
797  $image_meta = array(
798  'ID' => get_post_thumbnail_id( $post_id ),
799  'post_title' => $img_title,
800  'post_excerpt' => $img_caption,
801  'post_content' => $img_description,
802  );
803 
804  // update image title, caption or description
805  wp_update_post( $image_meta );
806  }
807  } else {
808 
809  // if we get here, image was removed or not set.
810  $value = '';
811 
812  if ( $field->postFeaturedImage ) {
813  delete_post_thumbnail( $post_id );
814  }
815  }
816 
817  return $value;
818  }
819 
820  /**
821  * Loop through the fields being edited and if they include Post fields, update the Entry's post object
822  *
823  * @param array $form Gravity Forms form
824  *
825  * @return void
826  */
827  private function maybe_update_post_fields( $form ) {
828 
829  if( empty( $this->entry['post_id'] ) ) {
830  gravityview()->log->debug( 'This entry has no post fields. Continuing...' );
831  return;
832  }
833 
834  $post_id = $this->entry['post_id'];
835 
836  // Security check
837  if( false === GVCommon::has_cap( 'edit_post', $post_id ) ) {
838  gravityview()->log->error( 'The current user does not have the ability to edit Post #{post_id}', array( 'post_id' => $post_id ) );
839  return;
840  }
841 
842  $update_entry = false;
843 
844  $updated_post = $original_post = get_post( $post_id );
845 
846  foreach ( $this->entry as $field_id => $value ) {
847 
848  $field = RGFormsModel::get_field( $form, $field_id );
849 
850  if( ! $field ) {
851  continue;
852  }
853 
854  if( GFCommon::is_post_field( $field ) && 'post_category' !== $field->type ) {
855 
856  // Get the value of the field, including $_POSTed value
857  $value = RGFormsModel::get_field_value( $field );
858 
859  // Use temporary entry variable, to make values available to fill_post_template() and update_post_image()
860  $entry_tmp = $this->entry;
861  $entry_tmp["{$field_id}"] = $value;
862 
863  switch( $field->type ) {
864 
865  case 'post_title':
866  $post_title = $value;
867  if ( \GV\Utils::get( $form, 'postTitleTemplateEnabled' ) ) {
868  $post_title = $this->fill_post_template( $form['postTitleTemplate'], $form, $entry_tmp );
869  }
870  $updated_post->post_title = $post_title;
871  $updated_post->post_name = $post_title;
872  unset( $post_title );
873  break;
874 
875  case 'post_content':
876  $post_content = $value;
877  if ( \GV\Utils::get( $form, 'postContentTemplateEnabled' ) ) {
878  $post_content = $this->fill_post_template( $form['postContentTemplate'], $form, $entry_tmp, true );
879  }
880  $updated_post->post_content = $post_content;
881  unset( $post_content );
882  break;
883  case 'post_excerpt':
884  $updated_post->post_excerpt = $value;
885  break;
886  case 'post_tags':
887  wp_set_post_tags( $post_id, $value, false );
888  break;
889  case 'post_category':
890  break;
891  case 'post_custom_field':
892  if ( is_array( $value ) && ( floatval( $field_id ) !== floatval( $field->id ) ) ) {
893  $value = $value[ $field_id ];
894  }
895 
896  if( ! empty( $field->customFieldTemplateEnabled ) ) {
897  $value = $this->fill_post_template( $field->customFieldTemplate, $form, $entry_tmp, true );
898  }
899 
900  $value = $field->get_value_save_entry( $value, $form, '', $this->entry['id'], $this->entry );
901 
902  update_post_meta( $post_id, $field->postCustomFieldName, $value );
903  break;
904 
905  case 'post_image':
906  $value = $this->update_post_image( $form, $field, $field_id, $value, $this->entry, $post_id );
907  break;
908 
909  }
910 
911  // update entry after
912  $this->entry["{$field_id}"] = $value;
913 
914  $update_entry = true;
915 
916  unset( $entry_tmp );
917  }
918 
919  }
920 
921  if( $update_entry ) {
922 
923  $return_entry = GFAPI::update_entry( $this->entry );
924 
925  if( is_wp_error( $return_entry ) ) {
926  gravityview()->log->error( 'Updating the entry post fields failed', array( 'data' => array( '$this->entry' => $this->entry, '$return_entry' => $return_entry ) ) );
927  } else {
928  gravityview()->log->debug( 'Updating the entry post fields for post #{post_id} succeeded', array( 'post_id' => $post_id ) );
929  }
930 
931  }
932 
933  $return_post = wp_update_post( $updated_post, true );
934 
935  if( is_wp_error( $return_post ) ) {
936  $return_post->add_data( $updated_post, '$updated_post' );
937  gravityview()->log->error( 'Updating the post content failed', array( 'data' => compact( 'updated_post', 'return_post' ) ) );
938  } else {
939  gravityview()->log->debug( 'Updating the post content for post #{post_id} succeeded', array( 'post_id' => $post_id, 'data' => $updated_post ) );
940  }
941  }
942 
943  /**
944  * Convert a field content template into prepared output
945  *
946  * @uses GravityView_GFFormsModel::get_post_field_images()
947  *
948  * @since 1.17
949  *
950  * @param string $template The content template for the field
951  * @param array $form Gravity Forms form
952  * @param bool $do_shortcode Whether to process shortcode inside content. In GF, only run on Custom Field and Post Content fields
953  *
954  * @return string
955  */
956  private function fill_post_template( $template, $form, $entry, $do_shortcode = false ) {
957 
958  require_once GRAVITYVIEW_DIR . 'includes/class-gravityview-gfformsmodel.php';
959 
961 
962  //replacing post image variables
963  $output = GFCommon::replace_variables_post_image( $template, $post_images, $entry );
964 
965  //replacing all other variables
966  $output = GFCommon::replace_variables( $output, $form, $entry, false, false, false );
967 
968  // replace conditional shortcodes
969  if( $do_shortcode ) {
970  $output = do_shortcode( $output );
971  }
972 
973  return $output;
974  }
975 
976 
977  /**
978  * Perform actions normally performed after updating a lead
979  *
980  * @since 1.8
981  *
982  * @see GFEntryDetail::lead_detail_page()
983  *
984  * @return void
985  */
986  private function after_update() {
987 
988  do_action( 'gform_after_update_entry', self::$original_form, $this->entry['id'], self::$original_entry );
989  do_action( "gform_after_update_entry_{$this->form['id']}", self::$original_form, $this->entry['id'], self::$original_entry );
990 
991  // Re-define the entry now that we've updated it.
992  $entry = RGFormsModel::get_lead( $this->entry['id'] );
993 
994  $entry = GFFormsModel::set_entry_meta( $entry, self::$original_form );
995 
996  if ( version_compare( GFFormsModel::get_database_version(), '2.3-dev-1', '<' ) ) {
997  // We need to clear the cache because Gravity Forms caches the field values, which
998  // we have just updated.
999  foreach ($this->form['fields'] as $key => $field) {
1000  GFFormsModel::refresh_lead_field_value( $entry['id'], $field->id );
1001  }
1002  }
1003 
1004  /**
1005  * Maybe process feeds.
1006  *
1007  * @since develop
1008  */
1009  if ( $allowed_feeds = $this->view->settings->get( 'edit_feeds', array() ) ) {
1010  $feeds = GFAPI::get_feeds( null, $entry['form_id'] );
1011  if ( ! is_wp_error( $feeds ) ) {
1012  $registered_feeds = array();
1013  foreach ( GFAddOn::get_registered_addons() as $registered_feed ) {
1014  if ( is_subclass_of( $registered_feed, 'GFFeedAddOn' ) ) {
1015  if ( method_exists( $registered_feed, 'get_instance' ) ) {
1016  $registered_feed = call_user_func( array( $registered_feed, 'get_instance' ) );
1017  $registered_feeds[ $registered_feed->get_slug() ] = $registered_feed;
1018  }
1019  }
1020  }
1021  foreach ( $feeds as $feed ) {
1022  if ( in_array( $feed['id'], $allowed_feeds ) ) {
1023  if ( $feed_object = \GV\Utils::get( $registered_feeds, $feed['addon_slug'] ) ) {
1024  $returned_entry = $feed_object->process_feed( $feed, $entry, self::$original_form );
1025  if ( is_array( $returned_entry ) && rgar( $returned_entry, 'id' ) ) {
1026  $entry = $returned_entry;
1027  }
1028 
1029  do_action( 'gform_post_process_feed', $feed, $entry, self::$original_form, $feed_object );
1030  $slug = $feed_object->get_slug();
1031  do_action( "gform_{$slug}_post_process_feed", $feed, $entry, self::$original_form, $feed_object );
1032  }
1033  }
1034  }
1035  }
1036  }
1037 
1038  $this->entry = $entry;
1039  }
1040 
1041 
1042  /**
1043  * Display the Edit Entry form
1044  *
1045  * @return void
1046  */
1047  public function edit_entry_form() {
1048 
1049  $view = \GV\View::by_id( $this->view_id );
1050 
1051  if( $view->settings->get( 'edit_locking' ) ) {
1052  $locking = new GravityView_Edit_Entry_Locking();
1053  $locking->maybe_lock_object( $this->entry['id'] );
1054  }
1055 
1056  ?>
1057 
1058  <div id="wpfooter"></div><!-- used for locking message -->
1059 
1060  <script>
1061  var ajaxurl = '<?php echo admin_url( 'admin-ajax.php', 'relative' ); ?>';
1062  </script>
1063 
1064  <div class="gv-edit-entry-wrapper"><?php
1065 
1066  $javascript = gravityview_ob_include( GravityView_Edit_Entry::$file .'/partials/inline-javascript.php', $this );
1067 
1068  /**
1069  * Fixes weird wpautop() issue
1070  * @see https://github.com/katzwebservices/GravityView/issues/451
1071  */
1072  echo gravityview_strip_whitespace( $javascript );
1073 
1074  ?><h2 class="gv-edit-entry-title">
1075  <span><?php
1076 
1077  /**
1078  * @filter `gravityview_edit_entry_title` Modify the edit entry title
1079  * @param string $edit_entry_title Modify the "Edit Entry" title
1080  * @param GravityView_Edit_Entry_Render $this This object
1081  */
1082  $edit_entry_title = apply_filters('gravityview_edit_entry_title', __('Edit Entry', 'gravityview'), $this );
1083 
1084  echo esc_attr( $edit_entry_title );
1085  ?></span>
1086  </h2>
1087 
1088  <?php $this->maybe_print_message(); ?>
1089 
1090  <?php // The ID of the form needs to be `gform_{form_id}` for the pluploader ?>
1091 
1092  <form method="post" id="gform_<?php echo $this->form_id; ?>" enctype="multipart/form-data">
1093 
1094  <?php
1095 
1096  wp_nonce_field( self::$nonce_key, self::$nonce_key );
1097 
1098  wp_nonce_field( self::$nonce_field, self::$nonce_field, false );
1099 
1100  // Print the actual form HTML
1101  $this->render_edit_form();
1102 
1103  ?>
1104  </form>
1105 
1106  <script>
1107  gform.addFilter('gform_reset_pre_conditional_logic_field_action', function ( reset, formId, targetId, defaultValues, isInit ) {
1108  return false;
1109  });
1110  </script>
1111 
1112  </div>
1113 
1114  <?php
1115  }
1116 
1117  /**
1118  * Display success or error message if the form has been submitted
1119  *
1120  * @uses GVCommon::generate_notice
1121  *
1122  * @since 1.16.2.2
1123  *
1124  * @return void
1125  */
1126  private function maybe_print_message() {
1127 
1128  if ( \GV\Utils::_POST( 'action' ) === 'update' ) {
1129 
1130  if ( GFCommon::has_pages( $this->form ) && apply_filters( 'gravityview/features/paged-edit', false ) ) {
1131  $labels = array(
1132  'cancel' => __( 'Cancel', 'gravityview' ),
1133  'submit' => __( 'Update', 'gravityview' ),
1134  'next' => __( 'Next', 'gravityview' ),
1135  'previous' => __( 'Previous', 'gravityview' ),
1136  );
1137 
1138  /**
1139  * @filter `gravityview/edit_entry/button_labels` Modify the cancel/submit buttons' labels
1140  * @since 1.16.3
1141  * @param array $labels Default button labels associative array
1142  * @param array $form The Gravity Forms form
1143  * @param array $entry The Gravity Forms entry
1144  * @param int $view_id The current View ID
1145  */
1146  $labels = apply_filters( 'gravityview/edit_entry/button_labels', $labels, $this->form, $this->entry, $this->view_id );
1147 
1148  $this->is_paged_submitted = \GV\Utils::_POST( 'save' ) === $labels['submit'];
1149  }
1150 
1151  $back_link = remove_query_arg( array( 'page', 'view', 'edit' ) );
1152 
1153  if( ! $this->is_valid ){
1154 
1155  // Keeping this compatible with Gravity Forms.
1156  $validation_message = "<div class='validation_error'>" . __('There was a problem with your submission.', 'gravityview') . " " . __('Errors have been highlighted below.', 'gravityview') . "</div>";
1157  $message = apply_filters("gform_validation_message_{$this->form['id']}", apply_filters("gform_validation_message", $validation_message, $this->form), $this->form);
1158 
1159  echo GVCommon::generate_notice( $message , 'gv-error' );
1160 
1161  } elseif ( false === $this->is_paged_submitted ) {
1162  // Paged form that hasn't been submitted on the last page yet
1163  $entry_updated_message = sprintf( esc_attr__( 'Entry Updated.', 'gravityview' ), '<a href="' . esc_url( $back_link ) . '">', '</a>' );
1164 
1165  /**
1166  * @filter `gravityview/edit_entry/page/success` Modify the edit entry success message on pages
1167  * @since develop
1168  * @param string $entry_updated_message Existing message
1169  * @param int $view_id View ID
1170  * @param array $entry Gravity Forms entry array
1171  */
1172  $message = apply_filters( 'gravityview/edit_entry/page/success', $entry_updated_message , $this->view_id, $this->entry );
1173 
1174  echo GVCommon::generate_notice( $message );
1175  } else {
1176  $view = \GV\View::by_id( $this->view_id );
1177  $edit_redirect = $view->settings->get( 'edit_redirect' );
1178  $edit_redirect_url = $view->settings->get( 'edit_redirect_url' );
1179 
1180  switch ( $edit_redirect ) {
1181 
1182  case '0':
1183  $redirect_url = $back_link;
1184  $entry_updated_message = sprintf( esc_attr_x('Entry Updated. %sReturning to Entry%s', 'Replacements are HTML', 'gravityview'), '<a href="'. esc_url( $redirect_url ) .'">', '</a>' );
1185  break;
1186 
1187  case '1':
1188  $redirect_url = $directory_link = GravityView_API::directory_link();
1189  $entry_updated_message = sprintf( esc_attr_x('Entry Updated. %sReturning to %s%s', 'Replacement 1 is HTML. Replacement 2 is the title of the page where the user will be taken. Replacement 3 is HTML.','gravityview'), '<a href="'. esc_url( $redirect_url ) . '">', esc_html( $view->post_title ), '</a>' );
1190  break;
1191 
1192  case '2':
1193  $redirect_url = $edit_redirect_url;
1194  $redirect_url = GFCommon::replace_variables( $redirect_url, $this->form, $this->entry, false, false, false, 'text' );
1195  $entry_updated_message = sprintf( esc_attr_x('Entry Updated. %sRedirecting to %s%s', 'Replacement 1 is HTML. Replacement 2 is the URL where the user will be taken. Replacement 3 is HTML.','gravityview'), '<a href="'. esc_url( $redirect_url ) . '">', esc_html( $edit_redirect_url ), '</a>' );
1196  break;
1197 
1198  case '':
1199  default:
1200  $entry_updated_message = sprintf( esc_attr__('Entry Updated. %sReturn to Entry%s', 'gravityview'), '<a href="'. esc_url( $back_link ) .'">', '</a>' );
1201  break;
1202  }
1203 
1204  if ( isset( $redirect_url ) ) {
1205  $entry_updated_message .= sprintf( '<script>window.location.href = %s;</script><noscript><meta http-equiv="refresh" content="0;URL=%s" /></noscript>', json_encode( $redirect_url ), esc_attr( $redirect_url ) );
1206  }
1207 
1208  /**
1209  * @filter `gravityview/edit_entry/success` Modify the edit entry success message (including the anchor link)
1210  * @since 1.5.4
1211  * @param string $entry_updated_message Existing message
1212  * @param int $view_id View ID
1213  * @param array $entry Gravity Forms entry array
1214  * @param string $back_link URL to return to the original entry. @since 1.6
1215  */
1216  $message = apply_filters( 'gravityview/edit_entry/success', $entry_updated_message , $this->view_id, $this->entry, $back_link );
1217 
1218  echo GVCommon::generate_notice( $message );
1219  }
1220 
1221  }
1222  }
1223 
1224  /**
1225  * Display the Edit Entry form in the original Gravity Forms format
1226  *
1227  * @since 1.9
1228  *
1229  * @return void
1230  */
1231  private function render_edit_form() {
1232 
1233  /**
1234  * @action `gravityview/edit-entry/render/before` Before rendering the Edit Entry form
1235  * @since 1.17
1236  * @param GravityView_Edit_Entry_Render $this
1237  */
1238  do_action( 'gravityview/edit-entry/render/before', $this );
1239 
1240  add_filter( 'gform_pre_render', array( $this, 'filter_modify_form_fields'), 5000, 3 );
1241  add_filter( 'gform_submit_button', array( $this, 'render_form_buttons') );
1242  add_filter( 'gform_next_button', array( $this, 'render_form_buttons' ) );
1243  add_filter( 'gform_previous_button', array( $this, 'render_form_buttons' ) );
1244  add_filter( 'gform_disable_view_counter', '__return_true' );
1245 
1246  add_filter( 'gform_field_input', array( $this, 'verify_user_can_edit_post' ), 5, 5 );
1247  add_filter( 'gform_field_input', array( $this, 'modify_edit_field_input' ), 10, 5 );
1248 
1249  // We need to remove the fake $_GET['page'] arg to avoid rendering form as if in admin.
1250  unset( $_GET['page'] );
1251 
1252  $this->show_next_button = false;
1253  $this->show_previous_button = false;
1254 
1255  // TODO: Verify multiple-page forms
1256  if ( GFCommon::has_pages( $this->form ) && apply_filters( 'gravityview/features/paged-edit', false ) ) {
1257  if ( intval( $page_number = \GV\Utils::_POST( 'gform_source_page_number_' . $this->form['id'], 0 ) ) ) {
1258 
1259  $labels = array(
1260  'cancel' => __( 'Cancel', 'gravityview' ),
1261  'submit' => __( 'Update', 'gravityview' ),
1262  'next' => __( 'Next', 'gravityview' ),
1263  'previous' => __( 'Previous', 'gravityview' ),
1264  );
1265 
1266  /**
1267  * @filter `gravityview/edit_entry/button_labels` Modify the cancel/submit buttons' labels
1268  * @since 1.16.3
1269  * @param array $labels Default button labels associative array
1270  * @param array $form The Gravity Forms form
1271  * @param array $entry The Gravity Forms entry
1272  * @param int $view_id The current View ID
1273  */
1274  $labels = apply_filters( 'gravityview/edit_entry/button_labels', $labels, $this->form, $this->entry, $this->view_id );
1275 
1276  GFFormDisplay::$submission[ $this->form['id'] ][ 'form' ] = $this->form;
1277  GFFormDisplay::$submission[ $this->form['id'] ][ 'is_valid' ] = true;
1278 
1279  if ( \GV\Utils::_POST( 'save' ) === $labels['next'] ) {
1280  $last_page = \GFFormDisplay::get_max_page_number( $this->form );
1281 
1282  while ( ++$page_number < $last_page && RGFormsModel::is_page_hidden( $this->form, $page_number, \GV\Utils::_POST( 'gform_field_values' ) ) ) {
1283  } // Advance to next visible page
1284  } elseif ( \GV\Utils::_POST( 'save' ) === $labels['previous'] ) {
1285  while ( --$page_number > 1 && RGFormsModel::is_page_hidden( $this->form, $page_number, \GV\Utils::_POST( 'gform_field_values' ) ) ) {
1286  } // Advance to next visible page
1287  }
1288 
1289  GFFormDisplay::$submission[ $this->form['id'] ]['page_number'] = $page_number;
1290  }
1291 
1292  if ( ( $page_number = intval( $page_number ) ) < 2 ) {
1293  $this->show_next_button = true; // First page
1294  }
1295 
1296  $last_page = \GFFormDisplay::get_max_page_number( $this->form );
1297 
1298  $has_more_pages = $page_number < $last_page;
1299 
1300  if ( $has_more_pages ) {
1301  $this->show_next_button = true; // Not the last page
1302  } else {
1303  $this->show_update_button = true; // The last page
1304  }
1305 
1306  if ( $page_number > 1 ) {
1307  $this->show_previous_button = true; // Not the first page
1308  }
1309  } else {
1310  $this->show_update_button = true;
1311  }
1312 
1313  ob_start(); // Prevent PHP warnings possibly caused by prefilling list fields for conditional logic
1314 
1315  $html = GFFormDisplay::get_form( $this->form['id'], false, false, true, $this->entry );
1316 
1317  ob_get_clean();
1318 
1319  remove_filter( 'gform_pre_render', array( $this, 'filter_modify_form_fields' ), 5000 );
1320  remove_filter( 'gform_submit_button', array( $this, 'render_form_buttons' ) );
1321  remove_filter( 'gform_next_button', array( $this, 'render_form_buttons' ) );
1322  remove_filter( 'gform_previous_button', array( $this, 'render_form_buttons' ) );
1323  remove_filter( 'gform_disable_view_counter', '__return_true' );
1324  remove_filter( 'gform_field_input', array( $this, 'verify_user_can_edit_post' ), 5 );
1325  remove_filter( 'gform_field_input', array( $this, 'modify_edit_field_input' ), 10 );
1326 
1327  echo $html;
1328 
1329  /**
1330  * @action `gravityview/edit-entry/render/after` After rendering the Edit Entry form
1331  * @since 1.17
1332  * @param GravityView_Edit_Entry_Render $this
1333  */
1334  do_action( 'gravityview/edit-entry/render/after', $this );
1335  }
1336 
1337  /**
1338  * Display the Update/Cancel/Delete buttons for the Edit Entry form
1339  * @since 1.8
1340  * @return string
1341  */
1342  public function render_form_buttons() {
1343  return gravityview_ob_include( GravityView_Edit_Entry::$file .'/partials/form-buttons.php', $this );
1344  }
1345 
1346 
1347  /**
1348  * Modify the form fields that are shown when using GFFormDisplay::get_form()
1349  *
1350  * By default, all fields will be shown. We only want the Edit Tab configured fields to be shown.
1351  *
1352  * @param array $form
1353  * @param boolean $ajax Whether in AJAX mode
1354  * @param array|string $field_values Passed parameters to the form
1355  *
1356  * @since 1.9
1357  *
1358  * @return array Modified form array
1359  */
1360  public function filter_modify_form_fields( $form, $ajax = false, $field_values = '' ) {
1361 
1362  if( $form['id'] != $this->form_id ) {
1363  return $form;
1364  }
1365 
1366  // In case we have validated the form, use it to inject the validation results into the form render
1367  if( isset( $this->form_after_validation ) && $this->form_after_validation['id'] === $form['id'] ) {
1369  } else {
1370  $form['fields'] = $this->get_configured_edit_fields( $form, $this->view_id );
1371  }
1372 
1373  $form = $this->filter_conditional_logic( $form );
1374 
1375  $form = $this->prefill_conditional_logic( $form );
1376 
1377  // for now we don't support Save and Continue feature.
1378  if( ! self::$supports_save_and_continue ) {
1379  unset( $form['save'] );
1380  }
1381 
1382  $form = $this->unselect_default_values( $form );
1383 
1384  return $form;
1385  }
1386 
1387  /**
1388  * 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.
1389  *
1390  * @since 1.16.2.2
1391  *
1392  * @param string $field_content Always empty. Returning not-empty overrides the input.
1393  * @param GF_Field $field
1394  * @param string|array $value If array, it's a field with multiple inputs. If string, single input.
1395  * @param int $lead_id Lead ID. Always 0 for the `gform_field_input` filter.
1396  * @param int $form_id Form ID
1397  *
1398  * @return string If error, the error message. If no error, blank string (modify_edit_field_input() runs next)
1399  */
1400  public function verify_user_can_edit_post( $field_content = '', $field, $value, $lead_id = 0, $form_id ) {
1401 
1402  if( ! GFCommon::is_post_field( $field ) ) {
1403  return $field_content;
1404  }
1405 
1406  $message = null;
1407 
1408  // First, make sure they have the capability to edit the post.
1409  if( false === current_user_can( 'edit_post', $this->entry['post_id'] ) ) {
1410 
1411  /**
1412  * @filter `gravityview/edit_entry/unsupported_post_field_text` Modify the message when someone isn't able to edit a post
1413  * @param string $message The existing "You don't have permission..." text
1414  */
1415  $message = apply_filters('gravityview/edit_entry/unsupported_post_field_text', __('You don&rsquo;t have permission to edit this post.', 'gravityview') );
1416 
1417  } elseif( null === get_post( $this->entry['post_id'] ) ) {
1418  /**
1419  * @filter `gravityview/edit_entry/no_post_text` Modify the message when someone is editing an entry attached to a post that no longer exists
1420  * @param string $message The existing "This field is not editable; the post no longer exists." text
1421  */
1422  $message = apply_filters('gravityview/edit_entry/no_post_text', __('This field is not editable; the post no longer exists.', 'gravityview' ) );
1423  }
1424 
1425  if( $message ) {
1426  $field_content = sprintf('<div class="ginput_container ginput_container_' . $field->type . '">%s</div>', wpautop( $message ) );
1427  }
1428 
1429  return $field_content;
1430  }
1431 
1432  /**
1433  *
1434  * Fill-in the saved values into the form inputs
1435  *
1436  * @param string $field_content Always empty. Returning not-empty overrides the input.
1437  * @param GF_Field $field
1438  * @param string|array $value If array, it's a field with multiple inputs. If string, single input.
1439  * @param int $lead_id Lead ID. Always 0 for the `gform_field_input` filter.
1440  * @param int $form_id Form ID
1441  *
1442  * @return mixed
1443  */
1444  public function modify_edit_field_input( $field_content = '', $field, $value, $lead_id = 0, $form_id ) {
1445 
1447 
1448  // If the form has been submitted, then we don't need to pre-fill the values,
1449  // Except for fileupload type and when a field input is overridden- run always!!
1450  if(
1451  ( $this->is_edit_entry_submission() && !in_array( $field->type, array( 'fileupload', 'post_image' ) ) )
1452  && false === ( $gv_field && is_callable( array( $gv_field, 'get_field_input' ) ) )
1453  && ! GFCommon::is_product_field( $field->type )
1454  || ! empty( $field_content )
1455  || in_array( $field->type, array( 'honeypot' ) )
1456  ) {
1457  return $field_content;
1458  }
1459 
1460  // SET SOME FIELD DEFAULTS TO PREVENT ISSUES
1461  $field->adminOnly = false; /** @see GFFormDisplay::get_counter_init_script() need to prevent adminOnly */
1462 
1463  $field_value = $this->get_field_value( $field );
1464 
1465  // Prevent any PHP warnings, like undefined index
1466  ob_start();
1467 
1468  $return = null;
1469 
1470  /** @var GravityView_Field $gv_field */
1471  if( $gv_field && is_callable( array( $gv_field, 'get_field_input' ) ) ) {
1472  $return = $gv_field->get_field_input( $this->form, $field_value, $this->entry, $field );
1473  } else {
1474  $return = $field->get_field_input( $this->form, $field_value, $this->entry );
1475  }
1476 
1477  // If there was output, it's an error
1478  $warnings = ob_get_clean();
1479 
1480  if( !empty( $warnings ) ) {
1481  gravityview()->log->error( '{warning}', array( 'warning' => $warnings, 'data' => $field_value ) );
1482  }
1483 
1484  return $return;
1485  }
1486 
1487  /**
1488  * Modify the value for the current field input
1489  *
1490  * @param GF_Field $field
1491  *
1492  * @return array|mixed|string
1493  */
1494  private function get_field_value( $field ) {
1495 
1496  /**
1497  * @filter `gravityview/edit_entry/pre_populate/override` Allow the pre-populated value to override saved value in Edit Entry form. By default, pre-populate mechanism only kicks on empty fields.
1498  * @param boolean True: override saved values; False: don't override (default)
1499  * @param $field GF_Field object Gravity Forms field object
1500  * @since 1.13
1501  */
1502  $override_saved_value = apply_filters( 'gravityview/edit_entry/pre_populate/override', false, $field );
1503 
1504  // We're dealing with multiple inputs (e.g. checkbox) but not time or date (as it doesn't store data in input IDs)
1505  if( isset( $field->inputs ) && is_array( $field->inputs ) && !in_array( $field->type, array( 'time', 'date' ) ) ) {
1506 
1507  $field_value = array();
1508 
1509  // only accept pre-populated values if the field doesn't have any choice selected.
1510  $allow_pre_populated = $field->allowsPrepopulate;
1511 
1512  foreach ( (array)$field->inputs as $input ) {
1513 
1514  $input_id = strval( $input['id'] );
1515 
1516  if ( isset( $this->entry[ $input_id ] ) && ! gv_empty( $this->entry[ $input_id ], false, false ) ) {
1517  $field_value[ $input_id ] = 'post_category' === $field->type ? GFCommon::format_post_category( $this->entry[ $input_id ], true ) : $this->entry[ $input_id ];
1518  $allow_pre_populated = false;
1519  }
1520 
1521  }
1522 
1523  $pre_value = $field->get_value_submission( array(), false );
1524 
1525  $field_value = ! $allow_pre_populated && ! ( $override_saved_value && !gv_empty( $pre_value, false, false ) ) ? $field_value : $pre_value;
1526 
1527  } else {
1528 
1529  $id = intval( $field->id );
1530 
1531  // get pre-populated value if exists
1532  $pre_value = $field->allowsPrepopulate ? GFFormsModel::get_parameter_value( $field->inputName, array(), $field ) : '';
1533 
1534  // saved field entry value (if empty, fallback to the pre-populated value, if exists)
1535  // or pre-populated value if not empty and set to override saved value
1536  $field_value = isset( $this->entry[ $id ] ) && ! gv_empty( $this->entry[ $id ], false, false ) && ! ( $override_saved_value && !gv_empty( $pre_value, false, false ) ) ? $this->entry[ $id ] : $pre_value;
1537 
1538  // in case field is post_category but inputType is select, multi-select or radio, convert value into array of category IDs.
1539  if ( 'post_category' === $field->type && !gv_empty( $field_value, false, false ) ) {
1540  $categories = array();
1541  foreach ( explode( ',', $field_value ) as $cat_string ) {
1542  $categories[] = GFCommon::format_post_category( $cat_string, true );
1543  }
1544  $field_value = 'multiselect' === $field->get_input_type() ? $categories : implode( '', $categories );
1545  }
1546 
1547  }
1548 
1549  // if value is empty get the default value if defined
1550  $field_value = $field->get_value_default_if_empty( $field_value );
1551 
1552  /**
1553  * @filter `gravityview/edit_entry/field_value` Change the value of an Edit Entry field, if needed
1554  * @since 1.11
1555  * @since 1.20 Added third param
1556  * @param mixed $field_value field value used to populate the input
1557  * @param object $field Gravity Forms field object ( Class GF_Field )
1558  * @param GravityView_Edit_Entry_Render $this Current object
1559  */
1560  $field_value = apply_filters( 'gravityview/edit_entry/field_value', $field_value, $field, $this );
1561 
1562  /**
1563  * @filter `gravityview/edit_entry/field_value_{field_type}` Change the value of an Edit Entry field for a specific field type
1564  * @since 1.17
1565  * @since 1.20 Added third param
1566  * @param mixed $field_value field value used to populate the input
1567  * @param GF_Field $field Gravity Forms field object
1568  * @param GravityView_Edit_Entry_Render $this Current object
1569  */
1570  $field_value = apply_filters( 'gravityview/edit_entry/field_value_' . $field->type , $field_value, $field, $this );
1571 
1572  return $field_value;
1573  }
1574 
1575 
1576  // ---- Entry validation
1577 
1578  /**
1579  * Add field keys that Gravity Forms expects.
1580  *
1581  * @see GFFormDisplay::validate()
1582  * @param array $form GF Form
1583  * @return array Modified GF Form
1584  */
1585  public function gform_pre_validation( $form ) {
1586 
1587  if( ! $this->verify_nonce() ) {
1588  return $form;
1589  }
1590 
1591  // Fix PHP warning regarding undefined index.
1592  foreach ( $form['fields'] as &$field) {
1593 
1594  // This is because we're doing admin form pretending to be front-end, so Gravity Forms
1595  // expects certain field array items to be set.
1596  foreach ( array( 'noDuplicates', 'adminOnly', 'inputType', 'isRequired', 'enablePrice', 'inputs', 'allowedExtensions' ) as $key ) {
1597  $field->{$key} = isset( $field->{$key} ) ? $field->{$key} : NULL;
1598  }
1599 
1600  switch( RGFormsModel::get_input_type( $field ) ) {
1601 
1602  /**
1603  * this whole fileupload hack is because in the admin, Gravity Forms simply doesn't update any fileupload field if it's empty, but it DOES in the frontend.
1604  *
1605  * What we have to do is set the value so that it doesn't get overwritten as empty on save and appears immediately in the Edit Entry screen again.
1606  *
1607  * @hack
1608  */
1609  case 'fileupload':
1610 
1611  // Set the previous value
1612  $entry = $this->get_entry();
1613 
1614  $input_name = 'input_'.$field->id;
1615  $form_id = $form['id'];
1616 
1617  $value = NULL;
1618 
1619  // Use the previous entry value as the default.
1620  if( isset( $entry[ $field->id ] ) ) {
1621  $value = $entry[ $field->id ];
1622  }
1623 
1624  // If this is a single upload file
1625  if( !empty( $_FILES[ $input_name ] ) && !empty( $_FILES[ $input_name ]['name'] ) ) {
1626  $file_path = GFFormsModel::get_file_upload_path( $form['id'], $_FILES[ $input_name ]['name'] );
1627  $value = $file_path['url'];
1628 
1629  } else {
1630 
1631  // Fix PHP warning on line 1498 of form_display.php for post_image fields
1632  // Fix PHP Notice: Undefined index: size in form_display.php on line 1511
1633  $_FILES[ $input_name ] = array('name' => '', 'size' => '' );
1634 
1635  }
1636 
1637  if ( \GV\Utils::get( $field, "multipleFiles" ) ) {
1638 
1639  // If there are fresh uploads, process and merge them.
1640  // Otherwise, use the passed values, which should be json-encoded array of URLs
1641  if( isset( GFFormsModel::$uploaded_files[$form_id][$input_name] ) ) {
1642  $value = empty( $value ) ? '[]' : $value;
1643  $value = stripslashes_deep( $value );
1644  $value = GFFormsModel::prepare_value( $form, $field, $value, $input_name, $entry['id'], array());
1645  }
1646 
1647  } else {
1648 
1649  // A file already exists when editing an entry
1650  // We set this to solve issue when file upload fields are required.
1651  GFFormsModel::$uploaded_files[ $form_id ][ $input_name ] = $value;
1652 
1653  }
1654 
1655  $this->entry[ $input_name ] = $value;
1656  $_POST[ $input_name ] = $value;
1657 
1658  break;
1659 
1660  case 'number':
1661  // Fix "undefined index" issue at line 1286 in form_display.php
1662  if( !isset( $_POST['input_'.$field->id ] ) ) {
1663  $_POST['input_'.$field->id ] = NULL;
1664  }
1665  break;
1666  }
1667 
1668  }
1669 
1670  return $form;
1671  }
1672 
1673 
1674  /**
1675  * Process validation for a edit entry submission
1676  *
1677  * Sets the `is_valid` object var
1678  *
1679  * @return void
1680  */
1681  private function validate() {
1682 
1683  /**
1684  * If using GF User Registration Add-on, remove the validation step, otherwise generates error when updating the entry
1685  * GF User Registration Add-on version > 3.x has a different class name
1686  * @since 1.16.2
1687  */
1688  if ( class_exists( 'GF_User_Registration' ) ) {
1689  remove_filter( 'gform_validation', array( GF_User_Registration::get_instance(), 'validate' ) );
1690  } else if ( class_exists( 'GFUser' ) ) {
1691  remove_filter( 'gform_validation', array( 'GFUser', 'user_registration_validation' ) );
1692  }
1693 
1694 
1695  /**
1696  * For some crazy reason, Gravity Forms doesn't validate Edit Entry form submissions.
1697  * You can enter whatever you want!
1698  * We try validating, and customize the results using `self::custom_validation()`
1699  */
1700  add_filter( 'gform_validation_'. $this->form_id, array( $this, 'custom_validation' ), 10, 4);
1701 
1702  // Needed by the validate funtion
1703  $failed_validation_page = NULL;
1704  $field_values = RGForms::post( 'gform_field_values' );
1705 
1706  // Prevent entry limit from running when editing an entry, also
1707  // prevent form scheduling from preventing editing
1708  unset( $this->form['limitEntries'], $this->form['scheduleForm'] );
1709 
1710  // Hide fields depending on Edit Entry settings
1711  $this->form['fields'] = $this->get_configured_edit_fields( $this->form, $this->view_id );
1712 
1713  $this->is_valid = GFFormDisplay::validate( $this->form, $field_values, 1, $failed_validation_page );
1714 
1715  remove_filter( 'gform_validation_'. $this->form_id, array( $this, 'custom_validation' ), 10 );
1716  }
1717 
1718 
1719  /**
1720  * Make validation work for Edit Entry
1721  *
1722  * Because we're calling the GFFormDisplay::validate() in an unusual way (as a front-end
1723  * form pretending to be a back-end form), validate() doesn't know we _can't_ edit post
1724  * fields. This goes through all the fields and if they're an invalid post field, we
1725  * set them as valid. If there are still issues, we'll return false.
1726  *
1727  * @param $validation_results {
1728  * @type bool $is_valid
1729  * @type array $form
1730  * @type int $failed_validation_page The page number which has failed validation.
1731  * }
1732  *
1733  * @return array
1734  */
1735  public function custom_validation( $validation_results ) {
1736 
1737  gravityview()->log->debug( 'GravityView_Edit_Entry[custom_validation] Validation results: ', array( 'data' => $validation_results ) );
1738 
1739  gravityview()->log->debug( 'GravityView_Edit_Entry[custom_validation] $_POSTed data (sanitized): ', array( 'data' => esc_html( print_r( $_POST, true ) ) ) );
1740 
1741  $gv_valid = true;
1742 
1743  foreach ( $validation_results['form']['fields'] as $key => &$field ) {
1744 
1745  $value = RGFormsModel::get_field_value( $field );
1746  $field_type = RGFormsModel::get_input_type( $field );
1747 
1748  // Validate always
1749  switch ( $field_type ) {
1750 
1751 
1752  case 'fileupload' :
1753  case 'post_image':
1754 
1755  // in case nothing is uploaded but there are already files saved
1756  if( !empty( $field->failed_validation ) && !empty( $field->isRequired ) && !empty( $value ) ) {
1757  $field->failed_validation = false;
1758  unset( $field->validation_message );
1759  }
1760 
1761  // validate if multi file upload reached max number of files [maxFiles] => 2
1762  if( \GV\Utils::get( $field, 'maxFiles') && \GV\Utils::get( $field, 'multipleFiles') ) {
1763 
1764  $input_name = 'input_' . $field->id;
1765  //uploaded
1766  $file_names = isset( GFFormsModel::$uploaded_files[ $validation_results['form']['id'] ][ $input_name ] ) ? GFFormsModel::$uploaded_files[ $validation_results['form']['id'] ][ $input_name ] : array();
1767 
1768  //existent
1769  $entry = $this->get_entry();
1770  $value = NULL;
1771  if( isset( $entry[ $field->id ] ) ) {
1772  $value = json_decode( $entry[ $field->id ], true );
1773  }
1774 
1775  // count uploaded files and existent entry files
1776  $count_files = ( is_array( $file_names ) ? count( $file_names ) : 0 ) +
1777  ( is_array( $value ) ? count( $value ) : 0 );
1778 
1779  if( $count_files > $field->maxFiles ) {
1780  $field->validation_message = __( 'Maximum number of files reached', 'gravityview' );
1781  $field->failed_validation = 1;
1782  $gv_valid = false;
1783 
1784  // in case of error make sure the newest upload files are removed from the upload input
1785  GFFormsModel::$uploaded_files[ $validation_results['form']['id'] ] = null;
1786  }
1787 
1788  }
1789 
1790 
1791  break;
1792 
1793  }
1794 
1795  // This field has failed validation.
1796  if( !empty( $field->failed_validation ) ) {
1797 
1798  gravityview()->log->debug( 'GravityView_Edit_Entry[custom_validation] Field is invalid.', array( 'data' => array( 'field' => $field, 'value' => $value ) ) );
1799 
1800  switch ( $field_type ) {
1801 
1802  // Captchas don't need to be re-entered.
1803  case 'captcha':
1804 
1805  // Post Image fields aren't editable, so we un-fail them.
1806  case 'post_image':
1807  $field->failed_validation = false;
1808  unset( $field->validation_message );
1809  break;
1810 
1811  }
1812 
1813  // You can't continue inside a switch, so we do it after.
1814  if( empty( $field->failed_validation ) ) {
1815  continue;
1816  }
1817 
1818  // checks if the No Duplicates option is not validating entry against itself, since
1819  // we're editing a stored entry, it would also assume it's a duplicate.
1820  if( !empty( $field->noDuplicates ) ) {
1821 
1822  $entry = $this->get_entry();
1823 
1824  // If the value of the entry is the same as the stored value
1825  // Then we can assume it's not a duplicate, it's the same.
1826  if( !empty( $entry ) && $value == $entry[ $field->id ] ) {
1827  //if value submitted was not changed, then don't validate
1828  $field->failed_validation = false;
1829 
1830  unset( $field->validation_message );
1831 
1832  gravityview()->log->debug( 'GravityView_Edit_Entry[custom_validation] Field not a duplicate; it is the same entry.', array( 'data' => $entry ) );
1833 
1834  continue;
1835  }
1836  }
1837 
1838  // if here then probably we are facing the validation 'At least one field must be filled out'
1839  if( GFFormDisplay::is_empty( $field, $this->form_id ) && empty( $field->isRequired ) ) {
1840  unset( $field->validation_message );
1841  $field->validation_message = false;
1842  continue;
1843  }
1844 
1845  $gv_valid = false;
1846 
1847  }
1848 
1849  }
1850 
1851  $validation_results['is_valid'] = $gv_valid;
1852 
1853  gravityview()->log->debug( 'GravityView_Edit_Entry[custom_validation] Validation results.', array( 'data' => $validation_results ) );
1854 
1855  // We'll need this result when rendering the form ( on GFFormDisplay::get_form )
1856  $this->form_after_validation = $validation_results['form'];
1857 
1858  return $validation_results;
1859  }
1860 
1861 
1862  /**
1863  * TODO: This seems to be hacky... we should remove it. Entry is set when updating the form using setup_vars()!
1864  * Get the current entry and set it if it's not yet set.
1865  * @return array Gravity Forms entry array
1866  */
1867  public function get_entry() {
1868 
1869  if( empty( $this->entry ) ) {
1870  // Get the database value of the entry that's being edited
1872  }
1873 
1874  return $this->entry;
1875  }
1876 
1877 
1878 
1879  // --- Filters
1880 
1881  /**
1882  * Get the Edit Entry fields as configured in the View
1883  *
1884  * @since 1.8
1885  *
1886  * @param int $view_id
1887  *
1888  * @return array Array of fields that are configured in the Edit tab in the Admin
1889  */
1891 
1892  // Get all fields for form
1893  if ( \GV\View::exists( $view_id ) ) {
1895  $properties = $view->fields ? $view->fields->as_configuration() : array();
1896  } else {
1897  $properties = null;
1898  }
1899 
1900  // If edit tab not yet configured, show all fields
1901  $edit_fields = !empty( $properties['edit_edit-fields'] ) ? $properties['edit_edit-fields'] : NULL;
1902 
1903  // Hide fields depending on admin settings
1904  $fields = $this->filter_fields( $form['fields'], $edit_fields );
1905 
1906  // If Edit Entry fields are configured, remove adminOnly field settings. Otherwise, don't.
1907  $fields = $this->filter_admin_only_fields( $fields, $edit_fields, $form, $view_id );
1908 
1909  /**
1910  * @filter `gravityview/edit_entry/form_fields` Modify the fields displayed in Edit Entry form
1911  * @since 1.17
1912  * @param GF_Field[] $fields Gravity Forms form fields
1913  * @param array|null $edit_fields Fields for the Edit Entry tab configured in the View Configuration
1914  * @param array $form GF Form array (`fields` key modified to have only fields configured to show in Edit Entry)
1915  * @param int $view_id View ID
1916  */
1917  $fields = apply_filters( 'gravityview/edit_entry/form_fields', $fields, $edit_fields, $form, $view_id );
1918 
1919  return $fields;
1920  }
1921 
1922 
1923  /**
1924  * Filter area fields based on specified conditions
1925  * - This filter removes the fields that have calculation configured
1926  * - Hides fields that are hidden, etc.
1927  *
1928  * @uses GravityView_Edit_Entry::user_can_edit_field() Check caps
1929  * @access private
1930  * @param GF_Field[] $fields
1931  * @param array $configured_fields
1932  * @since 1.5
1933  * @return array $fields
1934  */
1935  private function filter_fields( $fields, $configured_fields ) {
1936 
1937  if( empty( $fields ) || !is_array( $fields ) ) {
1938  return $fields;
1939  }
1940 
1941  $edit_fields = array();
1942 
1943  $field_type_blacklist = $this->loader->get_field_blacklist( $this->entry );
1944 
1945  if ( empty( $configured_fields ) && apply_filters( 'gravityview/features/paged-edit', false ) ) {
1946  $field_type_blacklist = array_diff( $field_type_blacklist, array( 'page' ) );
1947  }
1948 
1949  // First, remove blacklist or calculation fields
1950  foreach ( $fields as $key => $field ) {
1951 
1952  // Remove the fields that have calculation properties and keep them to be used later
1953  // @since 1.16.2
1954  if( $field->has_calculation() ) {
1955  $this->fields_with_calculation[] = $field;
1956  // don't remove the calculation fields on form render.
1957  }
1958 
1959  if( in_array( $field->type, $field_type_blacklist ) ) {
1960  unset( $fields[ $key ] );
1961  }
1962  }
1963 
1964  // The Edit tab has not been configured, so we return all fields by default.
1965  // But we do keep the hidden ones hidden please, for everyone :)
1966  if ( empty( $configured_fields ) ) {
1967 
1968  $out_fields = array();
1969 
1970  foreach ( $fields as &$field ) {
1971 
1972  /**
1973  * @filter `gravityview/edit_entry/render_hidden_field`
1974  * @see https://docs.gravityview.co/article/678-edit-entry-hidden-fields-field-visibility
1975  * @since 2.7
1976  * @param[in,out] bool $render_hidden_field Whether to render this Hidden field in HTML. Default: true
1977  * @param GF_Field $field The field to possibly remove
1978  */
1979  $render_hidden_field = apply_filters( 'gravityview/edit_entry/render_hidden_field', true, $field );
1980 
1981  if ( 'hidden' === $field->type && ! $render_hidden_field ) {
1982  continue; // Don't include hidden fields in the output
1983  }
1984 
1985  if ( 'hidden' == $field->visibility ) {
1986  continue; // Never include when no fields are configured
1987  }
1988 
1989  $out_fields[] = $field;
1990  }
1991 
1992  return array_values( $out_fields );
1993  }
1994 
1995  // The edit tab has been configured, so we loop through to configured settings
1996  foreach ( $configured_fields as $configured_field ) {
1997 
1998  /** @var GF_Field $field */
1999  foreach ( $fields as $field ) {
2000  if( intval( $configured_field['id'] ) === intval( $field->id ) && $this->user_can_edit_field( $configured_field, false ) ) {
2001  $edit_fields[] = $this->merge_field_properties( $field, $configured_field );
2002  break;
2003  }
2004 
2005  }
2006 
2007  }
2008 
2009  return $edit_fields;
2010 
2011  }
2012 
2013  /**
2014  * Override GF Form field properties with the ones defined on the View
2015  * @param GF_Field $field GF Form field object
2016  * @param array $field_setting GV field options
2017  * @since 1.5
2018  * @return array|GF_Field
2019  */
2020  private function merge_field_properties( $field, $field_setting ) {
2021 
2022  $return_field = $field;
2023 
2024  if( empty( $field_setting['show_label'] ) ) {
2025  $return_field->label = '';
2026  } elseif ( !empty( $field_setting['custom_label'] ) ) {
2027  $return_field->label = $field_setting['custom_label'];
2028  }
2029 
2030  if( !empty( $field_setting['custom_class'] ) ) {
2031  $return_field->cssClass .= ' '. gravityview_sanitize_html_class( $field_setting['custom_class'] );
2032  }
2033 
2034  /**
2035  * Normalize page numbers - avoid conflicts with page validation
2036  * @since 1.6
2037  */
2038  $return_field->pageNumber = 1;
2039 
2040  return $return_field;
2041 
2042  }
2043 
2044  /**
2045  * Remove fields that shouldn't be visible based on the Gravity Forms adminOnly field property
2046  *
2047  * @since 1.9.1
2048  *
2049  * @param array|GF_Field[] $fields Gravity Forms form fields
2050  * @param array|null $edit_fields Fields for the Edit Entry tab configured in the View Configuration
2051  * @param array $form GF Form array
2052  * @param int $view_id View ID
2053  *
2054  * @return array Possibly modified form array
2055  */
2056  private function filter_admin_only_fields( $fields = array(), $edit_fields = null, $form = array(), $view_id = 0 ) {
2057 
2058  /**
2059  * @filter `gravityview/edit_entry/use_gf_admin_only_setting` When Edit tab isn't configured, should the Gravity Forms "Admin Only" field settings be used to control field display to non-admins? Default: true
2060  * If the Edit Entry tab is not configured, adminOnly fields will not be shown to non-administrators.
2061  * If the Edit Entry tab *is* configured, adminOnly fields will be shown to non-administrators, using the configured GV permissions
2062  * @since 1.9.1
2063  * @param boolean $use_gf_adminonly_setting True: Hide field if set to Admin Only in GF and the user is not an admin. False: show field based on GV permissions, ignoring GF permissions.
2064  * @param array $form GF Form array
2065  * @param int $view_id View ID
2066  */
2067  $use_gf_adminonly_setting = apply_filters( 'gravityview/edit_entry/use_gf_admin_only_setting', empty( $edit_fields ), $form, $view_id );
2068 
2069  if( $use_gf_adminonly_setting && false === GVCommon::has_cap( 'gravityforms_edit_entries', $this->entry['id'] ) ) {
2070  foreach( $fields as $k => $field ) {
2071  if( $field->adminOnly ) {
2072  unset( $fields[ $k ] );
2073  }
2074  }
2075  return array_values( $fields );
2076  }
2077 
2078  foreach( $fields as &$field ) {
2079  $field->adminOnly = false;
2080  }
2081 
2082  return $fields;
2083  }
2084 
2085  /**
2086  * Checkboxes and other checkbox-based controls should not
2087  * display default checks in edit mode.
2088  *
2089  * https://github.com/gravityview/GravityView/1149
2090  *
2091  * @since 2.1
2092  *
2093  * @param array $form Gravity Forms array object
2094  *
2095  * @return array $form, modified to default checkboxes, radios from showing up.
2096  */
2097  private function unselect_default_values( $form ) {
2098 
2099  foreach ( $form['fields'] as &$field ) {
2100 
2101  if ( empty( $field->choices ) ) {
2102  continue;
2103  }
2104 
2105  foreach ( $field->choices as &$choice ) {
2106  if ( \GV\Utils::get( $choice, 'isSelected' ) ) {
2107  $choice['isSelected'] = false;
2108  }
2109  }
2110  }
2111 
2112  return $form;
2113  }
2114 
2115  // --- Conditional Logic
2116 
2117  /**
2118  * Conditional logic isn't designed to work with forms that already have content. When switching input values,
2119  * the dependent fields will be blank.
2120  *
2121  * Note: This is because GF populates a JavaScript variable with the input values. This is tough to filter at the input level;
2122  * via the `gform_field_value` filter; it requires lots of legwork. Doing it at the form level is easier.
2123  *
2124  * @since 1.17.4
2125  *
2126  * @param array $form Gravity Forms array object
2127  *
2128  * @return array $form, modified to fix conditional
2129  */
2130  function prefill_conditional_logic( $form ) {
2131 
2132  if( ! GFFormDisplay::has_conditional_logic( $form ) ) {
2133  return $form;
2134  }
2135 
2136  // Have Conditional Logic pre-fill fields as if the data were default values
2137  /** @var GF_Field $field */
2138  foreach ( $form['fields'] as &$field ) {
2139 
2140  if( 'checkbox' === $field->type ) {
2141  foreach ( $field->get_entry_inputs() as $key => $input ) {
2142  $input_id = $input['id'];
2143  $choice = $field->choices[ $key ];
2144  $value = \GV\Utils::get( $this->entry, $input_id );
2145  $match = RGFormsModel::choice_value_match( $field, $choice, $value );
2146  if( $match ) {
2147  $field->choices[ $key ]['isSelected'] = true;
2148  }
2149  }
2150  } else {
2151 
2152  // We need to run through each field to set the default values
2153  foreach ( $this->entry as $field_id => $field_value ) {
2154 
2155  if( floatval( $field_id ) === floatval( $field->id ) ) {
2156 
2157  if( 'list' === $field->type ) {
2158  $list_rows = maybe_unserialize( $field_value );
2159 
2160  $list_field_value = array();
2161  foreach ( (array) $list_rows as $row ) {
2162  foreach ( (array) $row as $column ) {
2163  $list_field_value[] = $column;
2164  }
2165  }
2166 
2167  $field->defaultValue = serialize( $list_field_value );
2168  } else {
2169  $field->defaultValue = $field_value;
2170  }
2171  }
2172  }
2173  }
2174  }
2175 
2176  return $form;
2177  }
2178 
2179  /**
2180  * Remove the conditional logic rules from the form button and the form fields, if needed.
2181  *
2182  * @todo Merge with caller method
2183  * @since 1.9
2184  *
2185  * @param array $form Gravity Forms form
2186  * @return array Modified form, if not using Conditional Logic
2187  */
2188  private function filter_conditional_logic( $form ) {
2189  /**
2190  * Fields that are tied to a conditional logic field that is not present in the view
2191  * have to still be displayed, if the condition is met.
2192  *
2193  * @see https://github.com/gravityview/GravityView/issues/840
2194  * @since develop
2195  */
2196  $the_form = GFAPI::get_form( $form['id'] );
2197  $editable_ids = array();
2198  foreach ( $form['fields'] as $field ) {
2199  $editable_ids[] = $field['id']; // wp_list_pluck is destructive in this context
2200  }
2201  $remove_conditions_rule = array();
2202  foreach ( $the_form['fields'] as $field ) {
2203  if ( ! empty( $field->conditionalLogic ) && ! empty( $field->conditionalLogic['rules'] ) ) {
2204  foreach ( $field->conditionalLogic['rules'] as $i => $rule ) {
2205  if ( ! in_array( $rule['fieldId'], $editable_ids ) ) {
2206  /**
2207  * This conditional field is not editable in this View.
2208  * We need to remove the rule, but only if it matches.
2209  */
2210  if ( $_field = GFAPI::get_field( $the_form, $rule['fieldId'] ) ) {
2211  $value = $_field->get_value_export( $this->entry );
2212  } elseif ( isset( $this->entry[ $rule['fieldId'] ] ) ) {
2213  $value = $this->entry[ $rule['fieldId'] ];
2214  } else {
2215  $value = gform_get_meta( $this->entry['id'], $rule['fieldId'] );
2216  }
2217 
2218  $match = GFFormsModel::matches_operation( $value, $rule['value'], $rule['operator'] );
2219 
2220  if ( $match ) {
2221  $remove_conditions_rule[] = array( $field['id'], $i );
2222  }
2223  }
2224  }
2225  }
2226  }
2227 
2228  if ( $remove_conditions_rule ) {
2229  foreach ( $form['fields'] as &$field ) {
2230  foreach ( $remove_conditions_rule as $_remove_conditions_r ) {
2231 
2232  list( $rule_field_id, $rule_i ) = $_remove_conditions_r;
2233 
2234  if ( $field['id'] == $rule_field_id ) {
2235  unset( $field->conditionalLogic['rules'][ $rule_i ] );
2236  gravityview()->log->debug( 'Removed conditional rule #{rule} for field {field_id}', array( 'rule' => $rule_i, 'field_id' => $field['id'] ) );
2237  }
2238  }
2239  }
2240  }
2241 
2242  /** Normalize the indices... */
2243  $form['fields'] = array_values( $form['fields'] );
2244 
2245  /**
2246  * @filter `gravityview/edit_entry/conditional_logic` Should the Edit Entry form use Gravity Forms conditional logic showing/hiding of fields?
2247  * @since 1.9
2248  * @param bool $use_conditional_logic True: Gravity Forms will show/hide fields just like in the original form; False: conditional logic will be disabled and fields will be shown based on configuration. Default: true
2249  * @param array $form Gravity Forms form
2250  */
2251  $use_conditional_logic = apply_filters( 'gravityview/edit_entry/conditional_logic', true, $form );
2252 
2253  if( $use_conditional_logic ) {
2254  return $form;
2255  }
2256 
2257  foreach( $form['fields'] as &$field ) {
2258  /* @var GF_Field $field */
2259  $field->conditionalLogic = null;
2260  }
2261 
2262  unset( $form['button']['conditionalLogic'] );
2263 
2264  return $form;
2265 
2266  }
2267 
2268  /**
2269  * Disable the Gravity Forms conditional logic script and features on the Edit Entry screen
2270  *
2271  * @since 1.9
2272  *
2273  * @param $has_conditional_logic
2274  * @param $form
2275  * @return mixed
2276  */
2277  public function manage_conditional_logic( $has_conditional_logic, $form ) {
2278 
2279  if( ! $this->is_edit_entry() ) {
2280  return $has_conditional_logic;
2281  }
2282 
2283  /** @see GravityView_Edit_Entry_Render::filter_conditional_logic for filter documentation */
2284  return apply_filters( 'gravityview/edit_entry/conditional_logic', $has_conditional_logic, $form );
2285  }
2286 
2287 
2288  // --- User checks and nonces
2289 
2290  /**
2291  * Check if the user can edit the entry
2292  *
2293  * - Is the nonce valid?
2294  * - Does the user have the right caps for the entry
2295  * - Is the entry in the trash?
2296  *
2297  * @todo Move to GVCommon
2298  *
2299  * @param boolean $echo Show error messages in the form?
2300  * @return boolean True: can edit form. False: nope.
2301  */
2302  private function user_can_edit_entry( $echo = false ) {
2303 
2304  $error = NULL;
2305 
2306  /**
2307  * 1. Permalinks are turned off
2308  * 2. There are two entries embedded using oEmbed
2309  * 3. One of the entries has just been saved
2310  */
2311  if( !empty( $_POST['lid'] ) && !empty( $_GET['entry'] ) && ( $_POST['lid'] !== $_GET['entry'] ) ) {
2312 
2313  $error = true;
2314 
2315  }
2316 
2317  if( !empty( $_GET['entry'] ) && (string)$this->entry['id'] !== $_GET['entry'] ) {
2318 
2319  $error = true;
2320 
2321  } elseif( ! $this->verify_nonce() ) {
2322 
2323  /**
2324  * If the Entry is embedded, there may be two entries on the same page.
2325  * If that's the case, and one is being edited, the other should fail gracefully and not display an error.
2326  */
2327  if( GravityView_oEmbed::getInstance()->get_entry_id() ) {
2328  $error = true;
2329  } else {
2330  $error = __( 'The link to edit this entry is not valid; it may have expired.', 'gravityview');
2331  }
2332 
2333  }
2334 
2335  if( ! GravityView_Edit_Entry::check_user_cap_edit_entry( $this->entry ) ) {
2336  $error = __( 'You do not have permission to edit this entry.', 'gravityview');
2337  }
2338 
2339  if( $this->entry['status'] === 'trash' ) {
2340  $error = __('You cannot edit the entry; it is in the trash.', 'gravityview' );
2341  }
2342 
2343  // No errors; everything's fine here!
2344  if( empty( $error ) ) {
2345  return true;
2346  }
2347 
2348  if( $echo && $error !== true ) {
2349 
2350  $error = esc_html( $error );
2351 
2352  /**
2353  * @since 1.9
2354  */
2355  if ( ! empty( $this->entry ) ) {
2356  $error .= ' ' . gravityview_get_link( '#', _x('Go back.', 'Link shown when invalid Edit Entry link is clicked', 'gravityview' ), array( 'onclick' => "window.history.go(-1); return false;" ) );
2357  }
2358 
2359  echo GVCommon::generate_notice( wpautop( $error ), 'gv-error error');
2360  }
2361 
2362  gravityview()->log->error( '{error}', array( 'error' => $error ) );
2363 
2364  return false;
2365  }
2366 
2367 
2368  /**
2369  * Check whether a field is editable by the current user, and optionally display an error message
2370  * @uses GravityView_Edit_Entry->check_user_cap_edit_field() Check user capabilities
2371  * @param array $field Field or field settings array
2372  * @param boolean $echo Whether to show error message telling user they aren't allowed
2373  * @return boolean True: user can edit the current field; False: nope, they can't.
2374  */
2375  private function user_can_edit_field( $field, $echo = false ) {
2376 
2377  $error = NULL;
2378 
2379  if( ! $this->check_user_cap_edit_field( $field ) ) {
2380  $error = __( 'You do not have permission to edit this field.', 'gravityview');
2381  }
2382 
2383  // No errors; everything's fine here!
2384  if( empty( $error ) ) {
2385  return true;
2386  }
2387 
2388  if( $echo ) {
2389  echo GVCommon::generate_notice( wpautop( esc_html( $error ) ), 'gv-error error');
2390  }
2391 
2392  gravityview()->log->error( '{error}', array( 'error' => $error ) );
2393 
2394  return false;
2395 
2396  }
2397 
2398 
2399  /**
2400  * checks if user has permissions to edit a specific field
2401  *
2402  * Needs to be used combined with GravityView_Edit_Entry::user_can_edit_field for maximum security!!
2403  *
2404  * @param [type] $field [description]
2405  * @return bool
2406  */
2407  private function check_user_cap_edit_field( $field ) {
2408 
2409  // If they can edit any entries (as defined in Gravity Forms), we're good.
2410  if( GVCommon::has_cap( array( 'gravityforms_edit_entries', 'gravityview_edit_others_entries' ) ) ) {
2411  return true;
2412  }
2413 
2414  $field_cap = isset( $field['allow_edit_cap'] ) ? $field['allow_edit_cap'] : false;
2415 
2416  if( $field_cap ) {
2417  return GVCommon::has_cap( $field['allow_edit_cap'] );
2418  }
2419 
2420  return false;
2421  }
2422 
2423 
2424  /**
2425  * Is the current nonce valid for editing the entry?
2426  * @return boolean
2427  */
2428  public function verify_nonce() {
2429 
2430  // Verify form submitted for editing single
2431  if( $this->is_edit_entry_submission() ) {
2432  $valid = wp_verify_nonce( $_POST[ self::$nonce_field ], self::$nonce_field );
2433  }
2434 
2435  // Verify
2436  else if( ! $this->is_edit_entry() ) {
2437  $valid = false;
2438  }
2439 
2440  else {
2441  $valid = wp_verify_nonce( $_GET['edit'], self::$nonce_key );
2442  }
2443 
2444  /**
2445  * @filter `gravityview/edit_entry/verify_nonce` Override Edit Entry nonce validation. Return true to declare nonce valid.
2446  * @since 1.13
2447  * @param int|boolean $valid False if invalid; 1 or 2 when nonce was generated
2448  * @param string $nonce_field Key used when validating submissions. Default: is_gv_edit_entry
2449  */
2450  $valid = apply_filters( 'gravityview/edit_entry/verify_nonce', $valid, self::$nonce_field );
2451 
2452  return $valid;
2453  }
2454 
2455 
2456  /**
2457  * Multiselect in GF 2.2 became a json_encoded value. Fix it.
2458  *
2459  * As a hack for now we'll implode it back.
2460  */
2462  if ( empty ( $field->storageType ) || $field->storageType != 'json' ) {
2463  return $field_value;
2464  }
2465 
2466  $maybe_json = @json_decode( $field_value, true );
2467 
2468  if ( $maybe_json ) {
2469  return implode( ',', $maybe_json );
2470  }
2471 
2472  return $field_value;
2473  }
2474 
2475 
2476 
2477 } //end class
get_configured_edit_fields( $form, $view_id)
Get the Edit Entry fields as configured in the View.
const GRAVITYVIEW_DIR
"GRAVITYVIEW_DIR" "./" The absolute path to the plugin directory, with trailing slash ...
Definition: gravityview.php:40
$labels
$entry
if(current_filter()==='gform_previous_button') if(current_filter()==='gform_next_button') $back_link
static media_handle_upload( $url, $post_id, $post_data=array())
Copied function from Gravity Forms plugin ::media_handle_upload since the method is private...
global $post
Definition: edit-entry.php:7
static getInstance( $passed_post=NULL)
edit_entry_form()
Display the Edit Entry form.
$fields_with_calculation
$image_meta
Definition: post_image.php:106
static getInstance( $passed_post=NULL)
Definition: class-data.php:120
fill_post_template( $template, $form, $entry, $do_shortcode=false)
Convert a field content template into prepared output.
if(! function_exists( 'gravityview_sanitize_html_class')) gravityview_strip_whitespace( $string)
Replace multiple newlines, tabs, and spaces with a single space.
load()
if(! isset( $gravityview)||empty( $gravityview->template)) $template
The entry loop for the list output.
update_calculation_fields()
$is_valid
filter_conditional_logic( $form)
Remove the conditional logic rules from the form button and the form fields, if needed.
is_edit_entry()
Is the current page an Edit Entry page?
static get_post_field_images( $form, $entry)
Given information provided in an entry, get array of media IDs.
$ary
Definition: post_image.php:24
render_edit_form()
Display the Edit Entry form in the original Gravity Forms format.
static check_user_cap_edit_entry( $entry, $view=0)
checks if user has permissions to edit a specific entry
static generate_notice( $notice, $class='', $cap='', $object_id=null)
Display updated/error notice.
process_save_process_files( $form_id)
Have GF handle file uploads.
$entries
gravityview_get_link( $href='', $anchor_text='', $atts=array())
Generate an HTML anchor tag with a list of supported attributes.
gravityview_get_entry( $entry_slug, $force_allow_ids=false, $check_entry_display=true, $view=null)
Return a single entry object.
save_field_value( $value='', $entry=array(), $field=null, $form=array(), $input_id='')
Make sure the fileuploads are not overwritten if no such request was done.
after_update()
Perform actions normally performed after updating a lead.
gravityview()
Definition: _stubs.php:26
If this file is called directly, abort.
form_prepare_for_save()
Set visibility to visible and convert field input key to string.
static $nonce_field
get( $key, $default=null)
Retrieve a setting.
maybe_print_message()
Display success or error message if the form has been submitted.
setup_vars()
When Edit entry view is requested setup the vars.
$show_next_button
static directory_link( $post_id=NULL, $add_query_args=true, $context=null)
Generate a URL to the Directory context.
Definition: class-api.php:392
unset_hidden_field_values()
Delete the value of fields hidden by conditional logic when the entry is edited.
gravityview_ob_include( $file_path, $object=NULL)
Get the contents of a file using include() and ob_start()
$view_id
gform_pre_validation( $form)
Add field keys that Gravity Forms expects.
update_post_image( $form, $field, $field_id, $value, $entry, $post_id)
Handle updating the Post Image field.
static $nonce_key
process_save( $gv_data)
Process edit entry form save.
print_scripts()
Force Gravity Forms to output scripts as if it were in the admin.
manage_conditional_logic( $has_conditional_logic, $form)
Disable the Gravity Forms conditional logic script and features on the Edit Entry screen...
$form_id
check_user_cap_edit_field( $field)
checks if user has permissions to edit a specific field
prevent_update_unapproved_meta( $value, $form, $entry)
Done once from self::preset_approval_fields.
$gv_field
Definition: time.php:11
__construct(GravityView_Edit_Entry $loader)
static get_associated_field( $gf_field)
Alias for get_instance()
user_can_edit_field( $field, $echo=false)
Check whether a field is editable by the current user, and optionally display an error message Gravi...
static by_id( $post_id)
Construct a instance from a post ID.
static get_nonce_key( $view_id, $form_id, $entry_id)
Return a well formatted nonce key according to GravityView Edit Entry protocol.
static $original_form
merge_field_properties( $field, $field_setting)
Override GF Form field properties with the ones defined on the View.
prevent_maybe_process_form()
Because we&#39;re mimicking being a front-end Gravity Forms form while using a Gravity Forms backend form...
static $file
get_field_value( $field)
Modify the value for the current field input.
modify_fileupload_settings( $plupload_init, $form_id, $instance)
Remove max_files validation (done on gravityforms.js) to avoid conflicts with GravityView Late valida...
static is_single_entry()
Verify if user requested a single entry view.
$field_id
Definition: time.php:17
static $original_entry
static $supports_save_and_continue
$is_paged_submitted
validate()
Process validation for a edit entry submission.
verify_nonce()
Is the current nonce valid for editing the entry?
get_entry()
TODO: This seems to be hacky...
const UNAPPROVED
render_form_buttons()
Display the Update/Cancel/Delete buttons for the Edit Entry form.
filter_modify_form_fields( $form, $ajax=false, $field_values='')
Modify the form fields that are shown when using GFFormDisplay::get_form()
static get( $array, $key, $default=null)
Grab a value from an array or an object or default.
is_edit_entry_submission()
Is the current page an Edit Entry page?
preset_approval_fields()
Leverage gravityview/approve_entries/update_unapproved_meta to prevent the missing/empty approval fie...
static get_database_version()
Make sure the method exists, regardless of GF version.
$form_after_validation
gv_empty( $value, $zero_is_empty=true, $allow_string_booleans=true)
Is the value empty?
$post_id
$view
init( $gv_data=null, $entry=null, $view=null, $request=null)
Load required files and trigger edit flow.
static has_cap( $caps='', $object_id=null, $user_id=null)
Alias of GravityView_Roles_Capabilities::has_cap()
maybe_update_post_fields( $form)
Loop through the fields being edited and if they include Post fields, update the Entry&#39;s post object...
$loader
user_can_edit_entry( $echo=false)
Check if the user can edit the entry.
$form
$show_update_button
verify_user_can_edit_post( $field_content='', $field, $value, $lead_id=0, $form_id)
When displaying a field, check if it&#39;s a Post Field, and if so, make sure the post exists and current...
custom_validation( $validation_results)
Make validation work for Edit Entry.
fix_multiselect_value_serialization( $field_value, $field, $_this)
Multiselect in GF 2.2 became a json_encoded value.
filter_admin_only_fields( $fields=array(), $edit_fields=null, $form=array(), $view_id=0)
Remove fields that shouldn&#39;t be visible based on the Gravity Forms adminOnly field property...
prevent_render_form()
Don&#39;t show any forms embedded on a page when GravityView is in Edit Entry mode.
$field_value
Definition: checkbox.php:24
$field
Definition: gquiz_grade.php:11
static _POST( $name, $default=null)
Grab a value from the _POST superglobal or default.
unselect_default_values( $form)
Checkboxes and other checkbox-based controls should not display default checks in edit mode...
$show_previous_button