# e2pdf/1.02.02/classes/extension/e2pdf-formidable.php

E2Pdf – Export Pdf Tool for WordPress, version 1.02.02. 2,357 lines.

- Page: https://pluginprobe.com/plugins/e2pdf/1.02.02/code/classes/extension/e2pdf-formidable.php
- Raw: https://pluginprobe.com/plugins/e2pdf/1.02.02/raw/classes/extension/e2pdf-formidable.php
- Modified: 2018-12-07T12:07:02+00:00

Line numbers below start at 1. Link to a line or a range by appending a fragment to the
page URL, for example `https://pluginprobe.com/plugins/e2pdf/1.02.02/code/classes/extension/e2pdf-formidable.php#L10-L20`.

```php
<?php

/**
 * E2pdf Formidable Extension
 * 
 * @copyright  Copyright 2017 https://e2pdf.com
 * @license    GPL v2
 * @version    1
 * @link       https://e2pdf.com
 * @since      0.00.01
 */
if (!defined('ABSPATH')) {
    die('Access denied.');
}

class Extension_E2pdf_Formidable extends Model_E2pdf_Model {

    private $options;

    function __construct() {
        parent::__construct();
    }

    /**
     * Get info about extension
     * 
     * @return array() - Extension key and name
     */
    public function info() {
        return array(
            'formidable' => __('Formidable', 'e2pdf')
        );
    }

    /**
     * Check if export item function available
     * 
     * @return bool - Item export available/not available
     */
    public function export() {
        return true;
    }

    /**
     * Check if needed plugin active
     * 
     * @return bool - Activated/Not Activated plugin
     */
    public function active() {

        if (!function_exists('is_plugin_active')) {
            include_once( ABSPATH . 'wp-admin/includes/plugin.php' );
        }

        if (is_plugin_active('formidable/formidable.php')) {
            return true;
        }
        return false;
    }

    /**
     * Set option
     * 
     * @param string $key - Key of option
     * @param string $value - Value of option
     * 
     * @return bool - Status of setting option
     */
    public function set($key, $value) {

        if (!isset($this->options)) {
            $this->options = new stdClass();
        }

        $this->options->$key = $value;
        return true;
    }

    /**
     * Get option by key
     * 
     * @param string $key - Key to get assigned option value
     * 
     * @return mixed
     */
    public function get($key) {

        if (isset($this->options->$key)) {
            $value = $this->options->$key;
            return $value;
        } else {
            return false;
        }
    }

    /**
     * Get items to work with
     * 
     * @return array() - List of available items
     */
    public function get_items() {

        $content = array();

        if (class_exists('FrmForm')) {
            $where = array(
                'is_template' => 0,
                'status' => 'published'
            );

            $forms = FrmForm::getAll($where, 'name');
            if ($forms) {
                foreach ($forms as $key => $value) {
                    $content[] = array(
                        'key' => $value->id,
                        'value' => $value->name
                    );
                }
            }
        }

        return $content;
    }

    /**
     * Get entries for export
     * 
     * @param int $item - Form ID
     * @param string $name - Entries names
     * 
     * @return array() - Entries list
     */
    public function get_datasets($item = false, $name = false) {

        $item = (int) $item;
        $datasets = array();

        if (class_exists('FrmEntry') && $item) {
            $where = array(
                'it.form_id' => $item
            );

            $datasets_tmp = FrmEntry::getAll($where, ' ORDER BY id DESC');

            if ($datasets_tmp) {
                foreach ($datasets_tmp as $key => $dataset) {
                    $this->set('item', $item);
                    $this->set('dataset', $dataset->id);

                    $dataset_title = $this->render($name);
                    if (!$dataset_title) {
                        $dataset_title = $dataset->item_key;
                    }
                    $datasets[] = array(
                        'key' => $dataset->id,
                        'value' => $dataset_title
                    );
                }
            }
        }


        return $datasets;
    }

    /**
     * Get dataset
     * 
     * @param int $dataset - Dataset ID
     * 
     * @return object - Dataset
     */
    public function get_dataset($dataset = false) {

        $dataset = (int) $dataset;

        if (!$dataset) {
            return false;
        }

        $data = new stdClass();
        $data->url = $this->helper->get_url(array('page' => 'formidable-entries', 'frm_action' => 'show', 'id' => $dataset));

        return $data;
    }

    /**
     * Get item
     * 
     * @param int $item - Item ID
     * 
     * @return object - Item
     */
    public function get_item($item = false) {

        $item = (int) $item;
        $form = new stdClass();

        $formidable_form = false;
        if (class_exists('FrmForm')) {
            $formidable_form = FrmForm::getOne($item);
        }

        if ($formidable_form) {
            $form->url = $this->helper->get_url(array('page' => 'formidable', 'frm_action' => 'edit', 'id' => $item));
            $form->name = $formidable_form->name;
        } else {
            $form->url = 'javascript:void(0);';
            $form->name = '';
        }
        return $form;
    }

    /**
     * Render value according to content
     * 
     * @param string $value - Content
     * @param string $type - Type of rendering value
     * @param array $field - Field details
     * 
     * @return string - Fully rendered value
     */
    public function render($value, $type = false, $field = array()) {

        $value = $this->render_shortcodes($value, $type, $field);
        $value = $this->strip_shortcodes($value);

        if ($type === 'value' && isset($field['type']) && $field['type'] === 'e2pdf-checkbox' && isset($field['properties']['option'])) {
            $option = $this->render($field['properties']['option']);
            $options = explode(', ', $value);
            $option_options = explode(', ', $option);
            if (is_array($options) && is_array($option_options) && !array_diff($option_options, $options)) {
                return $option;
            } else {
                return "";
            }
        }

        if ($type === 'value') {
            $value = str_replace("&#91;", "[", $value);
        }

        return $value;
    }

    /**
     * Load actions for this extension
     */
    public function load_actions() {
        add_action('frm_notification', array($this, 'action_frm_notification'), 30, 3);
        add_action('e2pdf_model_template_fill_pre', array($this, 'action_e2pdf_model_template_fill_pre'), 10, 2);
        add_action('e2pdf_model_template_fill_after', array($this, 'action_e2pdf_model_template_fill_after'), 10, 2);
    }

    /**
     * Load filters for this extension
     */
    public function load_filters() {
        add_filter('frm_content', array($this, 'filter_frm_content'), 30, 3);
        add_filter('frm_notification_attachment', array($this, 'filter_frm_notification_attachment'), 30, 3);
        add_filter('e2pdf_model_options_get_options_options', array($this, 'filter_e2pdf_model_options_get_options_options'), 10, 1);
        add_filter('e2pdf_controller_templates_backup_options', array($this, 'filter_e2pdf_controller_templates_backup_options'), 10, 3);

        add_filter('e2pdf_controller_templates_backup_pages', array($this, 'filter_e2pdf_controller_templates_backup_pages'), 10, 4);
        add_filter('e2pdf_controller_templates_backup_dataset_title', array($this, 'filter_e2pdf_controller_templates_backup_replace_shortcodes'), 10, 4);
        add_filter('e2pdf_controller_templates_backup_button_title', array($this, 'filter_e2pdf_controller_templates_backup_replace_shortcodes'), 10, 4);
        add_filter('e2pdf_controller_templates_backup_name', array($this, 'filter_e2pdf_controller_templates_backup_replace_shortcodes'), 10, 4);
        add_filter('e2pdf_controller_templates_backup_password', array($this, 'filter_e2pdf_controller_templates_backup_replace_shortcodes'), 10, 4);

        add_filter('e2pdf_controller_templates_import_pages', array($this, 'filter_e2pdf_controller_templates_import_pages'), 10, 5);
        add_filter('e2pdf_controller_templates_import_dataset_title', array($this, 'filter_e2pdf_controller_templates_import_replace_shortcodes'), 10, 5);
        add_filter('e2pdf_controller_templates_import_button_title', array($this, 'filter_e2pdf_controller_templates_import_replace_shortcodes'), 10, 5);
        add_filter('e2pdf_controller_templates_import_name', array($this, 'filter_e2pdf_controller_templates_import_replace_shortcodes'), 10, 5);
        add_filter('e2pdf_controller_templates_import_password', array($this, 'filter_e2pdf_controller_templates_import_replace_shortcodes'), 10, 5);
    }

    /**
     * Render shortcodes which available in this extension
     * 
     * @param string $value - Content
     * @param string $type - Type of rendering value
     * @param array $field - Field details
     * 
     * @return string - Value with rendered shortcodes
     */
    public function render_shortcodes($value, $type = false, $field = array()) {

        $dataset = $this->get('dataset');
        $item = $this->get('item');

        $form = false;
        $entry = false;
        $maybe_checkbox_separated = false;

        if ($this->verify()) {

            $form = FrmForm::getOne($item);
            $entry = FrmEntry::getOne($dataset);

            if (false !== strpos($value, '[')) {

                // Start render Separatable fields shortcode
                if (class_exists('FrmProEntry')) {
                    $shortcode_tags = array();
                    preg_match_all('@\[([^<>&/\[\]\x00-\x20=]++)@', $value, $matches);
                    $tagnames = array_intersect($shortcode_tags, $matches[1]);

                    foreach ($matches[1] as $key => $shortcode) {
                        if (strpos($shortcode, ':') !== false) {
                            $shortcode_tags[] = $shortcode;
                        }
                    }

                    $tagnames = array_intersect($shortcode_tags, $matches[1]);
                    if (!empty($tagnames)) {
                        $pattern = get_shortcode_regex($tagnames);
                        preg_match_all("/$pattern/", $value, $shortcodes);
                        foreach ($shortcodes[0] as $key => $shortcode_value) {
                            $shortcode = array();
                            $shortcode[1] = $shortcodes[1][$key];
                            $shortcode[2] = $shortcodes[2][$key];
                            $shortcode[3] = $shortcodes[3][$key];
                            $shortcode[4] = $shortcodes[4][$key];
                            $shortcode[5] = $shortcodes[5][$key];
                            $shortcode[6] = $shortcodes[6][$key];

                            $shortcode_details = explode(":", $shortcode[2]);

                            $field_id = $shortcode_details['0'];
                            $child_id = $shortcode_details['1'];
                            $child_entry = 0;

                            $child_field = false;
                            $child_form = false;

                            if (class_exists("FrmField")) {
                                $child_field = FrmField::getOne($field_id);
                                if ($child_field) {
                                    $child_form = $child_field->form_id;
                                }
                            }

                            $childs = FrmProEntry::get_sub_entries($dataset, true);
                            $child_entries = array();

                            if ($childs && $child_form) {
                                foreach ($childs as $child) {
                                    if ($child->form_id == $child_form) {
                                        $child_entries[] = $child->id;
                                    }
                                }
                            }

                            $new_shortcode = "";

                            if (!empty($child_entries) && count($child_entries) >= $child_id) {
                                $start = 1;
                                foreach ($child_entries as $key => $sub_entry) {
                                    if ($start == $child_id) {
                                        $child_entry = $sub_entry;
                                        break;
                                    }
                                    $start++;
                                }

                                $shortcode[2] = "frm-field-value field_id={$field_id} entry={$child_entry}";
                                $new_shortcode = "[" . $shortcode[2] . $shortcode[3] . "]";
                            }

                            $maybe_checkbox_separated = true;
                            $value = str_replace($shortcode_value, $new_shortcode, $value);
                        }
                    }
                }
                // End render Separatable fields shortcode

                $shortcode_tags = array(
                    'e2pdf-format-number',
                    'e2pdf-format-date',
                    'e2pdf-format-output',
                );

                preg_match_all('@\[([^<>&/\[\]\x00-\x20=]++)@', $value, $matches);
                $tagnames = array_intersect($shortcode_tags, $matches[1]);

                if (!empty($tagnames)) {

                    $pattern = get_shortcode_regex($tagnames);
                    preg_match_all("/$pattern/", $value, $shortcodes);
                    foreach ($shortcodes[0] as $key => $shortcode_value) {
                        $shortcode = array();
                        $shortcode[1] = $shortcodes[1][$key];
                        $shortcode[2] = $shortcodes[2][$key];
                        $shortcode[3] = $shortcodes[3][$key];
                        $shortcode[4] = $shortcodes[4][$key];
                        $shortcode[5] = $shortcodes[5][$key];
                        $shortcode[6] = $shortcodes[6][$key];

                        if (isset($shortcode['5'])) {
                            $sub_value = $this->strip_shortcodes(apply_filters('frm_content', $shortcode['5'], $form, $entry));
                            $value = str_replace($shortcode_value, "[" . $shortcode['2'] . $shortcode['3'] . "]" . $sub_value . "[/" . $shortcode['2'] . "]", $value);
                        }
                    }
                }
            }


            /*
             * Checkboxes separatable fix filter add
             * @since 0.01.43
             */
            if ($maybe_checkbox_separated) {
                add_filter('frm_display_value_custom', array($this, 'filter_frm_display_value_custom'), 0, 3);
            }

            $value = do_shortcode($value);

            /*
             * Checkboxes separatable fix filter remove
             * @since 0.01.43
             */
            if ($maybe_checkbox_separated) {
                remove_filter('frm_display_value_custom', array($this, 'filter_frm_display_value_custom'), 0);
            }

            $value = apply_filters('frm_content', $value, $form, $entry);

            if (isset($field['type']) && ($field['type'] === 'e2pdf-image' || $field['type'] === 'e2pdf-signature')) {
                $esig = isset($field['properties']['esig']) && $field['properties']['esig'] ? true : false;
                if ($esig) {
                    //process e-signature
                    $value = "";
                } else {
                    preg_match('/src="([^"]*)"/', $value, $matches);

                    if (isset($matches[1])) {
                        $value = $matches[1];
                    }

                    if (!$this->helper->load('image')->get_image($value)) {
                        $value = $this->strip_shortcodes($value);
                        if (
                                $value &&
                                trim($value) != "" &&
                                extension_loaded('gd') &&
                                function_exists('imagettftext')
                        ) {
                            if (isset($field['properties']['text_color']) && $field['properties']['text_color']) {
                                $penColour = $this->helper->load('convert')->to_hex_color($field['properties']['text_color']);
                            } else {
                                $penColour = array(0x14, 0x53, 0x94);
                            }

                            $default_options = array(
                                'imageSize' => array(isset($field['width']) ? $field['width'] : '400', isset($field['height']) ? $field['height'] : '150'),
                                'bgColour' => 'transparent',
                                'penColour' => $penColour
                            );

                            $options = array();
                            $options = apply_filters('e2pdf_frm_sig_output_options', $options, $field_id);
                            $options = array_merge($default_options, $options);

                            $model_e2pdf_font = new Model_E2pdf_Font();

                            $font = false;
                            if (isset($field['properties']['text_font']) && $field['properties']['text_font']) {
                                $font = $model_e2pdf_font->get_font_path($field['properties']['text_font']);
                            } elseif (class_exists('FrmSigAppHelper')) {
                                if (file_exists(FrmSigAppHelper::plugin_path() . '/assets/journal.ttf')) {
                                    $font = FrmSigAppHelper::plugin_path() . '/assets/journal.ttf';
                                }
                            }

                            if (!$font) {
                                $font = $model_e2pdf_font->get_font_path('Noto Sans');
                            }

                            $size = 150;
                            if (isset($field['properties']['text_font_size']) && $field['properties']['text_font_size']) {
                                $size = $field['properties']['text_font_size'];
                            }

                            $model_e2pdf_signature = new Model_E2pdf_Signature();
                            $value = $model_e2pdf_signature->ttf_signature($value, $size, $font, $options);
                        } else {
                            $value = "";
                        }
                    }
                }
            }

            if ((false !== strpos($value, '[referer]') || false !== strpos($value, '[browser]')) && isset($entry->description)) {
                $description = maybe_unserialize($entry->description);
                $referer = "";
                if (isset($description['referrer'])) {
                    if (@preg_match('/Referer +\d+\:[ \t]+([^\n\t]+)/', $description['referrer'], $m)) {
                        $referer = $m[1];
                    } else {
                        $referer = $description['referrer'];
                    }
                }

                $browser = "";
                if (isset($description['browser'])) {
                    $browser = $description['browser'];
                }

                $replace = array(
                    'from' => array(
                        '[referer]',
                        '[browser]'
                    ),
                    'to' => array(
                        $referer,
                        $browser
                    )
                );
                $value = str_replace($replace['from'], $replace['to'], $value);
            }

            if (false !== strpos($value, '[entry_num]')) {
                $entry_num = '';
                if (class_exists("FrmDb")) {
                    $entry_num = FrmDb::get_count('frm_items', array("form_id = '{$form->id}' AND id <= '{$entry->id}' AND 1" => "1"));
                }

                $replace = array(
                    'from' => array(
                        '[entry_num]'
                    ),
                    'to' => array(
                        $entry_num
                    )
                );
                $value = str_replace($replace['from'], $replace['to'], $value);
            }

            if (false !== strpos($value, '[pdf_num]')) {
                $pdf_num = '0';
                $uid = $this->get('uid');
                if ($uid) {
                    $entry = new Model_E2pdf_Entry();
                    if ($entry->load_by_uid($uid)) {
                        $pdf_num = $entry->get('pdf_num') + 1;
                    }
                }

                $replace = array(
                    'from' => array(
                        '[pdf_num]'
                    ),
                    'to' => array(
                        $pdf_num
                    )
                );

                $value = str_replace($replace['from'], $replace['to'], $value);
            }
        }

        return $value;
    }

    /**
     * Strip unused shortcodes
     * 
     * @param string $value - Content
     * 
     * @return string - Value with removed unused shortcodes
     */
    public function strip_shortcodes($value) {
        $value = preg_replace('~(?:\[/?)[^/\]]+/?\]~s', "", $value);
        return $value;
    }

    /**
     * Search and update shortcodes for this extension inside content
     * Auto set of dataset id
     * 
     * @param string $content - Content
     * @param int $form - ID of form
     * @param int $dataset - ID of dataset
     * 
     * @return string - Content with updates shortcodes
     */
    public function filter_frm_content($content, $form, $dataset) {

        if (false === strpos($content, '[')) {
            return $content;
        }

        $shortcode_tags = array(
            'e2pdf-download',
            'e2pdf-save',
            'e2pdf-view',
            'e2pdf-adobesign'
        );

        preg_match_all('@\[([^<>&/\[\]\x00-\x20=]++)@', $content, $matches);
        $tagnames = array_intersect($shortcode_tags, $matches[1]);

        if (!empty($tagnames)) {
            $pattern = get_shortcode_regex($tagnames);

            preg_match_all("/$pattern/", $content, $shortcodes);
            foreach ($shortcodes[0] as $key => $shortcode_value) {

                $shortcode = array();
                $shortcode[1] = $shortcodes[1][$key];
                $shortcode[2] = $shortcodes[2][$key];
                $shortcode[3] = $shortcodes[3][$key];
                $shortcode[4] = $shortcodes[4][$key];
                $shortcode[5] = $shortcodes[5][$key];
                $shortcode[6] = $shortcodes[6][$key];

                $atts = shortcode_parse_atts($shortcode[3]);

                if (!array_key_exists('dataset', $atts) && array_key_exists('id', $atts)) {
                    $template = new Model_E2pdf_Template();
                    $template->load($atts['id']);
                    if ($template->get('extension') === 'formidable') {
                        $entry_id = is_object($dataset) ? $dataset->id : $dataset;
                        if ($entry_id) {
                            $atts['dataset'] = $entry_id;
                            $shortcode[3] .= " dataset=\"{$entry_id}\"";
                        }
                    }
                }
                if ($shortcode[2] === 'e2pdf-save' || $shortcode[2] === 'e2pdf-adobesign') {
                    $shortcode[3] .= " apply=\"true\"";
                }
                $shortcode[3] .= " filter=\"true\"";
                $content = str_replace($shortcode_value, do_shortcode_tag($shortcode), $content);
            }
        }

        return $content;
    }

    /**
     * Filter for checkbox repeatable Label/Value fix
     * 
     * @param array $value - Value
     * @param obj $field - Field
     * @param array $atts - Shortcode Attributes
     * 
     * @return mixed - Updated value
     */
    public function filter_frm_display_value_custom($value, $field, $atts = array()) {
        if (class_exists("FrmProEntriesController")) {
            $defaults = array('html' => 0, 'type' => $field->type, 'keepjs' => 0);
            $atts = array_merge($defaults, $atts);

            if ($atts['type'] === 'checkbox') {
                $value = FrmProEntriesController::get_option_label_for_saved_value($value, $field, $atts);
            }
        }
        return $value;
    }

    /**
     * Generate attachments according shortcodes in Email template
     * 
     * @param array $attachments - List of attachments
     * @param int $form - ID of form
     * @param array $args - Arguments
     * 
     * @return array - Updated list of attachments
     */
    public function filter_frm_notification_attachment($attachments = array(), $form, $args) {

        if (!isset($args['email_key'])) {
            return $attachments;
        }

        $form_actions = FrmFormAction::get_action_for_form($form->id);

        $dataset = $args['entry']->id;
        $email_key = $args['email_key'];

        $shortcode_tags = array(
            'e2pdf-attachment',
        );

        foreach ($form_actions as $key => $action) {
            if ($action->ID === $email_key) {

                $content = $action->post_content['email_message'];

                if (false === strpos($content, '[')) {
                    return $attachments;
                }

                remove_filter('frm_content', array($this, 'filter_frm_content'), 30);
                $content = apply_filters('frm_content', $content, $form, $args['entry']);
                add_filter('frm_content', array($this, 'filter_frm_content'), 30, 3);

                preg_match_all('@\[([^<>&/\[\]\x00-\x20=]++)@', $content, $matches);
                $tagnames = array_intersect($shortcode_tags, $matches[1]);

                if (!empty($tagnames)) {
                    $pattern = get_shortcode_regex($tagnames);

                    preg_match_all("/$pattern/", $content, $shortcodes);

                    foreach ($shortcodes[0] as $key => $shortcode_value) {

                        $shortcode = array();
                        $shortcode[1] = $shortcodes[1][$key];
                        $shortcode[2] = $shortcodes[2][$key];
                        $shortcode[3] = $shortcodes[3][$key];
                        $shortcode[4] = $shortcodes[4][$key];
                        $shortcode[5] = $shortcodes[5][$key];
                        $shortcode[6] = $shortcodes[6][$key];

                        $atts = shortcode_parse_atts($shortcode[3]);

                        if (!array_key_exists('dataset', $atts) && array_key_exists('id', $atts)) {
                            $template = new Model_E2pdf_Template();
                            $template->load($atts['id']);
                            if ($template->get('extension') === 'formidable') {
                                $entry_id = is_object($dataset) ? $dataset->id : $dataset;
                                if ($entry_id) {
                                    $atts['dataset'] = $entry_id;
                                    $shortcode[3] .= " dataset=\"{$entry_id}\"";
                                }
                            }
                        }

                        $shortcode[3] .= " apply=\"true\" filter=\"true\"";

                        $file = do_shortcode_tag($shortcode);

                        if ($file) {
                            $this->helper->add('formidable_attachments', $file);
                            $attachments[] = $file;
                        }
                    }
                }
            }
        }
        return $attachments;
    }

    /**
     * Remove Page Breaks for Visual Mapper
     * 
     * @param array $fields - List of fields 
     * 
     * @return array - Updated fields
     */
    function filter_remove_pagebreaks($fields) {
        foreach ((array) $fields as $field_key => $field) {
            if ($field->type == 'break') {
                unset($fields[$field_key]);
            }
        }
        return $fields;
    }

    /**
     * Add options for Formidable extension
     * 
     * @param array $options - List of options 
     * 
     * @return array - Updated options list
     */
    public function filter_e2pdf_model_options_get_options_options($options = array()) {
        $options['formidable_group'] = array(
            'name' => __('Formidable', 'e2pdf'),
            'action' => 'extension',
            'group' => 'formidable_group',
            'options' => array(
                array(
                    'name' => __('Auto PDF and Visual Mapper', 'e2pdf'),
                    'key' => 'e2pdf_formidable_use_keys',
                    'value' => get_option('e2pdf_formidable_use_keys') === false ? 0 : get_option('e2pdf_formidable_use_keys'),
                    'default_value' => 0,
                    'type' => 'checkbox',
                    'placeholder' => __('Use Field Keys instead Field IDs', 'e2pdf'),
                ),
            )
        );
        return $options;
    }

    public function filter_e2pdf_controller_templates_backup_options($options, $template, $extension) {

        if ($extension->loaded('formidable')) {

            $options['formidable'] = array(
                'name' => __('Formidable', 'e2pdf'),
                'options' => array(
                    array(
                        'name' => __('Force shortcodes to use', 'e2pdf'),
                        'key' => 'options[formidable_force_shortcodes]',
                        'value' => 0,
                        'default_value' => 0,
                        'type' => 'select',
                        'options' => array(
                            '0' => __('None', 'e2pdf'),
                            '1' => __('Fields IDs', 'e2pdf'),
                            '2' => __('Field Keys', 'e2pdf'),
                        )
                    ),
                )
            );
        }

        return $options;
    }

    public function filter_e2pdf_controller_templates_backup_pages($options, $template, $extension, $pages) {

        if ($extension->loaded('formidable') && (isset($options['formidable_force_shortcodes']) && $options['formidable_force_shortcodes'])) {

            $where = array('fi.form_id' => (int) $template->get('item'));
            $fields = FrmField::getAll($where, 'id ASC');

            $search = array();
            $replace = array();

            if ($options['formidable_force_shortcodes'] == '1') {
                foreach ($fields as $field_key => $field) {
                    if (isset($field->field_options['form_select']) && $field->field_options['form_select']) {
                        $sub_where = array('fi.form_id' => $field->field_options['form_select']);
                        $sub_fields = FrmField::getAll($sub_where, 'id ASC');

                        foreach ($sub_fields as $sub_field_key => $sub_field) {
                            $search[] = $sub_field->field_key;
                            $replace[] = $sub_field->id;
                        }
                    } else {
                        $search[] = $field->field_key;
                        $replace[] = $field->id;
                    }
                }
            } elseif ($options['formidable_force_shortcodes'] == '2') {
                foreach ($fields as $field_key => $field) {

                    if (isset($field->field_options['form_select']) && $field->field_options['form_select']) {
                        $sub_where = array('fi.form_id' => $field->field_options['form_select']);
                        $sub_fields = FrmField::getAll($sub_where, 'id ASC');

                        foreach ($sub_fields as $sub_field_key => $sub_field) {
                            $search[] = $sub_field->id;
                            $replace[] = $sub_field->field_key;
                        }
                    } else {
                        $search[] = $field->id;
                        $replace[] = $field->field_key;
                    }
                }
            }

            $search = array_reverse($search);
            $replace = array_reverse($replace);

            $list = array_combine($search, $replace);

            $pages = $this->pages_replace_shortcodes($pages, $list);
        }

        return $pages;
    }

    public function filter_e2pdf_controller_templates_backup_replace_shortcodes($options, $template, $extension, $value) {

        if ($extension->loaded('formidable') && (isset($options['formidable_force_shortcodes']) && $options['formidable_force_shortcodes'])) {
            $where = array('fi.form_id' => (int) $template->get('item'));
            $fields = FrmField::getAll($where, 'id ASC');

            $search = array();
            $replace = array();

            if ($options['formidable_force_shortcodes'] == '1') {
                foreach ($fields as $field_key => $field) {
                    if (isset($field->field_options['form_select']) && $field->field_options['form_select']) {
                        $sub_where = array('fi.form_id' => $field->field_options['form_select']);
                        $sub_fields = FrmField::getAll($sub_where, 'id ASC');

                        foreach ($sub_fields as $sub_field_key => $sub_field) {
                            $search[] = $sub_field->field_key;
                            $replace[] = $sub_field->id;
                        }
                    } else {
                        $search[] = $field->field_key;
                        $replace[] = $field->id;
                    }
                }
            } elseif ($options['formidable_force_shortcodes'] == '2') {
                foreach ($fields as $field_key => $field) {

                    if (isset($field->field_options['form_select']) && $field->field_options['form_select']) {
                        $sub_where = array('fi.form_id' => $field->field_options['form_select']);
                        $sub_fields = FrmField::getAll($sub_where, 'id ASC');

                        foreach ($sub_fields as $sub_field_key => $sub_field) {
                            $search[] = $sub_field->id;
                            $replace[] = $sub_field->field_key;
                        }
                    } else {
                        $search[] = $field->id;
                        $replace[] = $field->field_key;
                    }
                }
            }

            $search = array_reverse($search);
            $replace = array_reverse($replace);

            $list = array_combine($search, $replace);

            $value = $this->replace_shortcodes($value, $list);
        }

        return $value;
    }

    public function filter_e2pdf_controller_templates_import_pages($options, $xml, $template, $extension, $pages) {

        if ($extension->loaded('formidable') &&
                $template->get('item') &&
                $template->get('item') != (String) $xml->template->item &&
                $xml->item->formidable &&
                $options['item'] &&
                class_exists('FrmXMLHelper') &&
                class_exists('FrmField')
        ) {

            $tmp = tempnam($this->helper->get('tmp_dir'), 'e2pdf');
            file_put_contents($tmp, base64_decode((String) $xml->item->formidable));

            $dom = new DOMDocument;
            $success = $dom->loadXML(file_get_contents($tmp));

            $old_ids = array();
            $old_keys = array();

            if ($success && function_exists('simplexml_import_dom')) {
                $item_xml = simplexml_import_dom($dom);

                foreach ($item_xml->form as $form_key => $form) {
                    if ((String) $form->id == (String) $xml->template->item) {
                        foreach ($form->field as $field_key => $field) {
                            $field_options = @json_decode((String) $field->field_options, true);
                            if (isset($field_options['form_select']) && $field_options['form_select']) {
                                foreach ($item_xml->form as $sub_form_key => $sub_form) {
                                    if ((String) $sub_form->id == $field_options['form_select']) {
                                        foreach ($sub_form->field as $sub_field_key => $sub_field) {
                                            $old_ids[] = (String) $sub_field->id;
                                            $old_keys[] = (String) $sub_field->field_key;
                                        }
                                    }
                                }
                            } else {
                                $old_ids[] = (String) $field->id;
                                $old_keys[] = (String) $field->field_key;
                            }
                        }
                    }
                }
            }

            $where = array('fi.form_id' => (int) $template->get('item'));
            $fields = FrmField::getAll($where, 'id ASC');

            $new_ids = array();
            $new_keys = array();

            foreach ($fields as $field_key => $field) {

                if (isset($field->field_options['form_select']) && $field->field_options['form_select']) {
                    $sub_where = array('fi.form_id' => (int) $field->field_options['form_select']);
                    $sub_fields = FrmField::getAll($sub_where, 'id ASC');

                    foreach ($sub_fields as $sub_field_key => $sub_field) {
                        $new_ids[] = $sub_field->id;
                        $new_keys[] = $sub_field->field_key;
                    }
                } else {
                    $new_ids[] = $field->id;
                    $new_keys[] = $field->field_key;
                }
            }


            if (count($old_ids) === count($new_ids)) {
                $old_ids = array_reverse($old_ids);
                $new_ids = array_reverse($new_ids);

                $old_keys = array_reverse($old_keys);
                $new_keys = array_reverse($new_keys);

                $list_ids = array_combine($old_ids, $new_ids);
                $pages = $this->pages_replace_shortcodes($pages, $list_ids);

                $list_keys = array_combine($old_keys, $new_keys);
                $pages = $this->pages_replace_shortcodes($pages, $list_keys);
            }

            unset($dom);
            unlink($tmp);
        }

        return $pages;
    }

    public function filter_e2pdf_controller_templates_import_replace_shortcodes($options, $xml, $template, $extension, $value) {

        if ($extension->loaded('formidable') &&
                $template->get('item') &&
                $template->get('item') != (String) $xml->template->item &&
                $xml->item->formidable &&
                $options['item'] &&
                class_exists('FrmXMLHelper') &&
                class_exists('FrmField')
        ) {

            $tmp = tempnam($this->helper->get('tmp_dir'), 'e2pdf');
            file_put_contents($tmp, base64_decode((String) $xml->item->formidable));

            $dom = new DOMDocument;
            $success = $dom->loadXML(file_get_contents($tmp));

            $old_ids = array();
            $old_keys = array();

            if ($success && function_exists('simplexml_import_dom')) {
                $item_xml = simplexml_import_dom($dom);

                foreach ($item_xml->form as $form_key => $form) {
                    if ((String) $form->id == (String) $xml->template->item) {
                        foreach ($form->field as $field_key => $field) {
                            $field_options = @json_decode((String) $field->field_options, true);
                            if (isset($field_options['form_select']) && $field_options['form_select']) {
                                foreach ($item_xml->form as $sub_form_key => $sub_form) {
                                    if ((String) $sub_form->id == $field_options['form_select']) {
                                        foreach ($sub_form->field as $sub_field_key => $sub_field) {
                                            $old_ids[] = (String) $sub_field->id;
                                            $old_keys[] = (String) $sub_field->field_key;
                                        }
                                    }
                                }
                            } else {
                                $old_ids[] = (String) $field->id;
                                $old_keys[] = (String) $field->field_key;
                            }
                        }
                    }
                }
            }

            $where = array('fi.form_id' => (int) $template->get('item'));
            $fields = FrmField::getAll($where, 'id ASC');

            $new_ids = array();
            $new_keys = array();

            foreach ($fields as $field_key => $field) {

                if (isset($field->field_options['form_select']) && $field->field_options['form_select']) {
                    $sub_where = array('fi.form_id' => (int) $field->field_options['form_select']);
                    $sub_fields = FrmField::getAll($sub_where, 'id ASC');

                    foreach ($sub_fields as $sub_field_key => $sub_field) {
                        $new_ids[] = $sub_field->id;
                        $new_keys[] = $sub_field->field_key;
                    }
                } else {
                    $new_ids[] = $field->id;
                    $new_keys[] = $field->field_key;
                }
            }

            if (count($old_ids) === count($new_ids)) {

                $old_ids = array_reverse($old_ids);
                $new_ids = array_reverse($new_ids);

                $old_keys = array_reverse($old_keys);
                $new_keys = array_reverse($new_keys);

                $list_ids = array_combine($old_ids, $new_ids);
                $value = $this->replace_shortcodes($value, $list_ids);

                $list_keys = array_combine($old_keys, $new_keys);
                $value = $this->replace_shortcodes($value, $list_keys);
            }

            unset($dom);
            unlink($tmp);
        }


        return $value;
    }

    /**
     * Delete attachments that were sent by email
     */
    public function action_frm_notification() {

        $files = $this->helper->get('formidable_attachments');

        if (is_array($files) && !empty($files)) {
            foreach ($files as $key => $file) {
                $this->helper->delete_dir(dirname($file) . '/');
            }
            $this->helper->deset('formidable_attachments');
        }
    }

    /**
     * Fix for user_id shortcode
     * 
     * @param object $template - Current Template
     * @param object $extension - Loaded extension 
     * 
     */
    public function action_e2pdf_model_template_fill_pre($template, $extension) {
        if ($extension->loaded("formidable")) {
            if ($extension->get('dataset') && class_exists("FrmEntry") && is_admin()) {
                $extension->set('user_id', get_current_user_id());
                $entry = FrmEntry::getOne($extension->get('dataset'));
                if ($entry) {
                    set_current_user($entry->user_id);
                }
            }
        }
    }

    /**
     * Revert Fix for user_id shortcode
     * 
     * @param object $template - Current Template
     * @param object $extension - Loaded extension 
     * 
     */
    public function action_e2pdf_model_template_fill_after($template, $extension) {
        if ($extension->loaded("formidable")) {
            if ($extension->get('dataset') && class_exists("FrmEntry") && is_admin()) {
                set_current_user($extension->get('user_id'));
            }
        }
    }

    /**
     * Auto Generate of Template for this extension
     * 
     * @return array - List of elements
     */
    public function auto() {

        $response = array();
        $elements = array();

        $form_id = $this->get('item');

        $fields = array();

        if (class_exists('FrmField')) {
            $fields = FrmField::get_all_for_form($form_id);
        }

        if ($fields) {
            foreach ($fields as $key => $field) {

                $field_id = get_option('e2pdf_formidable_use_keys') ? $field->field_key : $field->id;

                if ($field->type === 'lookup' || $field->type === 'data') {

                    $dynamic_field_id = false;
                    $dynamic_form_id = false;

                    if ($field->type === 'lookup' && isset($field->field_options['get_values_field']) && isset($field->field_options['get_values_form'])) {

                        $dynamic_form_id = $field->field_options['get_values_form'];
                        $dynamic_field_id = $field->field_options['get_values_field'];

                        if (get_option('e2pdf_formidable_use_keys')) {
                            $dynamic_field_data = FrmField::getOne($dynamic_field_id);

                            if ($dynamic_field_data) {
                                $dynamic_field_id = $dynamic_field_data->field_key;
                            }
                        }
                    } elseif ($field->type === 'data' && isset($field->field_options['form_select']) && $field->field_options['form_select'] !== 'taxonomy' && class_exists('FrmField')) {

                        $dynamic_field_id = $field->field_options['form_select'];
                        $dynamic_field_data = FrmField::getOne($dynamic_field_id);

                        if ($dynamic_field_data) {
                            $dynamic_form_id = $dynamic_field_data->form_id;

                            if (get_option('e2pdf_formidable_use_keys')) {
                                $dynamic_field_id = $dynamic_field_data->field_key;
                            }
                        }
                    }

                    $field->type = $field->field_options['data_type'];
                    if ($dynamic_field_id && $dynamic_form_id) {
                        if ($field->field_options['data_type'] == 'select') {

                            $field->options = array(
                                "[e2pdf-frm-entry-values id='$dynamic_form_id' field_id='$dynamic_field_id']"
                            );
                        } elseif ($field->field_options['data_type'] == 'radio' || $field->field_options['data_type'] == 'checkbox') {

                            $options = array();

                            if (class_exists('FrmEntry') && class_exists('FrmEntryMeta')) {
                                $where = array(
                                    'it.form_id' => $dynamic_form_id
                                );

                                $entries_tmp = FrmEntry::getAll($where, ' ORDER BY id ASC');
                                foreach ($entries_tmp as $key => $entry) {
                                    $options[] = FrmEntryMeta::get_meta_value($entry, $dynamic_field_id);
                                }
                            }
                            $field->options = $options;
                        }
                    }
                }

                /*
                 * Repeatable fields Field ID modification
                 * @since 0.01.42
                 */
                if ($field->type !== 'lookup' && $field->type !== 'data' && isset($field->form_id) && $field->form_id != $form_id) {
                    $field_id = $field_id . ":1";
                }

                switch ($field->type) {
                    case 'html':
                        $elements[] = $this->auto_field($field, 'e2pdf-html', array(
                            'top' => '20',
                            'left' => '20',
                            'right' => '20',
                            'block' => true,
                            'properties' => array(
                                'value' => $field->name,
                            )
                        ));

                        $elements[] = $this->auto_field($field, 'e2pdf-html', array(
                            'properties' => array(
                                'value' => $field->description,
                            )
                        ));
                        break;

                    case 'signature':
                        $elements[] = $this->auto_field($field, 'e2pdf-html', array(
                            'top' => '20',
                            'left' => '20',
                            'right' => '20',
                            'block' => true,
                            'properties' => array(
                                'value' => $field->name,
                            )
                        ));

                        $elements[] = $this->auto_field($field, 'e2pdf-signature', array(
                            'properties' => array(
                                'width' => '400',
                                'height' => '150',
                                'scale' => '1',
                                'dimension' => '1',
                                'value' => "[$field_id]"
                            )
                        ));
                        break;

                    case 'scale':
                        $elements[] = $this->auto_field($field, 'e2pdf-html', array(
                            'top' => '20',
                            'left' => '20',
                            'right' => '20',
                            'block' => true,
                            'properties' => array(
                                'value' => $field->name,
                            )
                        ));

                        $left = 0;

                        if (isset($field->options) && is_array($field->options)) {
                            foreach ($field->options as $opt_key => $option) {

                                if (is_array($option)) {
                                    $elements[] = $this->auto_field($field, 'e2pdf-radio', array(
                                        'top' => 0,
                                        'left' => $left,
                                        'properties' => array(
                                            'width' => '15',
                                            'height' => '15',
                                            'value' => "[$field_id]",
                                            'option' => $option['value'],
                                            'group' => "group_" . $field_id
                                        )
                                    ));
                                    $elements[] = $this->auto_field($field, 'e2pdf-html', array(
                                        'top' => '20',
                                        'left' => $left - 5,
                                        'properties' => array(
                                            'value' => $option['label'],
                                            'width' => '25',
                                            'text_align' => 'center',
                                        )
                                    ));
                                } else {

                                    $elements[] = $this->auto_field($field, 'e2pdf-radio', array(
                                        'top' => 0,
                                        'left' => $left,
                                        'properties' => array(
                                            'width' => '15',
                                            'height' => '15',
                                            'value' => "[$field_id]",
                                            'option' => $option,
                                            'group' => "group_" . $field_id
                                        )
                                    ));
                                    $elements[] = $this->auto_field($field, 'e2pdf-html', array(
                                        'top' => '20',
                                        'left' => $left - 5,
                                        'properties' => array(
                                            'value' => $option,
                                            'width' => '25',
                                            'text_align' => 'center',
                                        )
                                    ));
                                }

                                $left = $left + 25;
                            }
                        }
                        break;

                    case 'rte':
                        $elements[] = $this->auto_field($field, 'e2pdf-html', array(
                            'top' => '20',
                            'left' => '20',
                            'right' => '20',
                            'block' => true,
                            'properties' => array(
                                'value' => $field->name,
                            )
                        ));

                        $elements[] = $this->auto_field($field, 'e2pdf-html', array(
                            'properties' => array(
                                'height' => '150',
                                'value' => "[$field_id wpautop=0]"
                            )
                        ));
                        break;

                    case 'file':
                    case 'text':
                    case 'email':
                    case 'url':
                    case 'number':
                    case 'phone':
                    case 'date':
                    case 'time':
                    case 'image':
                    case 'tag':
                    case 'password':
                        $elements[] = $this->auto_field($field, 'e2pdf-html', array(
                            'top' => '20',
                            'left' => '20',
                            'right' => '20',
                            'block' => true,
                            'properties' => array(
                                'value' => $field->name,
                            )
                        ));

                        if ($field->type == 'file') {
                            if (strpos($field_id, ':') !== false) {
                                $field_id .= " size='full' show_image='0' add_link='0'";
                            } else {
                                $field_id .= " size='full'";
                            }
                        }

                        $elements[] = $this->auto_field($field, 'e2pdf-input', array(
                            'properties' => array(
                                'value' => "[$field_id]",
                                'pass' => $field->type === 'password' ? '1' : '0',
                            )
                        ));
                        break;

                    case 'select':
                        $elements[] = $this->auto_field($field, 'e2pdf-html', array(
                            'top' => '20',
                            'left' => '20',
                            'right' => '20',
                            'block' => true,
                            'properties' => array(
                                'value' => $field->name,
                            )
                        ));

                        $options_tmp = array();
                        if (isset($field->options) && is_array($field->options)) {
                            foreach ($field->options as $opt_key => $option) {
                                if (is_array($option)) {
                                    $options_tmp[] = isset($option['label']) ? $option['label'] : $option['value'];
                                } else {
                                    $options_tmp[] = $option;
                                }
                            }
                        }

                        $elements[] = $this->auto_field($field, 'e2pdf-select', array(
                            'properties' => array(
                                'options' => implode("\n", $options_tmp),
                                'value' => "[$field_id]",
                                'height' => isset($field->field_options['multiple']) && $field->field_options['multiple'] ? '80' : '',
                                'multiline' => isset($field->field_options['multiple']) && $field->field_options['multiple'] ? '1' : '0',
                            )
                        ));
                        break;


                    case 'credit_card':
                    case 'address':
                        $elements[] = $this->auto_field($field, 'e2pdf-html', array(
                            'top' => '20',
                            'left' => '20',
                            'right' => '20',
                            'block' => true,
                            'properties' => array(
                                'value' => $field->name,
                            )
                        ));

                        $elements[] = $this->auto_field($field, 'e2pdf-textarea', array(
                            'properties' => array(
                                'value' => "[$field_id]",
                            )
                        ));
                        break;

                    case 'textarea':
                        $elements[] = $this->auto_field($field, 'e2pdf-html', array(
                            'top' => '20',
                            'left' => '20',
                            'right' => '20',
                            'block' => true,
                            'properties' => array(
                                'value' => $field->name,
                            )
                        ));

                        $elements[] = $this->auto_field($field, 'e2pdf-textarea', array(
                            'properties' => array(
                                'value' => "[$field_id wpautop=0]",
                            )
                        ));
                        break;

                    case 'radio':
                        $elements[] = $this->auto_field($field, 'e2pdf-html', array(
                            'top' => '20',
                            'left' => '20',
                            'right' => '20',
                            'block' => true,
                            'properties' => array(
                                'value' => $field->name,
                            )
                        ));

                        $top = 0;
                        if (isset($field->options) && is_array($field->options)) {
                            foreach ($field->options as $opt_key => $option) {

                                if (is_array($option)) {
                                    $elements[] = $this->auto_field($field, 'e2pdf-radio', array(
                                        'top' => $top,
                                        'properties' => array(
                                            'width' => '15',
                                            'height' => '15',
                                            'value' => "[$field_id]",
                                            'option' => $option['label'],
                                            'group' => "group_" . $field_id
                                        )
                                    ));
                                    $elements[] = $this->auto_field($field, 'e2pdf-html', array(
                                        'top' => $top,
                                        'left' => '20',
                                        'properties' => array(
                                            'value' => $option['label']
                                        )
                                    ));
                                } else {

                                    $elements[] = $this->auto_field($field, 'e2pdf-radio', array(
                                        'top' => $top,
                                        'properties' => array(
                                            'width' => '15',
                                            'height' => '15',
                                            'value' => "[$field_id]",
                                            'option' => $option,
                                            'group' => "group_" . $field_id
                                        )
                                    ));
                                    $elements[] = $this->auto_field($field, 'e2pdf-html', array(
                                        'top' => $top,
                                        'left' => '20',
                                        'properties' => array(
                                            'value' => $option
                                        )
                                    ));
                                }
                                $top = $top + 20;
                            }
                        }
                        break;

                    case 'checkbox':
                        $elements[] = $this->auto_field($field, 'e2pdf-html', array(
                            'top' => '20',
                            'left' => '20',
                            'right' => '20',
                            'block' => true,
                            'properties' => array(
                                'value' => $field->name,
                            )
                        ));

                        $top = 0;
                        if (isset($field->options) && is_array($field->options)) {
                            foreach ($field->options as $opt_key => $option) {
                                if (is_array($option)) {
                                    $elements[] = $this->auto_field($field, 'e2pdf-checkbox', array(
                                        'top' => $top,
                                        'properties' => array(
                                            'width' => '15',
                                            'height' => '15',
                                            'value' => "[$field_id]",
                                            'option' => $option['label']
                                        )
                                    ));
                                    $elements[] = $this->auto_field($field, 'e2pdf-html', array(
                                        'top' => $top,
                                        'left' => '20',
                                        'properties' => array(
                                            'value' => $option['label']
                                        )
                                    ));
                                } else {
                                    $elements[] = $this->auto_field($field, 'e2pdf-checkbox', array(
                                        'top' => $top,
                                        'properties' => array(
                                            'width' => '15',
                                            'height' => '15',
                                            'value' => "[$field_id]",
                                            'option' => $option
                                        )
                                    ));
                                    $elements[] = $this->auto_field($field, 'e2pdf-html', array(
                                        'top' => $top,
                                        'left' => '20',
                                        'properties' => array(
                                            'value' => $option
                                        )
                                    ));
                                }
                                $top = $top + 20;
                            }
                        }
                        break;

                    default:
                        break;
                }
            }
        }

        $response['page'] = array(
            'bottom' => '20',
            'top' => '20',
        );

        $response['elements'] = $elements;
        return $response;
    }

    /**
     * Generate field for Auto PDF
     * 
     * @param object $field - Formidable field object
     * @param string $type - Field type
     * @param array $options - Field additional options
     * 
     * @return array - Prepared auto field
     */
    public function auto_field($field = false, $type = false, $options = array()) {

        if (!$field || !$type) {
            return false;
        }

        $classes = array();
        if (isset($field->field_options['classes'])) {
            $classes = explode(" ", $field->field_options['classes']);
        }

        $element = array(
            'type' => $type,
            'properties' => isset($options['properties']) ? $options['properties'] : array(),
        );

        $element['top'] = isset($options['top']) ? $options['top'] : '0';
        $element['left'] = isset($options['left']) ? $options['left'] : '0';
        $element['right'] = isset($options['right']) ? $options['right'] : '0';
        $element['block'] = isset($options['block']) ? $options['block'] : false;

        $float_classes = array(
            'frm_half',
            'frm_third',
            'frm_two_thirds',
            'frm_fourth',
            'frm_three_fourths',
            'frm_fifth',
            'frm_two_fifths',
            'frm_sixth',
            'frm_seventh',
            'frm_eighth'
        );

        $array_intersect = array_intersect($classes, $float_classes);

        if (!empty($array_intersect) && !in_array('frm_first', $classes)) {
            $element['float'] = true;
        };

        $primary_class = false;
        if (!empty($array_intersect)) {
            $primary_class = end($array_intersect);
        }

        if ($element['block']) {
            switch ($primary_class) {
                case 'frm_half':
                    $element['width'] = '50%';
                    break;

                case 'frm_third':
                    $element['width'] = '33.3%';
                    break;

                case 'frm_two_thirds':
                    $element['width'] = '66.67%';
                    break;

                case 'frm_fourth':
                    $element['width'] = '25%';
                    break;

                case 'frm_three_fourths':
                    $element['width'] = '75%';
                    break;

                case 'frm_fifth':
                    $element['width'] = '20%';
                    break;

                case 'frm_two_fifths':
                    $element['width'] = '80%';
                    break;

                case 'frm_sixth':
                    $element['width'] = '16.67%';
                    break;

                case 'frm_seventh':
                    $element['width'] = '14.29%';
                    break;

                case 'frm_eighth':
                    $element['width'] = '12.5%';
                    break;

                default:
                    break;
            }
        }

        return $element;
    }

    /**
     * Backup form action
     * 
     * @param object xml - XML object where to add params for saved item
     */
    public function backup($xml = false) {
        if (class_exists('FrmXMLController')) {

            $ids = array();
            $ids[] = $this->get('item');

            $type = array();
            $type[] = 'forms';

            ob_start();
            FrmXMLController::generate_xml($type, compact('ids'));
            $backup = ob_get_clean();
            $xml->addChildCData('formidable', base64_encode($backup));
        }
    }

    /**
     * Import form action
     * 
     * @param object xml - XML object to parse data to import form
     */
    public function import($xml, $item) {

        $updated_item = '';

        if (class_exists('FrmXMLHelper') && class_exists('FrmField')) {

            if ($xml->formidable) {

                $tmp = tempnam($this->helper->get('tmp_dir'), 'e2pdf');
                file_put_contents($tmp, base64_decode((String) $xml->formidable));

                $result = FrmXMLHelper::import_xml($tmp);

                unlink($tmp);

                FrmXMLHelper::parse_message($result, $message, $errors);
                if ($errors) {
                    return array(
                        'errors' => $errors
                    );
                } else {
                    if (isset($result['forms'][$item])) {
                        $updated_item = $result['forms'][$item];
                    }
                }
            }
        }

        return $updated_item;
    }

    /**
     * Replace Old Formidable shortcodes to new values on pages
     * 
     * @param array $pages - List of pages to replace shortcodes
     * @param array $shortcodes_list - List of new/old shortcodes to replace
     * 
     * @return array - List of updated pages
     */
    public function pages_replace_shortcodes($pages = array(), $shortcodes_list = array()) {

        foreach ($pages as $page_key => $page) {
            foreach ($page['elements'] as $element_key => $element_value) {
                $pages[$page_key]['elements'][$element_key]['value'] = $this->replace_shortcodes($element_value['value'], $shortcodes_list);
            }
        }

        return $pages;
    }

    /**
     * Replace Old Formidable shortcodes to new values
     * 
     * @param string $content - Value that can contains old shortcodes
     * @param array $shortcodes_list - List of new/old shortcodes to replace
     * 
     * @return string - Updated value
     */
    public function replace_shortcodes($content = "", $shortcodes_list = array()) {

        if (false === strpos($content, '[')) {
            return $content;
        }

        foreach ($shortcodes_list as $list_key => $list_value) {
            $content = preg_replace("/(\[|\[(?:[^\]]*?)\s|\[(?:[^\]]*?)field_id=(?:\'|\"|)){$list_key}(\:(?:.*?)\]|\s(?:.*?)\]|(?:\'|\")(?:.*?)\]|\])/", '${1}' . $list_value . '${2}', $content);
        }

        return $content;
    }

    /**
     * Verify if form and dataset exists
     * 
     * @return bool - Exists/Not exists
     */
    public function verify() {
        $item = $this->get('item');
        $dataset = $this->get('dataset');

        if ($item && $dataset && class_exists('FrmEntry') && class_exists('FrmForm')) {
            $entry = FrmEntry::getOne($dataset);
            if (is_object($entry) && $entry->form_id == $item) {
                return true;
            }
        }
        return false;
    }

    /**
     * Visual Mapper for Mapping field
     * 
     * @return bool|string - Prepared form or false
     */
    public function visual_mapper() {

        $item = $this->get('item');

        if ($item && class_exists('FrmformsController')) {

            if (class_exists("FrmProFieldsHelper")) {
                add_filter('frm_get_paged_fields', array($this, 'filter_remove_pagebreaks'), 9, 1);
            }

            $source = FrmformsController::show_form($item, '', true, true);

            if (class_exists("FrmProFieldsHelper")) {
                remove_filter('frm_get_paged_fields', array($this, 'filter_remove_pagebreaks'), 9);
            }

            libxml_use_internal_errors(true);
            $dom = new DOMDocument;
            $html = $dom->loadHTML($source);
            libxml_clear_errors();

            if (!$html) {
                return __('Form could not be parsed due incorrect HTML', 'e2pdf');
            } else {

                $xpath = new DomXPath($dom);

                $remove_by_class = array(
                    'frm_ajax_loading',
                    'wp-editor-tools',
                    'quicktags-toolbar',
                    'frm_button_submit',
                    'frm_range_value',
                    'star-rating',
                    'frm_repeat_buttons'
                );
                foreach ($remove_by_class as $key => $class) {
                    $elements = $xpath->query("//*[contains(@class, '{$class}')]");
                    foreach ($elements as $element) {
                        $element->parentNode->removeChild($element);
                    }
                }

                $remove_by_tag = array(
                    'link',
                    'style',
                    'script'
                );
                foreach ($remove_by_tag as $key => $tag) {
                    $elements = $xpath->query("//{$tag}");
                    foreach ($elements as $element) {
                        $element->parentNode->removeChild($element);
                    }
                }

                $remove_classes = array(
                    'wp-editor-container',
                    'frm_logic_form'
                );

                foreach ($remove_classes as $key => $class) {
                    $elements = $xpath->query("//*[contains(@class, '{$class}')]");
                    foreach ($elements as $element) {
                        $element->attributes->getNamedItem("class")->nodeValue = str_replace($class, '', $element->attributes->getNamedItem("class")->nodeValue);
                    }
                }

                $remove_styles = array(
                    'frm_toggle_container'
                );

                foreach ($remove_styles as $key => $class) {
                    $elements = $xpath->query("//*[contains(@class, '{$class}')]");
                    foreach ($elements as $element) {
                        $element->attributes->getNamedItem("style")->nodeValue = '';
                    }
                }


                /*
                 * Metas patterns to replace field names
                 * @since 0.01.42
                 */
                $metas_pattern = array(
                    '/item_meta\[(?:.*?)\]\[0\]\[(.*?)\](?:\[\])?/i' => '$1:1',
                    '/item_meta\[(.*?)\](\[\])?/i' => '$1',
                );

                // Replace names
                $metas = $xpath->query("//*[contains(@name, 'item_meta')]");
                foreach ($metas as $element) {
                    $field_id = preg_replace(array_keys($metas_pattern), $metas_pattern, $element->attributes->getNamedItem("name")->nodeValue);
                    if (get_option('e2pdf_formidable_use_keys') && class_exists("FrmField")) {
                        if (strpos($field_id, ':') !== false) {
                            $repeat_data = explode(":", $field_id);
                            if (isset($repeat_data['0'])) {
                                $field_data = FrmField::getOne($repeat_data['0']);
                                if ($field_data) {
                                    $field_id = $field_data->field_key . ":1";
                                }
                            }
                        } else {
                            $field_data = FrmField::getOne($field_id);
                            if ($field_data) {
                                $field_id = $field_data->field_key;
                            }
                        }
                    }

                    $element->attributes->getNamedItem("name")->nodeValue = $field_id;
                }




                // Time field replace
                $time_fields = $xpath->query("//div/select[contains(@class, 'frm_time_select')]/parent::*");
                foreach ($time_fields as $key => $element) {
                    $span = $xpath->query("./span", $element)->item(0);
                    $select = $xpath->query("./select", $element)->item(0);

                    if ($span) {

                        $span_cloned = $span->cloneNode(true);
                        $select_cloned = $select->cloneNode(true);

                        foreach ($xpath->query("./select", $span_cloned) as $key => $sub_select) {
                            $sub_select->attributes->getNamedItem("class")->nodeValue = $sub_select->attributes->getNamedItem("class")->nodeValue . " e2pdf-no-vm";
                        }

                        $select_cloned->attributes->getNamedItem("class")->nodeValue = $select_cloned->attributes->getNamedItem("class")->nodeValue . " e2pdf-no-vm";

                        $span->parentNode->removeChild($span);
                        $select->parentNode->removeChild($select);

                        $wrapper = $dom->createElement('div');
                        $wrapper_atts = array(
                            'class' => 'e2pdf-vm-field-wrapper',
                        );

                        foreach ($wrapper_atts as $key => $value) {
                            $attr = $dom->createAttribute($key);
                            $attr->value = $value;
                            $wrapper->appendChild($attr);
                        }

                        $field = $dom->createElement('input');

                        $field_id = preg_replace('/\[(.*?)\]/i', '', $select_cloned->attributes->getNamedItem("name")->nodeValue);
                        if (get_option('e2pdf_formidable_use_keys') && class_exists("FrmField")) {
                            $field_data = FrmField::getOne($field_id);
                            if ($field_data) {
                                $field_id = $field_data->field_key;
                            }
                        }

                        $field_atts = array(
                            'type' => 'text',
                            'class' => 'e2pdf-vm-field',
                            'name' => $field_id
                        );

                        foreach ($field_atts as $key => $value) {
                            $attr = $dom->createAttribute($key);
                            $attr->value = $value;
                            $field->appendChild($attr);
                        }

                        $wrapper->appendChild($field);
                        $wrapper->appendChild($span_cloned);
                        $wrapper->appendChild($select_cloned);

                        $element->appendChild($wrapper);
                    }
                }

                // Combo fields
                $frm_combo_inputs_container = $xpath->query("//*[contains(@class, 'frm_combo_inputs_container')]");
                foreach ($frm_combo_inputs_container as $element) {

                    $inputs = $xpath->query(".//input", $element);
                    $selects = $xpath->query(".//select", $element);

                    foreach ($selects as $key => $sub_element) {
                        if ($sub_element->attributes->getNamedItem("class")->nodeValue) {
                            $sub_element->attributes->getNamedItem("class")->nodeValue = $sub_select->attributes->getNamedItem("class")->nodeValue . " e2pdf-no-vm";
                        } else {
                            $class = $dom->createAttribute('class');
                            $class->value = 'e2pdf-no-vm';
                            $sub_element->appendChild($class);
                        }
                    }

                    foreach ($inputs as $key => $sub_element) {
                        if ($sub_element->attributes->getNamedItem("class")->nodeValue) {
                            $sub_element->attributes->getNamedItem("class")->nodeValue = $sub_element->attributes->getNamedItem("class")->nodeValue . " e2pdf-no-vm";
                        } else {
                            $class = $dom->createAttribute('class');
                            $class->value = 'e2pdf-no-vm';
                            $sub_element->appendChild($class);
                        }
                    }

                    $name = "";
                    if ($inputs->item(0)) {
                        $name = $inputs->item(0)->attributes->getNamedItem("name")->nodeValue;
                    } else {
                        $name = $selects->item(0)->attributes->getNamedItem("name")->nodeValue;
                    }

                    $field_id = preg_replace('/\[(.*?)\]/i', '', $name);
                    if (get_option('e2pdf_formidable_use_keys') && class_exists("FrmField")) {
                        $field_data = FrmField::getOne($field_id);
                        if ($field_data) {
                            $field_id = $field_data->field_key;
                        }
                    }

                    $field = $dom->createElement('input');
                    $field_atts = array(
                        'type' => 'text',
                        'class' => 'e2pdf-vm-field',
                        'name' => $field_id
                    );

                    foreach ($field_atts as $key => $value) {
                        $attr = $dom->createAttribute($key);
                        $attr->value = $value;
                        $field->appendChild($attr);
                    }
                    $element->appendChild($field);

                    $element->attributes->getNamedItem("class")->nodeValue = $element->attributes->getNamedItem("class")->nodeValue . " e2pdf-vm-field-wrapper";
                }

                $frm_dropzone = $xpath->query("//*[contains(@class, 'frm_dropzone')]/parent::*");
                foreach ($frm_dropzone as $element) {
                    $dropzone = $xpath->query(".//*[contains(@class, 'frm_dropzone')]", $element)->item(0);
                    $input = $xpath->query(".//input", $element)->item(0);
                    $input_cloned = $input->cloneNode(true);
                    $input_cloned->attributes->getNamedItem("type")->nodeValue = 'text';
                    $input_cloned->attributes->getNamedItem("value")->nodeValue = __('File Upload', 'e2pdf');

                    if (strpos($input_cloned->attributes->getNamedItem("name")->nodeValue, ':') !== false) {
                        $input_cloned->attributes->getNamedItem("name")->nodeValue = $input_cloned->attributes->getNamedItem("name")->nodeValue . " size='full' show_image='0' add_link='0'";
                    } else {
                        $input_cloned->attributes->getNamedItem("name")->nodeValue = $input_cloned->attributes->getNamedItem("name")->nodeValue . " size='full'";
                    }

                    $style = $dom->createAttribute('style');
                    $style->value = 'width: 100%; height: 200px; text-align: center;';
                    $input_cloned->appendChild($style);

                    $input->parentNode->replaceChild($input_cloned, $input);
                    $dropzone->parentNode->removeChild($dropzone);
                }

                // Replace signature
                $sigpad = $xpath->query("//*[contains(@class, 'sigPad')]");
                foreach ($sigpad as $element) {
                    $input = $xpath->query(".//input", $element)->item(0);
                    $input_cloned = $input->cloneNode(true);

                    $style = $dom->createAttribute('style');
                    $style->value = 'width: 300px; height: 100px;';
                    $input_cloned->appendChild($style);

                    $field_id = preg_replace('/\[(.*?)\]/i', '', $input_cloned->attributes->getNamedItem("name")->nodeValue);

                    if (get_option('e2pdf_formidable_use_keys') && class_exists("FrmField")) {
                        $field_data = FrmField::getOne($field_id);
                        if ($field_data) {
                            $field_id = $field_data->field_key;
                        }
                    }

                    $input_cloned->attributes->getNamedItem("name")->nodeValue = $field_id;

                    $element->parentNode->replaceChild($input_cloned, $element);
                }

                // Replace names
                $fields = $xpath->query("//input");
                foreach ($fields as $element) {

                    if (class_exists('FrmField')) {

                        if ($element->attributes->getNamedItem("type")->nodeValue == 'checkbox' || $element->attributes->getNamedItem("type")->nodeValue == 'radio') {

                            $field_id = $element->attributes->getNamedItem("name")->nodeValue;
                            if (false !== strpos($element->attributes->getNamedItem("name")->nodeValue, ':')) {
                                $field_id = substr($element->attributes->getNamedItem("name")->nodeValue, 0, strpos($element->attributes->getNamedItem("name")->nodeValue, ":"));
                            }

                            $field_data = FrmField::getOne($field_id);

                            if (isset($field_data->type) && $field_data->type === 'data' && isset($field_data->field_options['form_select'])) {
                                $dynamic_form_id = false;
                                $dynamic_field_id = false;

                                $dynamic_field_id = $field_data->field_options['form_select'];
                                $dynamic_field_data = FrmField::getOne($dynamic_field_id);
                                if ($dynamic_field_data) {
                                    $dynamic_form_id = $dynamic_field_data->form_id;
                                }

                                $options = array();
                                if (class_exists('FrmEntry') && class_exists('FrmEntryMeta')) {
                                    $where = array(
                                        'it.form_id' => $dynamic_form_id
                                    );
                                    $entries_tmp = FrmEntry::getAll($where, ' ORDER BY id ASC');
                                    foreach ($entries_tmp as $key => $entry) {
                                        $options[] = array(
                                            'label' => FrmEntryMeta::get_meta_value($entry, $dynamic_field_id),
                                            'value' => $key,
                                        );
                                    }
                                }
                                $field_data->options = $options;
                            }

                            if (isset($field_data->options) && is_array($field_data->options)) {
                                $field_options = $field_data->options;
                                $field_value = $element->attributes->getNamedItem("value")->nodeValue;
                                $field_key = array_search($field_value, array_column($field_options, 'value'));
                                if ($field_key !== false) {
                                    $field_label = isset($field_options[$field_key]['label']) ? $field_options[$field_key]['label'] : $field_value;
                                    $element->attributes->getNamedItem("value")->nodeValue = $field_label;
                                }
                            }
                        }
                    }

                    $element->attributes->getNamedItem("name")->nodeValue = "[" . $element->attributes->getNamedItem("name")->nodeValue . "]";
                }

                // Replace names
                $textareas = $xpath->query("//textarea");
                foreach ($textareas as $element) {
                    $element->attributes->getNamedItem("name")->nodeValue = "[" . $element->attributes->getNamedItem("name")->nodeValue . " wpautop=0]";
                }

                // Replace names
                $selects = $xpath->query("//select");
                foreach ($selects as $element) {

                    if (class_exists('FrmField')) {

                        $options = $xpath->query(".//option", $element);

                        $field_id = $element->attributes->getNamedItem("name")->nodeValue;
                        if (false !== strpos($element->attributes->getNamedItem("name")->nodeValue, ':')) {
                            $field_id = substr($element->attributes->getNamedItem("name")->nodeValue, 0, strpos($element->attributes->getNamedItem("name")->nodeValue, ":"));
                        }

                        $field_data = FrmField::getOne($field_id);

                        if (isset($field_data->type) && ($field_data->type === 'lookup' || $field_data->type === 'data')) {
                            $dynamic_form_id = false;
                            $dynamic_field_id = false;

                            if ($field_data->type === 'lookup' && isset($field_data->field_options['get_values_field']) && isset($field_data->field_options['get_values_form'])) {
                                $dynamic_form_id = $field_data->field_options['get_values_form'];
                                $dynamic_field_id = $field_data->field_options['get_values_field'];

                                if (get_option('e2pdf_formidable_use_keys')) {
                                    $dynamic_field_data = FrmField::getOne($dynamic_field_id);

                                    if ($dynamic_field_data) {
                                        $dynamic_field_id = $dynamic_field_data->field_key;
                                    }
                                }
                            } elseif ($field_data->type === 'data' && isset($field_data->field_options['form_select'])) {
                                $dynamic_field_id = $field_data->field_options['form_select'];
                                $dynamic_field_data = FrmField::getOne($dynamic_field_id);

                                if ($dynamic_field_data) {
                                    $dynamic_form_id = $dynamic_field_data->form_id;

                                    if (get_option('e2pdf_formidable_use_keys')) {
                                        $dynamic_field_id = $dynamic_field_data->field_key;
                                    }
                                }
                            }

                            if ($dynamic_form_id && $dynamic_field_id) {

                                foreach ($options as $option) {
                                    $option->parentNode->removeChild($option);
                                }

                                $wrapper = $dom->createElement('option');
                                $wrapper_atts = array(
                                    'value' => "[e2pdf-frm-entry-values id='{$dynamic_form_id}' field_id='{$dynamic_field_id}']",
                                );
                                foreach ($wrapper_atts as $key => $value) {
                                    $attr = $dom->createAttribute($key);
                                    $attr->value = $value;
                                    $wrapper->appendChild($attr);
                                }
                                $element->appendChild($wrapper);
                            }
                        } else if (isset($field_data->options) && is_array($field_data->options)) {
                            $field_options = $field_data->options;
                            foreach ($options as $option) {
                                $field_value = $option->attributes->getNamedItem("value")->nodeValue;
                                foreach ($field_options as $field_option) {
                                    if (isset($field_option['value']) && $field_option['value'] === $field_value) {
                                        $field_label = isset($field_option['label']) ? $field_option['label'] : $field_value;
                                        $option->attributes->getNamedItem("value")->nodeValue = $field_label;
                                    }
                                }
                            }
                        }
                    }

                    $element->attributes->getNamedItem("name")->nodeValue = "[" . $element->attributes->getNamedItem("name")->nodeValue . "]";
                }

                if ($xpath->query("//form")->item(0) && class_exists('FrmStylesHelper')) {
                    $autocomplete = $dom->createAttribute('autocomplete');
                    $autocomplete->value = 'off';
                    $xpath->query("//form")->item(0)->appendChild($autocomplete);
                }

                return $dom->saveHTML();
            }
        }
        return false;
    }

    /**
     * Convert Field name to Value
     * @since 0.01.34
     * 
     * @param string $name - Field name
     * 
     * @return bool|string - Converted value or false
     */
    public function auto_map($name = false) {

        $item = $this->get('item');

        if ($item && class_exists("FrmField")) {
            $where = array('fi.form_id' => (int) $item,
                "(fi.field_key = '{$name}' OR fi.name = '{$name}') AND 1" => "1"
            );
            $field = FrmField::getAll($where, 'id ASC', '1');

            if ($field && is_object($field)) {
                if ($field->type == 'textarea' || $field->type == 'rte') {
                    return "[" . $field->id . "  wpautop=0]";
                } else {
                    return "[" . $field->id . "]";
                }
            }
        }

        return false;
    }

    /**
     * Load additional shortcodes for this extension
     */
    public function load_shortcodes() {
        add_shortcode('e2pdf-frm-entry-values', array($this, 'shortcode_e2pdf_frm_entry_values'));
        add_shortcode('e2pdf-frm-repeatable', array($this, 'shortcode_e2pdf_frm_repeatable'));
    }

    /**
     * [e2pdf-frm-repeatable id='{entry_id}' field_id='{field_id}'] shortcode
     * 
     * @param array $atts - Atributes for shortcode
     * 
     * @return string - Output of shortcodes
     */
    public function shortcode_e2pdf_frm_repeatable($atts = array()) {
        $id = (int) $atts['id'];
        $field_id = $atts['field_id'];

        $response = "[frm-field-value field_id='{$field_id}' entry='{$id}']";
        return $response;
    }

    /**
     * [e2pdf-frm-entry-values id='{form_id}' field_id='{field_id}' separator=''] shortcode
     * 
     * @param array $atts - Atributes for shortcode
     * 
     * @return string - Output of shortcodes
     */
    public function shortcode_e2pdf_frm_entry_values($atts = array()) {
        $form_id = (int) $atts['id'];
        $field_id = $atts['field_id'];
        $separator = isset($atts['separator']) ? $atts['separator'] : "\r\n";

        $response = '';
        $values = array();
        if ($form_id && $field_id && class_exists('FrmEntry') && class_exists('FrmEntryMeta')) {
            $where = array(
                'it.form_id' => $form_id
            );
            $entries_tmp = FrmEntry::getAll($where, ' ORDER BY id ASC');
            foreach ($entries_tmp as $key => $entry) {
                $values[] = FrmEntryMeta::get_meta_value($entry, $field_id);
            }
        }
        $response = implode($separator, $values);
        return $response;
    }

    /**
     * Get styles for generating Map Field function
     * 
     * @return array - List of css files to load
     */
    public function get_styles() {

        $styles = array();
        if (class_exists('FrmStylesHelper')) {
            $uploads = FrmStylesHelper::get_upload_base();
            $saved_css_path = '/formidable/css/formidablepro.css';
            if (is_readable($uploads['basedir'] . $saved_css_path)) {
                $url = $uploads['baseurl'] . $saved_css_path;
            } else {
                $url = admin_url('admin-ajax.php?action=frmpro_css');
            }

            $styles[] = $url;
        }

        return $styles;
    }

}

```