DefaultPlugin.php

<?php
/*
 SPDX-FileCopyrightText: © 2014-2016 Siemens AG
 Author: Andreas Würl
 
 SPDX-License-Identifier: GPL-2.0-only
*/
 
namespace Fossology\Lib\Plugin;
 
use Fossology\Lib\Auth\Auth;
use Fossology\Lib\UI\Component\Menu;
use Fossology\Lib\UI\Component\MicroMenu;
use Monolog\Logger;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\Session\Session;
use Twig_Environment;
 
abstract class DefaultPlugin implements Plugin
{
  const PERMISSION = "permission";
  const REQUIRES_LOGIN = "requiresLogin";
  const ENABLE_MENU = "ENABLE_MENU";
  const LEVEL = "level";
  const DEPENDENCIES = "dependencies";
  const INIT_ORDER = "initOrder";
  const MENU_LIST = "menuList";
  const MENU_ORDER = "menuOrder";
  const MENU_TARGET = "menuTarget";
  const TITLE = "title";
 
  protected $container;
  protected $renderer;
  private $session;
  private $logger;
  private $menu;
  protected $microMenu;
  private $name;
  private $version = "1.0";
  private $title;
  private $permission = Auth::PERM_NONE;
  private $requiresLogin = true;
  private $PluginLevel = 10;
  private $dependencies = array();
  private $InitOrder = 0;
 
  private $MenuList = NULL;
  private $MenuOrder = 0;
  private $MenuTarget = NULL;
 
  public function __construct($name, $parameters = array())
  {
    if ($name === null || $name === "") {
      throw new \InvalidArgumentException("plugin requires a name");
    }
    $this->name = $name;
    foreach ($parameters as $key => $value) {
      $this->setParameter($key, $value);
    }
 
    global $container;
    $this->container = $container;
    $this->session = $this->getObject('session');
    $this->renderer = $this->getObject('twig.environment');
    $this->logger = $this->getObject('logger');
    $this->menu = $this->getObject('ui.component.menu');
    $this->microMenu = $this->getObject('ui.component.micromenu');
  }
 
  private function setParameter($key, $value)
  {
    switch ($key) {
      case self::TITLE:
        $this->title = $value;
        break;
 
      case self::PERMISSION:
        $this->permission = $value;
        break;
 
      case self::REQUIRES_LOGIN:
        $this->requiresLogin = $value;
        break;
 
      case self::LEVEL:
        $this->PluginLevel = $value;
        break;
 
      case self::DEPENDENCIES:
        $this->dependencies = $value;
        break;
 
      case self::INIT_ORDER:
        $this->InitOrder = $value;
        break;
 
      case self::MENU_LIST:
        $this->MenuList = $value;
        break;
 
      case self::MENU_ORDER:
        $this->MenuOrder = $value;
        break;
 
      case self::MENU_TARGET:
        $this->MenuTarget = $value;
        break;
 
      default:
        throw new \Exception("unhandled parameter $key in module " . $this->name);
    }
  }
 
  public function getName()
  {
    return $this->name;
  }
 
  public function getVersion()
  {
    return $this->version;
  }
 
  public function getTitle()
  {
    return $this->title;
  }
 
  public function isRequiresLogin()
  {
    return $this->requiresLogin;
  }
 
  public function getDependency()
  {
    return $this->dependencies;
  }
 
  public function getPluginLevel()
  {
    return $this->PluginLevel;
  }
 
  public function getDBaccess()
  {
    return $this->permission;
  }
 
  public function getState()
  {
    return PLUGIN_STATE_READY;
  }
 
  public function getInitOrder()
  {
    return $this->InitOrder;
  }
 
 
  public function getNoMenu()
  {
    return 0;
  }
 
  protected function RegisterMenus()
  {
    if (isset($this->MenuList) && (!$this->requiresLogin || $this->isLoggedIn())) {
      menu_insert("Main::" . $this->MenuList, $this->MenuOrder, $this->name, $this->name);
    }
  }
 
  public function getResponse()
  {
    $request = Request::createFromGlobals();
    $request->setSession($this->session);
 
    $this->checkPrerequisites();
 
    $startTime = microtime(true);
    $response = $this->handle($request);
    $response->prepare($request);
    $this->logger->debug(sprintf("handle request in %.3fs", microtime(true) - $startTime));
    return $response;
  }
 
  public function getObject($name)
  {
    return $this->container->get($name);
  }
 
  public function preInstall()
  {
    $this->RegisterMenus();
  }
 
  public function postInstall()
  {
  }
 
  public function unInstall()
  {
  }
 
  public function execute()
  {
    $startTime = microtime(true);
 
    $response = $this->getResponse();
 
    $this->logger->debug(sprintf("prepare response in %.3fs", microtime(true) - $startTime));
 
    $response->send();
  }
 
  protected abstract function handle(Request $request);
 
  protected function render($templateName, $vars = null, $headers = null)
  {
    if ($this->requiresLogin && !$this->isLoggedIn()) {
      new Response("permission denied", Response::HTTP_FORBIDDEN, array("contentType" => "text/plain"));
    }
 
    $startTime = microtime(true);
 
    $content = $this->renderer->load($templateName)
        ->render($vars ?: $this->getDefaultVars());
 
    $this->logger->debug(sprintf("%s: render response in %.3fs", get_class($this), microtime(true) - $startTime));
    return new Response(
        $content,
        Response::HTTP_OK,
        $headers ?: $this->getDefaultHeaders()
    );
  }
 
  public function isLoggedIn()
  {
    return (!empty($_SESSION[Auth::USER_NAME]) && $_SESSION[Auth::USER_NAME] != 'Default User');
  }
 
  private function checkPrerequisites()
  {
    if ($this->requiresLogin && !$this->isLoggedIn()) {
      throw new \Exception("not allowed without login");
    }
 
    foreach ($this->dependencies as $dependency) {
      $id = plugin_find_id($dependency);
      if ($id < 0) {
        $this->unInstall();
        throw new \Exception("unsatisfied dependency '$dependency' in module '" . $this->getName() . "'");
      }
    }
  }
 
  protected function getDefaultHeaders()
  {
    return array(
        'Content-type' => 'text/html',
        'Pragma' => 'no-cache',
        'Cache-Control' => 'no-cache, must-revalidate, maxage=1, post-check=0, pre-check=0',
        'Expires' => 'Expires: Thu, 19 Nov 1981 08:52:00 GMT');
  }
 
  protected function getDefaultVars()
  {
    $vars = array();
 
    $metadata = "<meta name='description' content='The study of Open Source'>\n";
    $metadata .= "<meta http-equiv='Content-Type' content='text/html;charset=UTF-8'>\n";
    $metadata .= "<meta name='viewport' content='width=device-width,initial-scale=1.0'>\n";
 
    $vars['metadata'] = $metadata;
 
    if (!empty($this->title)) {
      $vars[self::TITLE] = htmlentities($this->title);
    }
 
    $styles = "<link rel='stylesheet' href='css/jquery-ui.css'>\n";
    $styles .= "<link rel='stylesheet' href='css/select2.min.css'>\n";
    $styles .= "<link rel='stylesheet' href='css/jquery.dataTables.css'>\n";
    $styles .= "<link rel='stylesheet' href='css/fossology.css'>\n";
    $styles .= "<link rel='stylesheet' href='css/bootstrap/bootstrap.min.css'>\n";
    $styles .= "<link rel='stylesheet' href='css/bootstrap-icons.css'>\n";
    $styles .= "<link rel='icon' type='image/x-icon' href='favicon.ico'>\n";
    $styles .= "<link rel='shortcut icon' type='image/x-icon' href='favicon.ico'>\n";
 
    $styles .= $this->menu->OutputCSS();
 
    $vars['styles'] = $styles;
 
    $vars['menu'] = $this->menu->Output($this->title);
 
    global $SysConf;
    if (array_key_exists('BUILD', $SysConf)) {
      $vars['versionInfo'] = array(
          'version' => $SysConf['BUILD']['VERSION'],
          'buildDate' => $SysConf['BUILD']['BUILD_DATE'],
          'commitHash' => $SysConf['BUILD']['COMMIT_HASH'],
          'commitDate' => $SysConf['BUILD']['COMMIT_DATE'],
          'branchName' => $SysConf['BUILD']['BRANCH']
      );
    }
 
    return $vars;
  }
 
  protected function mergeWithDefault($vars)
  {
    return array_merge($this->getDefaultVars(), $vars);
  }
 
  protected function flushContent($content)
  {
    return $this->render("include/base.html.twig",$this->mergeWithDefault(array("content"=>$content)));
  }
 
  public function __get($name)
  {
    if (method_exists($this, ($method = 'get' . ucwords($name)))) {
      return $this->$method();
    } else {
      throw new \Exception("property '$name' not found in module " . $this->name);
    }
  }
 
  function __toString()
  {
    return getStringRepresentation(get_object_vars($this), get_class($this));
  }
}