290 lines
8.4 KiB
PHP
290 lines
8.4 KiB
PHP
<?php
|
|
/**
|
|
*The base class for module manager classes. ModuleManager classes which extend this
|
|
* class provide core backend functionality
|
|
*to each module such as defining models, error handliing and other configuration details
|
|
*@class AbstractModuleManager
|
|
*/
|
|
namespace Classes;
|
|
|
|
use Utils\LogManager;
|
|
|
|
abstract class AbstractModuleManager
|
|
{
|
|
|
|
private $fileFieldMappings = array();
|
|
private $userClasses = array();
|
|
private $errorMappings = array();
|
|
private $modelClasses = array();
|
|
|
|
private $modulePath = null;
|
|
private $moduleObject = null;
|
|
private $moduleType = null;
|
|
private $actionManager = null;
|
|
|
|
public function initialize()
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Override this method in module manager class to define user classes.
|
|
* A user class is a class that is mapped to a table having a field named profile.
|
|
* The profile field is mapped to the id of a Profile element.
|
|
* When a user is saving this type of an object in db, profile field will be set to the id of the
|
|
* Profile of currently logged in or switched user.
|
|
* When a user is retriving this type of records, only the records having profile field set to c
|
|
* urrently logged in users profile id will be released.
|
|
* @method initializeUserClasses
|
|
* @example
|
|
public function initializeUserClasses(){
|
|
$this->addUserClass("EmployeeDocument");
|
|
}
|
|
*
|
|
*/
|
|
abstract public function initializeUserClasses();
|
|
|
|
/**
|
|
* Override this method in module manager class to define file field mappings.
|
|
* If you have a table field that stores a name of a file which need to be
|
|
* deleted from the disk when the record is deleted a file field mapping should be added.
|
|
* @method initializeFieldMappings
|
|
* @example
|
|
public function initializeFieldMappings(){
|
|
$this->addFileFieldMapping('EmployeeDocument', 'attachment', 'name');
|
|
}
|
|
*/
|
|
abstract public function initializeFieldMappings();
|
|
|
|
/**
|
|
* Override this method in module manager class to define DB error mappings. Some actions to your
|
|
* model classes trigger database errors.
|
|
* These errors need to be translated to user friendly texts using DB error mappings
|
|
* @method initializeDatabaseErrorMappings
|
|
* @example
|
|
public function initializeDatabaseErrorMappings(){
|
|
$this->addDatabaseErrorMapping('CONSTRAINT `Fk_User_Employee` FOREIGN KEY',"Can not delete Employee,
|
|
* please delete the User for this employee first.");
|
|
$this->addDatabaseErrorMapping("Duplicate entry|for key 'employee'","A duplicate entry found");
|
|
}
|
|
*/
|
|
abstract public function initializeDatabaseErrorMappings();
|
|
|
|
/**
|
|
* Override this method in module manager class to add model classes to this module.
|
|
* All the model classes defind for the module should be added here
|
|
* @method setupModuleClassDefinitions
|
|
* @example
|
|
public function setupModuleClassDefinitions(){
|
|
$this->addModelClass('Employee');
|
|
$this->addModelClass('EmploymentStatus');
|
|
}
|
|
*/
|
|
abstract public function setupModuleClassDefinitions();
|
|
|
|
public function initCalculationHooks()
|
|
{
|
|
}
|
|
|
|
public function initQuickAccessMenu()
|
|
{
|
|
}
|
|
|
|
/**
|
|
* @return null
|
|
*/
|
|
public function getInitializer()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public function setModuleObject($obj)
|
|
{
|
|
$this->moduleObject = $obj;
|
|
}
|
|
|
|
public function getModuleObject()
|
|
{
|
|
return $this->moduleObject;
|
|
}
|
|
|
|
/**
|
|
* @return null
|
|
*/
|
|
public function getActionManager()
|
|
{
|
|
return $this->actionManager;
|
|
}
|
|
|
|
/**
|
|
* @param null $actionManager
|
|
*/
|
|
public function setActionManager($actionManager)
|
|
{
|
|
$this->actionManager = $actionManager;
|
|
}
|
|
|
|
public function setModuleType($type)
|
|
{
|
|
$this->moduleType = $type;
|
|
}
|
|
|
|
public function getModuleType()
|
|
{
|
|
return $this->moduleType;
|
|
}
|
|
|
|
public function getModulePath()
|
|
{
|
|
/*
|
|
$subClass = get_called_class();
|
|
$reflector = new \ReflectionClass($subClass);
|
|
$fn = $reflector->getFileName();
|
|
$this->modulePath = realpath(dirname($fn)."/..");
|
|
LogManager::getInstance()->info("Module Path: [$subClass | $fn]".$this->modulePath);
|
|
*/
|
|
return $this->modulePath;
|
|
}
|
|
|
|
public function setModulePath($modulePath)
|
|
{
|
|
$this->modulePath = $modulePath;
|
|
}
|
|
|
|
public function getDashboardItemData()
|
|
{
|
|
return array();
|
|
}
|
|
|
|
public function getDashboardItem()
|
|
{
|
|
$this->getModulePath();
|
|
if (!file_exists($this->modulePath."/dashboard.html")) {
|
|
//LogManager::getInstance()->error("Dashboard file not found :".$this->modulePath."/dashboard.html");
|
|
return null;
|
|
}
|
|
$dashboardItem = file_get_contents($this->modulePath."/dashboard.html");
|
|
if (empty($dashboardItem)) {
|
|
//LogManager::getInstance()->error("Dashboard file is empty :".$this->modulePath."/dashboard.html");
|
|
return null;
|
|
}
|
|
|
|
$data = $this->getDashboardItemData();
|
|
$data['moduleLink'] = $this->getModuleLink();
|
|
foreach ($data as $k => $v) {
|
|
$dashboardItem = str_replace("#_".$k."_#", $v, $dashboardItem);
|
|
}
|
|
|
|
return $dashboardItem;
|
|
}
|
|
|
|
public function getDashboardItemIndex()
|
|
{
|
|
$metaData = json_decode(file_get_contents($this->modulePath."/meta.json"), true);
|
|
if (!isset($metaData['dashboardPosition'])) {
|
|
return 100;
|
|
} else {
|
|
return $metaData['dashboardPosition'];
|
|
}
|
|
}
|
|
|
|
private function getModuleLink()
|
|
{
|
|
|
|
$metaData = json_decode(file_get_contents($this->modulePath."/meta.json"), true);
|
|
|
|
$mod = basename($this->modulePath);
|
|
$group = basename(realpath($this->modulePath."/.."));
|
|
|
|
//?g=admin&n=candidates&m=admin_Recruitment
|
|
|
|
return CLIENT_BASE_URL."?g=".$group."&n=".$mod."&m=".$group."_".str_replace(" ", "_", $metaData['label']);
|
|
}
|
|
|
|
public function setupRestEndPoints()
|
|
{
|
|
}
|
|
|
|
public function setupFileFieldMappings(&$fileFields)
|
|
{
|
|
foreach ($this->fileFieldMappings as $mapping) {
|
|
if (empty($fileFields[$mapping[0]])) {
|
|
$fileFields[$mapping[0]] = array();
|
|
}
|
|
|
|
$fileFields[$mapping[0]][$mapping[1]] = $mapping[2];
|
|
}
|
|
}
|
|
|
|
public function setupUserClasses(&$userTables)
|
|
{
|
|
foreach ($this->userClasses as $className) {
|
|
if (!in_array($className, $userTables)) {
|
|
$userTables[] = $className;
|
|
}
|
|
}
|
|
}
|
|
|
|
public function setupErrorMappings(&$mysqlErrors)
|
|
{
|
|
foreach ($this->errorMappings as $name => $desc) {
|
|
$mysqlErrors[$name] = $desc;
|
|
}
|
|
}
|
|
|
|
public function getModelClasses()
|
|
{
|
|
return $this->modelClasses;
|
|
}
|
|
|
|
protected function addFileFieldMapping($className, $fieldName, $fileTableFieldName)
|
|
{
|
|
$this->fileFieldMappings[] = array($className, $fieldName, $fileTableFieldName);
|
|
}
|
|
|
|
protected function addUserClass($className)
|
|
{
|
|
$this->userClasses[] = $className;
|
|
}
|
|
|
|
protected function addDatabaseErrorMapping($error, $description)
|
|
{
|
|
$this->errorMappings[$error] = $description;
|
|
}
|
|
|
|
protected function addModelClass($className)
|
|
{
|
|
$this->modelClasses[] = $className;
|
|
BaseService::getInstance()->addModelClass($className, $this->moduleObject['model_namespace']."\\".$className);
|
|
}
|
|
|
|
protected function addHistoryGeneric($type, $table, $refName, $refId, $field, $oldValue, $newValue)
|
|
{
|
|
/* @var \Model\BaseModel $eh */
|
|
$nsTable = BaseService::getInstance()->getFullQualifiedModelClassName($table);
|
|
$eh = new $nsTable();
|
|
$eh->type = $type;
|
|
$eh->$refName = $refId;
|
|
$eh->field = $field;
|
|
$eh->user = BaseService::getInstance()->getCurrentUser()->id;
|
|
$eh->old_value = $oldValue;
|
|
$eh->new_value = $newValue;
|
|
$eh->created = date("Y-m-d H:i:s");
|
|
$eh->updated = date("Y-m-d H:i:s");
|
|
|
|
$eh->Save();
|
|
}
|
|
|
|
public function addCalculationHook($code, $name, $class, $method)
|
|
{
|
|
BaseService::getInstance()->addCalculationHook($code, $name, $class, $method);
|
|
}
|
|
|
|
public function install() {
|
|
|
|
}
|
|
|
|
public function uninstall() {
|
|
|
|
}
|
|
}
|