Subversion Repositories web.creative

<?php

/**
* SettingsFactory
* Create unlimited settings pages from JSON and PHP
*
* @author Macrura
*
* ProcessWire 3.x
* Copyright (C) 2011 by Ryan Cramer
* Licensed under GNU/GPL v2, see LICENSE.TXT
*
* http://www.processwire.com
* http://www.ryancramer.com
*
*/
class SettingsFactory extends WireData implements Module, ConfigurableModule  {

    public static function getModuleInfo() {
        return array(
            'title' => __('Settings Factory', __FILE__),
            'summary' => __('Create Unlimited Settings Pages!', __FILE__),
            'version' => '1.0.6',
            'author'    => 'Macrura',
            'permanent' => false,
            'autoload' => true,
            'icon' => 'check-square-o',
            'installs' => 'ProcessSettingsFactory'
        );
    }

    protected static $configDefaults = array(
        'instructions' => '',
    );

    /**
    * Set our configuration defaults
    *
    */
    public function __construct() {
        $configDefaults = self::$configDefaults;
        foreach($configDefaults as $key => $value) {
            $this->set($key, $value);
        }
    }


    public function init() {
        $this->buildFactory();
    }

    public function ready() {
        //$this->buildFactory();
    }


    public function buildFactory() {

        /**
        * Look for all settings pages, read the name of the page, and and inputfield names into a this module's properties.
        * thanks @Zeka for fixing this pages find
        */
        $module_id = wire('modules')->getModuleInfo('ProcessSettingsFactory')['id'];
        $settingsPages = $this->wire('pages')->find("template=admin, process=$module_id");

        foreach($settingsPages as $sp) {
            if($sp->sp_filepath) {
                $key = $sp->name;
                $settingsArray = array();
                $path = wire('config')->paths->templates .  $sp->sp_filepath;
                if(file_exists($path)) {
                    $pathParts = pathinfo($path);

                    if($pathParts['extension'] == 'json') {
                        $json = file_get_contents($path);
                        $fArray = json_decode($json, true);
                        if($fArray === null) {
                            $this->error('Your json file must return valid JSON array of inputfields.');
                            continue;
                        }
                    }

                    if($pathParts['extension'] == 'php') {
                        $fArray = wireRenderFile($path);
                        if($fArray === null) {
                            $this->error('Your php file must return valid array of inputfields.');
                            continue;
                        }
                    }

                    // support for WireTabs (or nested wrappers are returned by file)
                    $fArray = $this->extractInputfields($fArray);
                    foreach($fArray as $field) {
                        if(!$field['name']) continue;
                        $value = isset($field['value']) ? $field['value'] : '';
                        $settingsArray[$field['name']] = $value;
                    }
                    $this->set($key, $settingsArray);
                } // end if file exists
            } // end if there is a filepath specified
        } // end foreach pages


    }


    /**
    * Extract the inputfields from nested tabs/fieldsets
    */
    public function extractInputfields($inputfields) {
        $inputfieldsArray = new InputfieldWrapper();
        foreach($inputfields as $field) {
            if(is_array($field)) $inputfieldsArray->importArray($field);
            elseif($field instanceof InputfieldWrapper) $inputfieldsArray->import($field->getAll());
        }
        return $inputfieldsArray->getAll();
    }



    /**
    * Get the settings for frontend api.
    * default to WireArray for returned object
    */
    public function getSettings($key, $wireData = true) {

        $languages = ($this->wire('languages')) ? $this->wire('languages') : '';
        $nonDefaultLanguages = ($languages) ? $languages->findNonDefault() : '';

        $user = $this->wire('user');
        $settings = $this->modules->getConfig('SettingsFactory'); // or $this?
        if(empty($settings[$key])) return;
        $dataArray = $settings[$key];
        $settingsFields = $this[$key];

        $newDataArray = array();

        foreach ($settingsFields as $key => $value) {
            if ($nonDefaultLanguages && $user->language !== $languages->getDefault()) {
                $key_lang = $key . "__" . $user->language->id;
                if (array_key_exists($key_lang, $dataArray)) {
                    $newDataArray[$key] = $dataArray[$key_lang] ? $dataArray[$key_lang] : $dataArray[$key];
                } else {
                    $newDataArray[$key] = $dataArray[$key];
                }
            //} else {
            } else if(isset($dataArray[$key])) { // 6/5/20 @martijn
                $newDataArray[$key] = $dataArray[$key];
            }
        }

        if(!$wireData) return $newDataArray;
        // convert to object
        $key = new WireData();
        $key->setArray($newDataArray);
        return $key;
    }

    /**
    * Get the settings in plain array for frontend api.
    */
    public function getSettingsArray($key) {
        return $this->getSettings($key, false);
    }


    /**
    * Called only when your module is installed
    *
    * This version creates a new page with this Process module assigned.
    *
    */
    public function ___install() {
        // Check for existence of the field below, throw a message if it already exists
        if($this->fields->get('sp_filepath') == NULL) {
            // If it doesn't exist then and create it
            $field = new Field();
            $field->type = $this->modules->get("FieldtypeText");
            $field->name = 'sp_filepath';
            $field->label = __('Inputfields Definition File Path.');
            $field->description = __('Path to the file that defines the inputfields - json or php. Relative to templates folder.');
            $field->notes = __('See the examples included in the modules to get started.');
            //$field->placeholder = __('settings/site-settings.php');
            $field->showIf = 'process=ProcessSettingsFactory';
            $field->save();
        }

        // add to admin template, set visibility to only for the process
        $adminTemplate = $this->templates->get('admin');
        $adminTemplate->fields->add($field);
        $adminTemplate->fields->save();
        $this->message(__("Added field 'sp_filepath' to admin template."));
    }

    /**
    * Called only when your module is uninstalled
    * This should return the site to the same state it was in before the module was installed.
    *
    */
    public function ___uninstall() {

        // 1) Remove the path field from the template
        $adminTemplate = $this->templates->get('admin');
        if($adminTemplate->fields->get('sp_filepath')) {
            $adminTemplate->fields->remove($adminTemplate->fields->get('sp_filepath'));
            $adminTemplate->fields->save();
        }

        // 2) Remove the field sp_filepath
        if($this->fields->get('sp_filepath')) {
            $field = $this->fields->get('sp_filepath');
            $this->fields->delete($field);
        }

    }


    public static function getModuleConfigInputfields(array $data) {

        foreach(self::$configDefaults as $key => $value) {
            if(!isset($data[$key])||$data[$key]=="") $data[$key] = $value;
        }

        $inputfields = new InputfieldWrapper();

        /* INSTRUCTIONS
        ------------------------------------------------------------------------ */
        $f = wire('modules')->get('InputfieldMarkup');
        $f->name  = 'instructions';
        $f->label = __('Instructions', __FILE__);
        $f->markupText = __('Create your processes then enter a path to the json or php definition file of the fields in the path field.', __FILE__);
        $inputfields->add($f);

        return $inputfields;

    }

    /**
     * @var $key - the settings key
     * @var $_key - the setting within the key
     * @var $value - the new value
     */
    public function changeSetting($key,$_key,$value) {

        $modData = $this->modules->getConfig('SettingsFactory');
        if(!array_key_exists($key, $modData)) return;
        if(!array_key_exists($_key, $modData[$key])) return;
        $modData[$key][$_key] = $value;
        $this->modules->saveModuleConfigData('SettingsFactory', $modData);

    }


}