capwelton / libapp

programs/AppComponent.php

<?php

// -------------------------------------------------------------------------
// OVIDENTIA http://www.ovidentia.org
// Ovidentia is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// -------------------------------------------------------------------------
/**
 * @license http://opensource.org/licenses/gpl-license.php GNU General Public License (GPL)
 * @copyright Copyright (c) 2022 by SI4YOU ({@link https://www.siforyou.com})
 */
namespace Capwelton\LibApp;

use Capwelton\LibApp\Ctrl\AppComponentCtrlRecord;
use Capwelton\LibApp\Interfaces\AppComponentUi;

class AppComponent
{
    
    const ENTRY = 'Entry';
    
    const COUNTRY = 'Country';
    
    const ADDRESS = 'Address';
    
    private $app;
    
    private $set;
    
    private $controller;
    
    private $ui;
    
    private $controllerObject;
    
    private $uiObject;
    
    private $packageName;
    
    public function __construct(Func_App $app, $set = null, $controller = null, $ui = null)
    {
        $this->app = $app;
        $this->set = $set;
        $this->controller = $controller;
        $this->ui = $ui;
    }
    
    /**
     * Returns a multidimensional array with information about required and optional components.
     * The returned array may have 0, 1 or 2 keys : 'requiredComponents' and 'optionalComponents'.
     * Each of these keys is associated to an array of strings for each component name.
     *
     * @return array
     */
    public function checkDependencies()
    {
        $main = new \ReflectionClass($this->set);
        $dependencies = array();
        if($main->hasMethod('getRequiredComponents')){
            $requiredComponents = $this->recordSet()->getRequiredComponents();
            foreach ($requiredComponents as $requiredComponent){
                $dependencies['requiredComponents'][] = $requiredComponent;
            }
        }
        if($main->hasMethod('getOptionalComponents')){
            $optionalComponents = $this->recordSet()->getOptionalComponents();
            foreach ($optionalComponents as $optionalComponent){
                $dependencies['optionalComponents'][] = $optionalComponent;
            }
        }
        
        return $dependencies;
    }
    
    public function setPackageName($packageName)
    {
        $this->packageName = $packageName;
        return $this;
    }
    
    public function getPackageName()
    {
        if(! isset($this->packageName) || empty($this->packageName)){
            $packageName = '';
            $setRc = new \ReflectionClass($this->set);
            // Tries to automatically retrieve the package name from the definition.json
            if($setRc){

$setRc is of type ReflectionClass, thus it always evaluated to true.

                // Get definition file path
                $definitionPathParts = explode('/', $setRc->getFileName());
                $definitionPath = implode('/', (array_splice($definitionPathParts, 0, - 3)));
                $definitionPath .= '/definition.json';
                $definitionContent = file_get_contents($definitionPath);
                if($definitionContent){
                    // Get definition.json content
                    $definitionContent = json_decode($definitionContent, true);
                    if($definitionContent && isset($definitionContent['name'])){
                        // Get name in definition.json
                        $definitionNameParts = explode('/', $definitionContent['name']);
                        $packageName = $definitionNameParts[count($definitionNameParts) - 1];
                    }
                }
            }
            
            $this->packageName = $packageName;
        }
        return $this->packageName;
    }
    
    /**
     * If the component record set has a method onUpdate, this method is called.
     * This method should only be called in the synchronizeComponentsSql method of the addon.
     */
    public function onUpdate()
    {
        $main = new \ReflectionClass($this->set);
        if($main->hasMethod('onUpdate')){
            $this->recordSet()->onUpdate();
        }
    }
    
    /**
     * @return AppComponentCtrlRecord
     */
    public function controller($proxy = true)
    {
        if(! isset($this->controllerObject)){
            $this->app->includeRecordController();
            $ctrl = $this->controller;
            $this->controllerObject = new $ctrl($this->app, $this);
        }
        if($proxy){
            return $this->controllerObject->proxy();
        }
        return $this->controllerObject;
    }
    
    /**
     * @return AppComponentCtrlRecord
     */
    public function proxy()
    {
        return $this->controller();
    }
    
    /**
     * @return AppComponentUi|null
     */
    public function ui()
    {
        $this->app->includeUi();
        if(! isset($this->uiObject)){
            $ui = $this->ui;
            if(! isset($ui)){
                return null;
            }
            $this->uiObject = new $ui($this->app);
        }
        return $this->uiObject;
    }
    
    public function recordSet()
    {
        $set = $this->set;
        return new $set($this->app);
    }
    
    public function getSetClassName()
    {
        $reflectionClass = new \ReflectionClass($this->set);
        return $this->app->classPrefix . $reflectionClass->getShortName();
    }
    
    public function getRecordClassName()
    {
        return substr($this->getSetClassName(), 0, - 3);
    }
    
    public function getName()
    {
        $reflectionClass = new \ReflectionClass($this->set);
        return substr($reflectionClass->getShortName(), 0, - 3);
    }
    
    public function getDefinition()
    {
        $componentDefinitionObjectName = 'Capwelton\App\\' . $this->getPackageName() . '\ComponentDefinition\ComponentDefinition';
        if(class_exists($componentDefinitionObjectName)){
            return new $componentDefinitionObjectName();
        }
        return null;
    }
    
    public function getLangPath()
    {
        $def = $this->getDefinition();
        if($def){
            return $def->getLangPath($this->app);
        }
        return null;
    }
    
    public function getStylePath()
    {
        $def = $this->getDefinition();
        if($def){
            return $def->getStylePath($this->app);
        }
        return null;
    }
    
    public function getScriptPath()
    {
        $def = $this->getDefinition();
        if($def){
            return $def->getScriptPath($this->app);
        }
        return null;
    }
    
    /**
     * @see Func_App::translate()
     * @return string
     */
    public function translate($str, $str_plurals = null, $number = null)
    {
        $currentComponent = $this->app->getCurrentComponent(); // Get actual currentComponent
        $this->app->setCurrentComponent($this); // Set currentComponent to self. This is used in Func_App::translate()
        $translation = $this->app->translate($str, $str_plurals, $number);
        $this->app->setCurrentComponent($currentComponent); // Reset the currentComponent to what it was before
        return $translation;
    }
}