芝麻web文件管理V1.00

编辑当前文件:/home/royashxg/www/wp-content/plugins/fluentform/app/Modules/Entries/Entries.php

<?php

namespace FluentForm\App\Modules\Entries;

use FluentForm\App\Helpers\Helper;
use FluentForm\App\Modules\Form\FormDataParser;
use FluentForm\App\Modules\Form\FormFieldsParser;
use FluentForm\App\Modules\Registerer\TranslationString;
use FluentForm\Framework\Helpers\ArrayHelper;

/**
 * @deprecated deprecated use FluentForm\App\Http\Controllers\SubmissionController
 */
class Entries extends EntryQuery
{
    /**
     * The form response model.
     *
     * @var \WpFluent\QueryBuilder\QueryBuilderHandler $responseMetaModel
     */
    protected $responseMetaModel;

/**
     * Entries constructor.
     *
     * @throws \Exception
     */
    public function __construct()
    {
        parent::__construct();

$this->responseMetaModel = wpFluent()->table('fluentform_submission_meta');
    }

public function getAllFormEntries()
    {
        $formId = intval($this->request->get('form_id'));

$limit = intval($this->request->get('per_page', 10));
        $page = intval($this->request->get('page', 1));
        $offset = ($page - 1) * $limit;

$search = sanitize_text_field($this->request->get('search'));
        $status = sanitize_text_field($this->request->get('entry_status'));

$query = wpFluent()->table('fluentform_submissions')
            ->select([
                'fluentform_submissions.id',
                'fluentform_submissions.form_id',
                'fluentform_submissions.status',
                'fluentform_submissions.created_at',
                'fluentform_submissions.browser',
                'fluentform_submissions.currency',
                'fluentform_submissions.total_paid',
                'fluentform_forms.title',
            ])
            ->join('fluentform_forms', 'fluentform_forms.id', '=', 'fluentform_submissions.form_id')
            ->orderBy('fluentform_submissions.id', 'DESC')
            ->limit($limit)
            ->offset($offset);

if ($formId) {
            $query->where('fluentform_submissions.form_id', $formId);
        }

if ($status) {
            $query->where('fluentform_submissions.status', $status);
        } else {
            $query->where('fluentform_submissions.status', '!=', 'trashed');
        }

$dateRange = $this->request->get('date_range');
        if ($dateRange) {
            $query->where('fluentform_submissions.created_at', '>=', $dateRange[0] . ' 00:00:01');
            $query->where('fluentform_submissions.created_at', '<=', $dateRange[1] . ' 23:59:59');
        }

if ($search) {
            $query->where('fluentform_submissions.response', 'LIKE', '%' . $search . '%');
            $query->orWhere('fluentform_forms.title', 'LIKE', '%' . $search . '%');
            $query->orWhere('fluentform_submissions.id', 'LIKE', '%' . $search . '%');
        }

$total = $query->count();
        $entries = $query->get();
        foreach ($entries as $entry) {
            $entry->entry_url = admin_url('admin.php?page=fluent_forms&route=entries&form_id=' . $entry->form_id . '#/entries/' . $entry->id);
            $entry->human_date = human_time_diff(strtotime($entry->created_at), strtotime(current_time('mysql')));
        }
        wp_send_json_success([
            'entries'         => $entries,
            'total'           => $total,
            'last_page'       => ceil($total / $limit),
            'available_forms' => $this->getAvailableForms(),
        ]);
    }

public function getEntriesReport()
    {
        $from = date('Y-m-d H:i:s', strtotime('-30 days'));
        $to = date('Y-m-d H:i:s', strtotime('+1 days'));

$ranges = $this->request->get('date_range', []);

if (!empty($ranges[0])) {
            $from = $ranges[0];
        }

if (!empty($ranges[1])) {
            $time = strtotime($ranges[1]) + 24 * 60 * 60;
            $to = date('Y-m-d H:i:s', $time);
        }

$period = new \DatePeriod(new \DateTime($from), new \DateInterval('P1D'), new \DateTime($to));

$range = [];

foreach ($period as $date) {
            $range[$date->format('Y-m-d')] = 0;
        }

$itemsQuery = wpFluent()->table('fluentform_submissions')->select([
            wpFluent()->raw('DATE(created_at) AS date'),
            wpFluent()->raw('COUNT(id) AS count'),
        ])
            ->whereBetween('created_at', [$from, $to])
            ->groupBy('date')
            ->orderBy('date', 'ASC');

$formId = $this->request->get('form_id');

if ($formId) {
            $itemsQuery = $itemsQuery->where('form_id', $formId);
        }

$items = $itemsQuery->get();
        foreach ($items as $item) {
            $range[$item->date] = $item->count; //Filling value in the array
        }

wp_send_json_success([
            'stats' => $range,
        ]);
    }

public function renderEntries($form_id)
    {
        wp_enqueue_script('fluentform_form_entries');

$forms = wpFluent()
            ->table('fluentform_forms')
            ->select(['id', 'title'])
            ->orderBy('id', 'DESC')
            ->get();

$emailNotifications = wpFluent()
            ->table('fluentform_form_meta')
            ->where('form_id', $form_id)
            ->where('meta_key', 'notifications')
            ->get();

$formattedNotification = [];

foreach ($emailNotifications as $notification) {
            $value = \json_decode($notification->value, true);
            $formattedNotification[] = [
                'id'   => $notification->id,
                'name' => ArrayHelper::get($value, 'name'),
            ];
        }

$form = wpFluent()->table('fluentform_forms')->find($form_id);
        $submissionShortcodes = \FluentForm\App\Services\FormBuilder\EditorShortCode::getSubmissionShortcodes();
        $submissionShortcodes['shortcodes']['{submission.ip}'] = __('Submitter IP', 'fluentform');
        if ($form->has_payment) {
            $submissionShortcodes['shortcodes']['{payment.payment_status}'] = __('Payment Status','fluentform');
            $submissionShortcodes['shortcodes']['{payment.payment_total}'] = __('Payment Total','fluentform');
        }
        $formInputs = FormFieldsParser::getEntryInputs($form, ['admin_label', 'raw']);
        $inputLabels = FormFieldsParser::getAdminLabels($form, $formInputs);
        $data = [
            'all_forms_url'       => admin_url('admin.php?page=fluent_forms'),
            'forms'               => $forms,
            'form_id'             => $form->id,
            'enabled_auto_delete' => Helper::isEntryAutoDeleteEnabled($form_id),
            'current_form_title'  => $form->title,
            'entry_statuses'      => Helper::getEntryStatuses($form_id),
            'entries_url_base'    => admin_url('admin.php?page=fluent_forms&route=entries&form_id='),
            'no_found_text'       => __('Sorry! No entries found. All your entries will be shown here once you start getting form submissions',
                'fluentform'),
            'has_pro'             => defined('FLUENTFORMPRO'),
            'printStyles'         => [fluentformMix('css/settings_global.css')],
            'email_notifications' => $formattedNotification,
            'available_countries' => getFluentFormCountryList(),
            'upgrade_url'         => fluentform_upgrade_url(),
            'form_entries_str'    => TranslationString::getEntriesI18n(),
            'editor_shortcodes'   => $submissionShortcodes['shortcodes'],
            'input_labels'        => $inputLabels,
            'update_status'       => isset($_REQUEST['update_status']) ? sanitize_text_field($_REQUEST['update_status']) : '',
        ];
    
        $data = apply_filters_deprecated(
            'fluent_form_entries_vars',
            [
                $data,
                $form
            ],
            FLUENTFORM_FRAMEWORK_UPGRADE,
            'fluentform/entries_vars',
            'Use fluentform/entries_vars instead of fluent_form_entries_vars.'
        );

$fluentFormEntriesVars = apply_filters('fluentform/entries_vars', $data, $form);

wp_localize_script(
            'fluentform_form_entries',
            'fluent_form_entries_vars',
            $fluentFormEntriesVars
        );

wpFluentForm('view')->render('admin.form.entries', [
            'form_id' => $form_id,
            'has_pdf' => defined('FLUENTFORM_PDF_VERSION') ? 'true' : 'false',
        ]);
    }

public function getEntriesGroup()
    {
        $formId = intval($this->request->get('form_id'));
        $counts = $this->groupCount($formId);
        wp_send_json_success([
            'counts' => $counts,
        ], 200);
    }

public function _getEntries(
        $formId,
        $currentPage,
        $perPage,
        $sortBy,
        $entryType,
        $search,
        $wheres = []
    ) {
        $this->formId = $formId;
        $this->per_page = $perPage;
        $this->sort_by = $sortBy;
        $this->page_number = $currentPage;
        $this->search = $search;
        $this->wheres = $wheres;

if ('favorite' == $entryType) {
            $this->is_favourite = true;
        } elseif ('all' != $entryType && $entryType) {
            $this->status = $entryType;
        }

$dateRange = $this->request->get('date_range');
        if ($dateRange) {
            $this->startDate = $dateRange[0];
            $this->endDate = $dateRange[1];
        }

$form = $this->formModel->find($formId);
        $formMeta = $this->getFormInputsAndLabels($form);
        $formLabels = $formMeta['labels'];
    
        $formLabels = apply_filters_deprecated(
            'fluentfoform_entry_lists_labels',
            [
                $formLabels,
                $form
            ],
            FLUENTFORM_FRAMEWORK_UPGRADE,
            'fluentform/entry_lists_labels',
            'Use fluentform/entry_lists_labels instead of fluentfoform_entry_lists_labels.'
        );

$formLabels = apply_filters('fluentform/entry_lists_labels', $formLabels, $form);
        $submissions = $this->getResponses();
        $submissions['data'] = FormDataParser::parseFormEntries($submissions['data'], $form);

return compact('submissions', 'formLabels');
    }

public function getEntries()
    {
        if (!defined('FLUENTFORM_RENDERING_ENTRIES')) {
            define('FLUENTFORM_RENDERING_ENTRIES', true);
        }

$wheres = [];

if ($paymentStatuses = $this->request->get('payment_statuses')) {
            if (is_array($paymentStatuses)) {
                $wheres[] = ['payment_status', $paymentStatuses];
            }
        }

$entries = $this->_getEntries(
            intval($this->request->get('form_id')),
            intval($this->request->get('current_page', 1)),
            intval($this->request->get('per_page', 10)),
            Helper::sanitizeOrderValue($this->request->get('sort_by', 'DESC')),
            sanitize_text_field($this->request->get('entry_type', 'all')),
            sanitize_text_field($this->request->get('search')),
            $wheres
        );

$entriesFormLabels = $entries['formLabels'];
        $formId = $this->request->get('form_id');
    
        $entriesFormLabels = apply_filters_deprecated(
            'fluentform_all_entry_labels',
            [
                $entriesFormLabels,
                $formId
            ],
            FLUENTFORM_FRAMEWORK_UPGRADE,
            'fluentform/all_entry_labels',
            'Use fluentform/all_entry_labels instead of fluentform_all_entry_labels.'
        );

$labels = apply_filters('fluentform/all_entry_labels', $entriesFormLabels, $formId);

$form = $this->formModel->find($this->request->get('form_id'));

if ($form->has_payment) {
            $entriesFormLabels = apply_filters_deprecated(
                'fluentform_all_entry_labels_with_payment',
                [
                    $entriesFormLabels,
                    false,
                    $form
                ],
                FLUENTFORM_FRAMEWORK_UPGRADE,
                'fluentform/all_entry_labels_with_payment',
                'Use fluentform/all_entry_labels_with_payment instead of fluentform_all_entry_labels_with_payment.'
            );

$labels = apply_filters('fluentform/all_entry_labels_with_payment', $entriesFormLabels, false, $form);
        }
        $formId = $this->request->get('form_id');
        $visible_columns = Helper::getFormMeta($formId, '_visible_columns', null);
        $columns_order = Helper::getFormMeta($formId, '_columns_order', null);
    
        $entries['submissions'] = apply_filters_deprecated(
            'fluentform_all_entries',
            [
                $entries['submissions']
            ],
            FLUENTFORM_FRAMEWORK_UPGRADE,
            'fluentform/all_entries',
            'Use fluentform/all_entries instead of fluentform_all_entries.'
        );

wp_send_json_success([
            'submissions'     => apply_filters('fluentform/all_entries', $entries['submissions']),
            'labels'          => $labels,
            'visible_columns' => $visible_columns,
            'columns_order'   => $columns_order,
        ], 200);
    }

public function _getEntry()
    {
        $this->formId = intval($this->request->get('form_id'));

$entryId = intval($this->request->get('entry_id'));

$entry_type = sanitize_key($this->request->get('entry_type', 'all'));

if ('favorite' === $entry_type) {
            $this->is_favourite = true;
        } elseif ('all' !== $entry_type) {
            $this->status = $entry_type;
        }

$this->sort_by = Helper::sanitizeOrderValue($this->request->get('sort_by', 'ASC'));

$this->search = sanitize_text_field($this->request->get('search'));

$submission = $this->getResponse($entryId);

if (!$submission) {
            wp_send_json_error([
                'message' => 'No Entry found.',
            ], 422);
        }

$form = $this->formModel->find($this->formId);

$autoRead = apply_filters_deprecated(
            'fluentform_auto_read',
            [
                true,
                $form
            ],
            FLUENTFORM_FRAMEWORK_UPGRADE,
            'fluentform/auto_read',
            'Use fluentform/auto_read instead of fluentform_auto_read.'
        );

if ('unread' == $submission->status && apply_filters('fluentform/auto_read', $autoRead, $form)) {
            wpFluent()->table('fluentform_submissions')
                ->where('id', $entryId)
                ->update([
                    'status' => 'read',
                ]);

$submission->status = 'read';
        }

$formMeta = $this->getFormInputsAndLabels($form);

$submission = FormDataParser::parseFormEntry($submission, $form, $formMeta['inputs'], true);

if ($submission->user_id) {
            $user = get_user_by('ID', $submission->user_id);
            $user_data = [
                'name'      => $user->display_name,
                'email'     => $user->user_email,
                'ID'        => $user->ID,
                'permalink' => get_edit_user_link($user->ID),
            ];
            $submission->user = $user_data;
        }
    
        $submission = apply_filters_deprecated(
            'fluentform_single_response_data',
            [
                $submission,
                $this->formId
            ],
            FLUENTFORM_FRAMEWORK_UPGRADE,
            'fluentform/find_submission',
            'Use fluentform/find_submission instead of fluentform_single_response_data.'
        );

$submission = apply_filters('fluentform/find_submission', $submission, $this->formId);
    
        $fields = $formMeta['inputs'];
        $fields = apply_filters_deprecated(
            'fluentform_single_response_input_fields',
            [
                $fields,
                $this->formId
            ],
            FLUENTFORM_FRAMEWORK_UPGRADE,
            'fluentform/single_response_input_fields',
            'Use fluentform/single_response_input_fields instead of fluentform_single_response_input_fields.'
        );

$fields = apply_filters(
            'fluentform/single_response_input_fields',
            $fields,
            $this->formId
        );
        $labels = $formMeta['labels'];
        $labels = apply_filters_deprecated(
            'fluentform_single_response_input_labels',
            [
                $labels,
                $this->formId
            ],
            FLUENTFORM_FRAMEWORK_UPGRADE,
            'fluentform/single_response_input_labels',
            'Use fluentform/single_response_input_labels instead of fluentform_single_response_input_labels.'
        );

$labels = apply_filters(
            'fluentform/single_response_input_labels',
            $labels,
            $this->formId
        );

$order_data = false;

if ($submission->payment_status || $submission->payment_total || 'subscription' === $submission->payment_type) {
            $order_data = apply_filters_deprecated(
                'fluentform_submission_order_data',
                [
                    $order_data,
                    $submission,
                    $form
                ],
                FLUENTFORM_FRAMEWORK_UPGRADE,
                'fluentform/submission_order_data',
                'Use fluentform/submission_order_data instead of fluentform_submission_order_data.'
            );

$order_data = apply_filters(
                'fluentform/submission_order_data',
                $order_data,
                $submission,
                $form
            );
    
            $labels = apply_filters_deprecated(
                'fluentform_submission_entry_labels_with_payment',
                [
                    $labels,
                    $submission,
                    $form
                ],
                FLUENTFORM_FRAMEWORK_UPGRADE,
                'fluentform/submission_entry_labels_with_payment',
                'Use fluentform/submission_entry_labels_with_payment instead of fluentform_submission_entry_labels_with_payment.'
            );

$labels = apply_filters(
                'fluentform/submission_entry_labels_with_payment',
                $labels,
                $submission,
                $form
            );
        }

$nextSubmissionId = $this->getNextResponse($entryId);

$previousSubmissionId = $this->getPrevResponse($entryId);

return [
            'submission' => $submission,
            'next'       => $nextSubmissionId,
            'prev'       => $previousSubmissionId,
            'labels'     => $labels,
            'fields'     => $fields,
            'order_data' => $order_data,
        ];
    }

public function getEntry()
    {
        if (!defined('FLUENTFORM_RENDERING_ENTRY')) {
            define('FLUENTFORM_RENDERING_ENTRY', true);
        }

$entryData = $this->_getEntry();

$widgets = apply_filters_deprecated(
            'fluentform_single_entry_widgets',
            [
                [],
                $entryData
            ],
            FLUENTFORM_FRAMEWORK_UPGRADE,
            'fluentform/single_entry_widgets',
            'Use fluentform/single_entry_widgets instead of fluentform_single_entry_widgets.'
        );
        $entryData['widgets'] = apply_filters('fluentform/single_entry_widgets', $widgets, $entryData);

$cards = apply_filters_deprecated(
            'fluentform_single_entry_cards',
            [
                [],
                $entryData
            ],
            FLUENTFORM_FRAMEWORK_UPGRADE,
            'fluentform/single_entry_cards',
            'Use fluentform/single_entry_cards instead of fluentform_single_entry_cards.'
        );
        $entryData['extraCards'] = apply_filters('fluentform/single_entry_cards', $cards, $entryData);

wp_send_json_success($entryData, 200);
    }

/**
     * @param       $form
     * @param array $with
     *
     * @return array
     *
     * @todo: Implement Caching mechanism so we don't have to parse these things for every request
     */
    public function getFormInputsAndLabels($form, $with = ['admin_label', 'raw'])
    {
        $formInputs = FormFieldsParser::getEntryInputs($form, $with);
        $inputLabels = FormFieldsParser::getAdminLabels($form, $formInputs);
        return [
            'inputs' => $formInputs,
            'labels' => $inputLabels,
        ];
    }

public function getNotes()
    {
        $formId = intval($this->request->get('form_id'));
        $entry_id = intval($this->request->get('entry_id'));
        $apiLog = 'yes' == sanitize_text_field($this->request->get('api_log'));

$metaKeys = ['_notes'];

if ($apiLog) {
            $metaKeys[] = 'api_log';
        }

$notes = $this->responseMetaModel
            ->where('form_id', $formId)
            ->where('response_id', $entry_id)
            ->whereIn('meta_key', $metaKeys)
            ->orderBy('id', 'DESC')
            ->get();

foreach ($notes as $note) {
            if ($note->user_id) {
                $note->pemalink = get_edit_user_link($note->user_id);
                $user = get_user_by('ID', $note->user_id);
                if ($user) {
                    $note->created_by = $user->display_name;
                } else {
                    $note->created_by = __('Fluent Forms Bot', 'fluentform');
                }
            } else {
                $note->pemalink = false;
            }
        }
    
        $notes = apply_filters_deprecated(
            'fluentform_entry_notes',
            [
                $notes,
                $entry_id,
                $formId
            ],
            FLUENTFORM_FRAMEWORK_UPGRADE,
            'fluentform/entry_notes',
            'Use fluentform/entry_notes instead of fluentform_entry_notes.'
        );

$notes = apply_filters('fluentform/entry_notes', $notes, $entry_id, $formId);

wp_send_json_success([
            'notes' => $notes,
        ], 200);
    }

public function addNote()
    {
        $entryId = intval($this->request->get('entry_id'));
        $formId = intval($this->request->get('form_id'));
        $note = $this->request->get('note');
        $note_content = sanitize_textarea_field($note['content']);
        $note_status = sanitize_text_field($note['status']);
        $user = get_user_by('ID', get_current_user_id());

$response_note = [
            'response_id' => $entryId,
            'form_id'     => $formId,
            'meta_key'    => '_notes',
            'value'       => $note_content,
            'status'      => $note_status,
            'user_id'     => $user->ID,
            'name'        => $user->display_name,
            'created_at'  => current_time('mysql'),
            'updated_at'  => current_time('mysql'),
        ];
    
        $response_note = apply_filters_deprecated(
            'fluentform_add_response_note',
            [
                $response_note
            ],
            FLUENTFORM_FRAMEWORK_UPGRADE,
            'fluentform/add_response_note',
            'Use fluentform/add_response_note instead of fluentform_add_response_note.'
        );

$response_note = apply_filters('fluentform/add_response_note', $response_note);

$insertId = $this->responseMetaModel->insertGetId($response_note);

$added_note = $this->responseMetaModel->find($insertId);

do_action_deprecated(
            'fluentform_new_response_note_added',
            [
                $insertId,
                $added_note
            ],
            FLUENTFORM_FRAMEWORK_UPGRADE,
            'fluentform/new_response_note_added',
            'Use fluentform/new_response_note_added instead of fluentform_new_response_note_added.'
        );

do_action('fluentform/new_response_note_added', $insertId, $added_note);

wp_send_json_success([
            'message'   => __('Note has been successfully added', 'fluentform'),
            'note'      => $added_note,
            'insert_id' => $insertId,
        ], 200);
    }

public function changeEntryStatus()
    {
        $formId = intval($this->request->get('form_id'));
        $entryId = intval($this->request->get('entry_id'));
        $newStatus = sanitize_text_field($this->request->get('status'));

$this->responseModel
            ->where('form_id', $formId)
            ->where('id', $entryId)
            ->update(['status' => $newStatus]);

wp_send_json_success([
            'message' => __('Item has been marked as ' . $newStatus, 'fluentform'),
            'status'  => $newStatus,
        ], 200);
    }

public function updateEntryDiffs($entryId, $formId, $formData)
    {
        wpFluent()->table('fluentform_entry_details')
            ->where('submission_id', $entryId)
            ->where('form_id', $formId)
            ->whereIn('field_name', array_keys($formData))
            ->delete();

$entryItems = [];
        foreach ($formData as $dataKey => $dataValue) {
            if (!$dataValue) {
                continue;
            }

if (is_array($dataValue)) {
                foreach ($dataValue as $subKey => $subValue) {
                    $entryItems[] = [
                        'form_id'        => $formId,
                        'submission_id'  => $entryId,
                        'field_name'     => $dataKey,
                        'sub_field_name' => $subKey,
                        'field_value'    => maybe_serialize($subValue),
                    ];
                }
            } else {
                $entryItems[] = [
                    'form_id'        => $formId,
                    'submission_id'  => $entryId,
                    'field_name'     => $dataKey,
                    'sub_field_name' => '',
                    'field_value'    => $dataValue,
                ];
            }
        }

foreach ($entryItems as $entryItem) {
            wpFluent()->table('fluentform_entry_details')->insert($entryItem);
        }

return true;
    }

public function getUsers()
    {
        // if (!current_user_can('list_users')) {
        //     wp_send_json_error([
        //         'message' => __('Sorry, You do not have permission to list users', 'fluentform')
        //     ]);
        // }

$search = sanitize_text_field($this->request->get('search'));

$users = get_users([
            'search' => "*{$search}*",
            'number' => 50,
        ]);

$formattedUsers = [];

foreach ($users as $user) {
            $formattedUsers[] = [
                'ID'    => $user->ID,
                'label' => $user->display_name . ' - ' . $user->user_email,
            ];
        }

wp_send_json_success([
            'users' => $formattedUsers,
        ]);
    }

public function changeEntryUser()
    {
        $userId = intval($this->request->get('user_id'));
        $submissionId = intval($this->request->get('submission_id'));

if (!$userId || !$submissionId) {
            wp_send_json_error([
                'message' => __('Submission ID and User ID is required', 'fluentform'),
            ], 423);
        }

$submission = fluentFormApi('submissions')->find($submissionId);

$user = get_user_by('ID', $userId);

if (!$submission || $submission->user_id == $userId || !$user) {
            wp_send_json_error([
                'message' => __('Invalid Request', 'fluentform'),
            ], 423);
        }

wpFluent()->table('fluentform_submissions')
            ->where('id', $submission->id)
            ->update([
                'user_id'    => $userId,
                'updated_at' => current_time('mysql'),
            ]);

if (defined('FLUENTFORMPRO')) {
            // let's update the corresponding user IDs for transactions and
            wpFluent()->table('fluentform_transactions')
                ->where('submission_id', $submission->id)
                ->update([
                    'user_id'    => $userId,
                    'updated_at' => current_time('mysql'),
                ]);
        }

$logData = [
            'parent_source_id' => $submission->form_id,
            'source_type'      => 'submission_item',
            'source_id'        => $submission->id,
            'component'        => 'General',
            'status'           => 'info',
            'title'            => 'Associate user has been changed from ' . $submission->user_id . ' to ' . $userId,
        ];

do_action('fluentform/log_data', $logData);

do_action_deprecated(
            'fluentform_submission_user_changed',
            [
                $submission,
                $user
            ],
            FLUENTFORM_FRAMEWORK_UPGRADE,
            'fluentform/submission_user_changed',
            'Use fluentform/submission_user_changed instead of fluentform_submission_user_changed.'
        );

do_action('fluentform/submission_user_changed', $submission, $user);

wp_send_json_success([
            'message' => __('Selected user has been successfully assigned to this submission', 'fluentform'),
            'user'    => [
                'name'      => $user->display_name,
                'email'     => $user->user_email,
                'ID'        => $user->ID,
                'permalink' => get_edit_user_link($user->ID),
            ],
            'user_id' => $userId,
        ]);
    }

public function getAvailableForms()
    {
        $forms = wpFluent()->table('fluentform_forms')
            ->select(['id', 'title'])
            ->orderBy('id', 'DESC')
            ->get();

$formattedForms = [];
        foreach ($forms as $form) {
            $formattedForms[] = [
                'id'    => $form->id,
                'title' => $form->title,
            ];
        }

return $formattedForms;
    }
}