mirror of
https://github.com/FH-Complete/FHC-Core.git
synced 2026-06-01 20:29:29 +00:00
Alexei Karpenko
319 lines
9.0 KiB
PHP
319 lines
9.0 KiB
PHP
<?php
|
|
/**
|
|
* Copyright (C) 2025 fhcomplete.org
|
|
*
|
|
* This program 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 3 of the License, 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, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
if (! defined('BASEPATH')) exit('No direct script access allowed');
|
|
|
|
class FehlerUpdateLib
|
|
{
|
|
// Who adds phrases into the database
|
|
//const INSERT_BY = 'FehlerUpdate';
|
|
|
|
const CONFIG_DIRECTORY = 'config';
|
|
const CONFIG_FEHLER_NAME = 'fehler';
|
|
const CONFIG_FEHLER_INDEX = 'fehler';
|
|
|
|
const TYPE_STRING = 'string';
|
|
const TYPE_ARRAY = 'array';
|
|
|
|
//~ // Array elements names
|
|
const FEHLERCODE = 'fehlercode';
|
|
const FEHLER_KURZBZ = 'fehler_kurzbz';
|
|
const FEHLERTEXT = 'fehlertext';
|
|
const FEHLERTYP_KURZBZ = 'fehlertyp_kurzbz';
|
|
const APP = 'app';
|
|
const FEHLERCODE_EXTERN = 'fehlercode_extern';
|
|
|
|
// structure of a fehler
|
|
// type default: string
|
|
const FEHLER_ATTRIBUTES = [
|
|
self::FEHLERCODE => ['required' => true],
|
|
self::FEHLER_KURZBZ => ['required' => false],
|
|
self::FEHLERTEXT => ['required' => true],
|
|
self::FEHLERTYP_KURZBZ => ['required' => false],
|
|
self::APP => ['required' => true, 'types' => [self::TYPE_STRING, self::TYPE_ARRAY]],
|
|
self::FEHLERCODE_EXTERN => ['required' => false]
|
|
];
|
|
|
|
private $_ci; // Code igniter instance
|
|
|
|
/**
|
|
* Loads parser library
|
|
*/
|
|
public function __construct()
|
|
{
|
|
$this->_ci =& get_instance();
|
|
|
|
// Loads EPrintfLib
|
|
$this->_ci->load->library('EPrintfLib');
|
|
|
|
// Loads the Models
|
|
$this->_ci->load->model('system/Fehler_model', 'FehlerModel');
|
|
$this->_ci->load->model('system/App_model', 'AppModel');
|
|
|
|
// Loads extensions lib
|
|
$this->_ci->load->library('ExtensionsLib');
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------------------------
|
|
// Public methods
|
|
|
|
|
|
/**
|
|
*
|
|
* @param
|
|
* @return object success or error
|
|
*/
|
|
public function installAll()
|
|
{
|
|
$this->installFromCore();
|
|
|
|
// load fehler entries of extensions
|
|
$extensions = $this->_ci->extensionslib->getInstalledExtensions();
|
|
|
|
if (hasData($extensions))
|
|
{
|
|
$extensionArray = array();
|
|
|
|
$extensionsData = getData($extensions);
|
|
|
|
foreach ($extensionsData as $ext)
|
|
{
|
|
$this->installFrom($ext->name);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Install fehler from the core
|
|
*/
|
|
public function installFromCore()
|
|
{
|
|
$this->_installFehler();
|
|
}
|
|
|
|
/**
|
|
* Install fehler from the given path
|
|
*/
|
|
public function installFrom($extensionName)
|
|
{
|
|
if (!isset($extensionName))
|
|
{
|
|
$this->_ci->eprintflib->printError('Extension name missing!');
|
|
return;
|
|
}
|
|
|
|
$this->_installFehler(ExtensionsLib::EXTENSIONS_DIR_NAME.'/'.$extensionName.'/'.FehlerUpdateLib::CONFIG_FEHLER_NAME);
|
|
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------------------------------------------
|
|
// Private methods
|
|
|
|
/**
|
|
* Install fehler from the given directory
|
|
*/
|
|
private function _installFehler($fehlerConfigDirectory = null)
|
|
{
|
|
// check that fehler config file exists
|
|
$configDir = isset($fehlerConfigDirectory) ? $fehlerConfigDirectory : self::CONFIG_FEHLER_NAME;
|
|
|
|
$configFilename = APPPATH.self::CONFIG_DIRECTORY.'/'.$configDir.'.php';
|
|
|
|
if (!file_exists($configFilename))
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Load Fehler Entries
|
|
$this->_ci->load->config($configDir);
|
|
$configArray = $this->_ci->config->item(self::CONFIG_FEHLER_INDEX);
|
|
|
|
if (!isset($configArray) || !is_array($configArray)) // check if fehler config entries could be loaded
|
|
{
|
|
$this->_ci->eprintflib->printError(
|
|
'Fehler config array could not be loaded, directory '.$configDir.' index '.self::CONFIG_FEHLER_INDEX
|
|
);
|
|
return;
|
|
}
|
|
|
|
$this->_ci->eprintflib->printInfo('------------------------------------------------------------------------------------------');
|
|
$this->_ci->eprintflib->printInfo('Fehler installation started, directory '.$configDir);
|
|
|
|
foreach ($configArray as $idx => $configEntry)
|
|
{
|
|
// create fehler from config entry
|
|
$createFehlerResult = $this->_createFehlerFromEntry($configEntry);
|
|
|
|
// write error if creation failed
|
|
if (isError($createFehlerResult))
|
|
{
|
|
$this->_ci->eprintflib->printError(
|
|
getError($createFehlerResult).', directory '.$configDir.', index '.$idx
|
|
);
|
|
}
|
|
elseif (hasData($createFehlerResult))
|
|
{
|
|
// add fehler to db
|
|
$addFehlerResult = $this->_addFehler(getData($createFehlerResult));
|
|
|
|
if (isError($addFehlerResult))
|
|
{
|
|
$this->_ci->eprintflib->printError(
|
|
getError($addFehlerResult).', directory'.$configDir.', index '.$idx
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
$this->_ci->eprintflib->printInfo('Fehler installation ended');
|
|
$this->_ci->eprintflib->printInfo('------------------------------------------------------------------------------------------');
|
|
}
|
|
|
|
/**
|
|
* Add a new fehler to the database
|
|
*/
|
|
private function _addFehler($fehler)
|
|
{
|
|
// Checks if the fehler already exists in the database
|
|
$this->_ci->FehlerModel->addSelect(self::FEHLERCODE.', '.self::FEHLER_KURZBZ);
|
|
$this->_ci->FehlerModel->db->where(self::FEHLERCODE.' = ', $fehler[self::FEHLERCODE]);
|
|
if ($fehler[self::FEHLER_KURZBZ] != null) $this->_ci->FehlerModel->db->or_where(self::FEHLER_KURZBZ.' = ', $fehler[self::FEHLER_KURZBZ]);
|
|
$fehlerResult = $this->_ci->FehlerModel->load();
|
|
|
|
// If an error occurred then return the error itself
|
|
if (isError($fehlerResult)) return $fehlerResult;
|
|
|
|
// if fehler has been found
|
|
if (hasData($fehlerResult))
|
|
{
|
|
$foundFehler = getData($fehlerResult)[0];
|
|
|
|
// check if fehlercode - fehler kurzbz combination is correct
|
|
if ($foundFehler->{self::FEHLERCODE} != $fehler[self::FEHLERCODE] || $foundFehler->{self::FEHLER_KURZBZ} != $fehler[self::FEHLER_KURZBZ])
|
|
{
|
|
return error("Wrong fehlercode - fehler kurzbz combination: ".$fehler[self::FEHLERCODE].", ".$fehler[self::FEHLER_KURZBZ]);
|
|
}
|
|
|
|
$this->_ci->eprintflib->printMessage(
|
|
"Fehler ".$fehler[self::FEHLERCODE]
|
|
.(isset($fehler[self::FEHLER_KURZBZ]) ? " (".$fehler[self::FEHLER_KURZBZ].")" : "")
|
|
." already exists in database"
|
|
);
|
|
|
|
return success($fehler[self::FEHLERCODE]);
|
|
}
|
|
|
|
// no fehler has been found
|
|
|
|
// handle apps
|
|
if (isset($fehler[self::APP]))
|
|
{
|
|
$apps = $fehler[self::APP];
|
|
if (is_string($apps)) $apps = [$apps];
|
|
|
|
foreach ($apps as $app)
|
|
{
|
|
// check if app exists in db
|
|
$this->_ci->AppModel->addSelect('1');
|
|
$appRes = $this->_ci->AppModel->loadWhere(['app' => $app]);
|
|
|
|
if (!hasData($appRes)) return error("App ".$app." does not exist");
|
|
// TODO add entry for each app
|
|
}
|
|
|
|
$fehler[self::APP] = $apps[0];
|
|
}
|
|
|
|
// Then add the fehler to the database
|
|
$fehlerInsertResult = $this->_ci->FehlerModel->insert(
|
|
$fehler
|
|
// TODO: add insertamum?
|
|
//~ array(
|
|
//~ 'insertamum' => 'NOW()',
|
|
//~ 'insertvon' => self::INSERT_BY
|
|
//~ )
|
|
);
|
|
|
|
// If an error occurred then return the error itself
|
|
if (isError($fehlerInsertResult)) return $fehlerInsertResult;
|
|
|
|
// Prints info about the new added fehler
|
|
$this->_ci->eprintflib->printMessage(
|
|
sprintf(
|
|
'A new fehler has been added into the database: '.
|
|
'fehlercode => %s | fehler_kurzbz => %s | fehlertyp => %s',
|
|
$fehler[self::FEHLERCODE],
|
|
$fehler[self::FEHLER_KURZBZ],
|
|
$fehler[self::FEHLERTYP_KURZBZ]
|
|
)
|
|
);
|
|
|
|
// If here then no blocking errors occurred
|
|
return success();
|
|
}
|
|
|
|
/**
|
|
* Create an array with fehler data from config entry
|
|
*/
|
|
private function _createFehlerFromEntry($configEntry)
|
|
{
|
|
$fehler = [];
|
|
foreach (self::FEHLER_ATTRIBUTES as $attributeName => $attributeConditions)
|
|
{
|
|
$required = isset($attributeConditions['required']) && $attributeConditions['required'];
|
|
if ($required && !isset($configEntry[$attributeName]))
|
|
{
|
|
return error('attribute'.$attributeName.' is missing');
|
|
}
|
|
|
|
$attributeValue = $configEntry[$attributeName];
|
|
$validType = false;
|
|
if (isset($attributeConditions['types']) && is_array($attributeConditions['types']))
|
|
{
|
|
foreach ($attributeConditions['types'] as $type)
|
|
{
|
|
switch ($type)
|
|
{
|
|
case self::TYPE_STRING:
|
|
if (is_string($attributeValue) || is_null($attributeValue)) $validType = true;
|
|
break;
|
|
case self::TYPE_ARRAY:
|
|
if (is_array($attributeValue) && !($required && isEmptyArray($attributeValue))) $validType = true;
|
|
break;
|
|
//~ default:
|
|
//~ if (is_string($configEntry[$attributeName]) || is_null($configEntry[$attributeName])) $validType = true;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$validType = is_string($attributeValue) || is_null($attributeValue);
|
|
}
|
|
|
|
if (!$validType)
|
|
{
|
|
return error('attribute'.$attributeName.' has invalid type');
|
|
}
|
|
|
|
$fehler[$attributeName] = $configEntry[$attributeName];
|
|
}
|
|
return success($fehler);
|
|
}
|
|
}
|