se/SE/se-lib/Schema/SystemObjectStorageAcl.php

<?php

Lib::loadClass('Core_AclSimpleSchemaBase');
Lib::loadClass('ParseOgcFilter');
Lib::loadClass('Router');
Lib::loadClass('SchemaVersionUpgrade');

class Schema_SystemObjectStorageAcl extends Core_AclSimpleSchemaBase {

	public $_simpleSchema = [
		'root' => [
			'@namespace' => 'default_objects/SystemObject',
			'@primaryKey' => 'namespace',
			'idZasob' => [ '@type' => 'xsd:integer' ],
			'idDatabase' => [ '@type' => 'xsd:integer' ],
			'namespace' => [ '@type' => 'xsd:string' ],
			'_rootTableName' => [ '@type' => 'xsd:string' ],
			'_type' => [ '@type' => 'xsd:string' ],
			'hasStruct' => [ '@type' => 'xsd:integer' ], // 0 - removed, old, 1 - has config, structure
			'isStructInstalled' => [ '@type' => 'xsd:integer' ], // installed
			'isObjectActive' => [ '@type' => 'xsd:integer' ], // (0,1) - admin settings with restrictions: (hasStruct, isStructInstalled, all fields installed and with idZasob)
			'description' => [ '@type' => 'xsd:string' ],
			'name' => [ '@type' => 'p5:string' ],
			'typeName' => [ '@type' => 'p5:string' ],
			'nsPrefix' => [ '@type' => 'p5:string' ],
			'reinstallLink' => [ '@type' => 'p5:www_link' ],
			'instanceTableSource' => [ '@type' => 'xsd:string' ], // enum('table', 'view') default 'view'
			// 'A_RECORD_CREATE_AUTHOR' => [ '@type' => 'xsd:string' , '@label' => 'autor' ],
			// 'A_RECORD_CREATE_DATE' => [ '@type' => 'xsd:date' , '@label' => 'utworzono' ],
			// 'A_RECORD_UPDATE_AUTHOR' => [ '@type' => 'xsd:string' , '@label' => 'zaktualizował' ],
			// 'A_RECORD_UPDATE_DATE' => [ '@type' => 'xsd:date', '@label' => 'zaktualizowano' ],
			'field' => [ '@ref' => 'default_objects/SystemObjectField', '@maxOccurs' => 'unbounded' ]
		]
	];
	// public $_rootTableName = 'CRM_LISTA_ZASOBOW';
	public $_rootTableName = 'CRM_#CACHE_ACL_OBJECT';

	public function __construct($simpleSchema = null) {
		parent::__construct($simpleSchema);
		SchemaVersionUpgrade::upgradeSchema();
	}

	public function updateCache($idDatabase = null) {
		DBG::simpleLog('schema', "SystemObject::updateCache...");
		// DB::getPDO()->execSql(" drop table if exists `{$this->_rootTableName}` "); // TODO: DBG
		DB::getPDO()->execSql(" update `{$this->_rootTableName}` set hasStruct = 0 ");

		$sourceStorage = SchemaFactory::loadDefaultObject('SystemSource');
		$listSourceToUpdate = $sourceStorage->getItems([ 'f_hasConfig' => 1 ]);
		foreach ($listSourceToUpdate as $source) {
			if ('default_objects' == $source['nsPrefix']) {
				$this->_updateDefaultObjectsStorageAclCache($source['idZasob']);
			}
			else {
				try {
					$this->_updateDatabaseCache($source);
				} catch (AlertWarningException $e) {
					UI::alert('warning', "Warning source '{$source['idZasob']}': " . $e->getMessage());
					continue;
				} catch (Exception $e) {
					UI::alert('danger', "Error source '{$source['idZasob']}': " . $e->getMessage());
					continue;
				}
			}
		}

		// Ant objects in: SE/schema/ant-object/
		$basePath = APP_PATH_SCHEMA . "/ant-object";
		foreach (glob("{$basePath}/*/*/build.xml", GLOB_NOSORT) as $buildXmlPath) {
			try {
				$this->_updateAntObjectCache($buildXmlPath, $basePath);
			} catch (Exception $e) {
				UI::alert('danger', $e->getMessage());
			}
		}

		if ($activeProject = Config::getProjectPath()) {
			$baseAntObjectPath = "{$activeProject}/schema/ant-object";
			DBG::nicePrint($baseAntObjectPath, "\$baseAntObjectPath");
			foreach (glob("{$baseAntObjectPath}/*/*/build.xml", GLOB_NOSORT) as $buildXmlPath) {
				try {
					$this->_updateAntObjectCache($buildXmlPath, $baseAntObjectPath);
				} catch (Exception $e) {
					UI::alert('danger', $e->getMessage());
				}
			}
		}

		// Fix objects AntAcl which struct is not installed
		$listAntAclObjectsToFix = DB::getPDO()->fetchAll("
			select t.*
			from `CRM_#CACHE_ACL_OBJECT` t
			where t._type = 'AntAcl'
				and t.idZasob is not NULL
				and t.hasStruct = 1
				and t.isStructInstalled = 0
		");
		if (!empty($listAntAclObjectsToFix)) {
			UI::alert('info', "Fix AntAcl objects which is not installed (total: ".count($listAntAclObjectsToFix).")");
			foreach ($listAntAclObjectsToFix as $antAclInfo) {
				$namespace = $antAclInfo['namespace'];
				DBG::nicePrint($antAclInfo, "\$antAclInfo ({$namespace})");
				$zasobyStruct = DB::getPDO()->fetchAll("
					select z.ID, z.`DESC`
					from `CRM_LISTA_ZASOBOW` z
					where z.PARENT_ID = :parent_id
						and z.`TYPE` = 'KOMORKA'
						and z.A_STATUS not in ('DELETED')
				", [ ':parent_id' => $antAclInfo['idZasob'] ]);
				DBG::nicePrint($zasobyStruct, "\$zasobyStruct ({$namespace})");

				ob_start();
				{
					Lib::loadClass('Schema_SystemObjectFieldStorageAcl');

					{ // check if build.xml file still eixsts
						$item = [];
						$exNs = explode('/', $namespace);
						$item['name'] = array_pop($exNs);
						$item['nsPrefix'] = implode('__x3A__', $exNs);
						$item['typeName'] = implode('__x3A__', $exNs) . ':' . $item['name'];

						$antAclPath = Schema_SystemObjectFieldStorageAcl::getAntAclXsdBasePath($item['typeName']);
						if (!file_exists("{$antAclPath}/build.xml")) {
							UI::alert('danger', "Ant build file not exists for namespace '{$antAclInfo['namespace']}' - Removing AntAcl");
							Schema_SystemObjectStorageAcl::deleteObjectFromCache($antAclInfo['idZasob'], $antAclInfo['namespace']);

							// throw new Exception("Ant build file not exists #TEST_OFF");
							continue;
						}
					}

					$objFieldAcl = new Schema_SystemObjectFieldStorageAcl();
					try {
						$objFieldAcl->updateCache($namespace);
					} catch (Exception $e) {
						UI::alert('danger', $e->getMessage());
						Schema_SystemObjectStorageAcl::deleteObjectFromCache($antAclInfo['idZasob'], $antAclInfo['namespace']);
						continue;
					}
					$reinstallLog = ob_get_clean();
				}
				// DBG::nicePrint($reinstallLog, "\$reinstallLog ({$namespace})");

				$fieldCacheStruct = DB::getPDO()->fetchAll("
					select t.namespace, t.fieldNamespace
					from `CRM_#CACHE_ACL_OBJECT_FIELD` t
					where t.objectNamespace = :namespace
						and t.idZasob is NULL
				", [ ':namespace' => $namespace ]);
				DBG::nicePrint($fieldCacheStruct, "\$fieldCacheStruct ({$namespace})");

				$fieldsToFix = [];
				foreach ($fieldCacheStruct as $cacheField) {
					$fieldName = $cacheField['fieldNamespace'];
					foreach ($zasobyStruct as $fieldZasob) {
						if ($fieldZasob['DESC'] === $fieldName) {
							$fieldsToFix[] = [
								'idZasob' => $fieldZasob['ID'],
								'namespace' => $cacheField['namespace'],
							];
						}
					}
				}
				DBG::nicePrint($fieldsToFix, "\$fieldsToFix ({$namespace})");

				foreach ($fieldsToFix as $fixField) {
					$affected = SchemaFactory::loadDefaultObject('SystemObjectField')->updateItem([
						'namespace' => $fixField['namespace'],
						'idZasob' => $fixField['idZasob']
					]);
					if (!$affected) UI::alert('warning', "field ({$fixField['namespace']}) update idZasob failed");
				}

				$affected = SchemaFactory::loadDefaultObject('SystemObject')->updateItem([
					'namespace' => $namespace,
					'isObjectActive' => 1
				]);
				($affected)
				?	UI::alert('success', "object ({$namespace}) activated")
				:	UI::alert('warning', "object ({$namespace}) activation failed");
			}
		}

		// // foreach ... DB::getPDO($idDatabase)->fetchAll(select real _rootTableName)
		// foreach (Core_AclHelper::getCustomAclList() as $typeName) {
		//	 $ns = Core_AclHelper::parseTypeName($typeName);
		//	 $namespace = str_replace('__x3A__', '/', $ns['prefix']) . "/{$ns['name']}";
		//	 $sqlNs = DB::getPDO()->quote($namespace, PDO::PARAM_STR);
		//	 $idZasob = DB::getPDO()->fetchValue(" select ID from CRM_LISTA_ZASOBOW where `DESC` = {$sqlNs} and `TYPE` = 'TABELA' and A_STATUS in('WAITING', 'NORMAL') ");
		//	 if (!$idZasob) {
		//	 DBG::nicePrint($ns, "TODO: insert zasob PARENT_ID = ?");
		//	 }
		// }

		SchemaVersionUpgrade::fixSystemObjectCoreTablesStructInstalled();
	}
	function _updateDefaultObjectsStorageAclCache($idSource) {
		$clsFiles = array_map(function ($clsFile) {
			return substr($clsFile, strlen(APP_PATH_LIB . "/Schema/"), -1 * strlen('StorageAcl.php'));
			// return str_replace('/', '_', substr($clsFile, strlen(APP_PATH_LIB . "/Schema/"), -1 * strlen('StorageAcl.php')));
		}, array_merge(
			glob(APP_PATH_LIB . "/Schema/*StorageAcl.php", GLOB_NOSORT),
			glob(APP_PATH_LIB . "/Schema/*/*StorageAcl.php", GLOB_NOSORT)
		));
		DBG::log($clsFiles, 'array', "DBG glob default_objects");
		foreach ($clsFiles as $clsName) {
			try {
				$acl = SchemaFactory::loadDefaultObject($clsName);
				$namespace = $acl->getNamespace();
				DB::getPDO()->insertOrUpdate($this->_rootTableName, [
					'namespace' => $namespace,
					'idDatabase' => $idSource,
					'_type' => "StorageAcl",
					'_rootTableName' => $acl->getRootTableName(),
					'hasStruct' => 1
				]);
			} catch (Exception $e) {
				UI::alert('danger', $e->getMessage());
			}
		}
		DB::getPDO()->execSql("
			insert into `{$this->_rootTableName}` (namespace, idZasob, idDatabase, description, hasStruct)
			select concat('{$source['nsPrefix']}/', t.`DESC`)
				, t.ID as idZasob
				, '{$idSource}' as idDatabase
				, t.`OPIS` as description
				, 1 as hasStruct
			from CRM_LISTA_ZASOBOW t
			where t.`TYPE` = 'TABELA'
				and t.A_STATUS in('NORMAL', 'WAITING')
				and t.PARENT_ID = {$idSource}
				and t.`DESC` not like '%/%'
			on duplicate key update idZasob = t.ID
									, hasStruct = 1
		");
	}
	function _updateDatabaseCache($source) {
		$dbName = DB::getPDO($source['idZasob'])->getDatabaseName();
		$dbType = DB::getPDO($source['idZasob'])->getType();
		switch ($dbType) {
			case 'mysql': return $this->_updateDatabaseMysqlCache($source, $dbName, $dbType);
			default: throw new AlertWarningException("Not imeplemented db type '{$dbType}': { id: {$source['idZasob']}, nsPrefix: '{$source['nsPrefix']}', dbName: '{$dbName}', dbType: <b>'{$dbType}'</b>}");
		}
	}
	function _updateDatabaseMysqlCache($source, $dbName) {
		// TODO: if another DB split select and insert
		DB::getPDO()->execSql("
			insert into `{$this->_rootTableName}` (namespace, idDatabase, _rootTableName, _type, description, hasStruct, isStructInstalled)
			select concat('{$source['nsPrefix']}/', t.TABLE_NAME) as namespace
				, '{$source['idZasob']}' as idDatabase
				, t.TABLE_NAME as _rootTableName
				, 'TableAcl' as _type
				, t.TABLE_COMMENT as description
				, 1 as hasStruct
				, 1 as isStructInstalled
			from INFORMATION_SCHEMA.TABLES t
			where t.TABLE_SCHEMA = '{$dbName}'
				and t.TABLE_NAME not like '%#%'
			on duplicate key update _rootTableName = t.TABLE_NAME
				, hasStruct = 1
				, isStructInstalled = 1
		");
		DB::getPDO()->execSql("
			insert into `{$this->_rootTableName}` (namespace, idZasob, idDatabase, description, hasStruct)
			select IF(t.`DESC` like 'default_db/%',
					t.`DESC`,
					concat('{$source['nsPrefix']}/', t.`DESC`)
				) as namespace
				, t.ID as idZasob
				, '{$source['idZasob']}' as idDatabase
				, t.`OPIS` as description
				, 1 as hasStruct
			from CRM_LISTA_ZASOBOW t
			where t.`TYPE` = 'TABELA'
				and t.A_STATUS in('NORMAL', 'WAITING')
				and t.PARENT_ID = {$source['idZasob']}
			on duplicate key update idZasob = t.ID
				, hasStruct = 1
		");
	}
	function _updateAntObjectCache($buildXmlPath, $basePath) {
		// format: "{$basePath}/{prefix}.{rootTableName}/{objectName}/build.xml"
		// regex: ^([a-zA-Z_]*)\.([a-zA-Z_]*)\/([a-zA-Z_]*)$
		// example: SE/schema/ant-object/default_db.test_perms/TestPermsAnt/build.xml
		$relativePath = substr($buildXmlPath, strlen("{$basePath}/")); // expected: "{prefix}.{rootTableName}/{objectName}/build.xml"
		$ret = preg_match_all('/^([0-9a-zA-Z_]*)\.([0-9a-zA-Z_]*)\/([0-9a-zA-Z_-]*)\/build\.xml$/', $relativePath, $matches, PREG_SET_ORDER);
		if (!$ret) throw new Exception("Syntax error in ant acl path: {$relativePath}");
		$antInfo = [
			'sourceName' => $matches[0][1],
			'rootTableName' => $matches[0][2],
			'objectName' => $matches[0][3],
		];
		DBG::nicePrint($antInfo, "relativePath({$relativePath})");

		$idDatabase = DB::getPDO($antInfo['sourceName'])->getZasobId();
		$namespace = "{$antInfo['sourceName']}/{$antInfo['rootTableName']}/{$antInfo['objectName']}";
		DB::getPDO()->insertOrUpdate($this->_rootTableName, [
			'namespace' => $namespace,
			'idDatabase' => $idDatabase,
			'_type' => "AntAcl",
			'_rootTableName' => $antInfo['rootTableName'],
			'hasStruct' => 1
		]);
	}

	public function _parseWhere($params = []) {
		$sqlWhere = [];
		DBG::log($params, 'array', "SystemObject::_parseWhere");
		if (!empty($params['#refFrom'])) {
			// '#refFrom' => [
			//	 'namespace' => 'default_objects/SystemSource',
			//	 'primaryKey' => $sourceItem['idZasob']
			// ]
			if (empty($params['#refFrom']['namespace'])) throw new Exception("Missing refFrom/namespace");
			if (empty($params['#refFrom']['primaryKey'])) throw new Exception("Missing refFrom/primaryKey");

			if ('default_objects/SystemSource' != $params['#refFrom']['namespace']) throw new Exception("Unsupported refFrom/namespace '{$params['#refFrom']['namespace']}'");
			$sqlWhere[] = "t.idDatabase = " . DB::getPDO()->quote($params['#refFrom']['primaryKey'], PDO::PARAM_INT);
		}
		{
			$filterParams = [];
			$xsdFields = $this->getXsdTypes();
			foreach ($params as $k => $v) {
				if ('f_' != substr($k, 0, 2)) continue;
				$fieldName = substr($k, 2);
				if (!array_key_exists($fieldName, $xsdFields)) {
					// TODO: check query by xpath or use different param prefix
					throw new Exception("Field '{$fieldName}' not found in '{$this->_namespace}'");
				}
				if ('p5:www_link' == $xsdFields[$fieldName]) {
					continue;
				}
				$filterParams[$fieldName] = $v;
			}
		}
		if (!empty($filterParams)) {
			DBG::log($filterParams, 'array', "SystemObject::_parseWhere TODO \$filterParams");
			foreach ($filterParams as $fieldName => $value) {
				if (is_array($value)) {
					DBG::log($value, 'array', "TODO SystemObject::_parseWhere array value for \$filterParams[{$fieldName}]");
				} else if (is_scalar($value)) {
					if ('=' == substr($value, 0, 1)) {
						$sqlWhere[] = "t.{$fieldName} = " . DB::getPDO()->quote(substr($value, 1), PDO::PARAM_STR);
					} else {
						$sqlWhere[] = "t.{$fieldName} like " . DB::getPDO()->quote("%{$value}%", PDO::PARAM_STR);
					}
				} else {
					DBG::log($value, 'array', "BUG SystemObject::_parseWhere unknown type for \$filterParams[{$fieldName}]");
				}
			}
		}
		return (!empty($sqlWhere)) ? "where " . implode(" and ", $sqlWhere) : '';
	}

	public function getTotal($params = []) {
		$sqlWhere = $this->_parseWhere($params);
		return DB::getPDO()->fetchValue("
			select count(1) as cnt
			from `{$this->_rootTableName}` t
			{$sqlWhere}
		");
	}

	public function clearGetItemCache($pk = null) {
		if (!$this->_cache) return;
		if (!$pk) $this->_cache = [];
		else if (array_key_exists($pk, $this->_cache)) unset($this->_cache[$pk]);
	}
	public function getItem($pk, $params = []) {
		// TODO: ceche query for: $pk = 'default_db/CRM_PROCES/PROCES', $params = [ 'propertyName' => "*,field" ]
		$pk = ACL::getBaseNamespace($pk);
		if (!$this->_cache) $this->_cache = [];
		if (1 === count($params) && "*,field" === V::get('propertyName', '', $params)) {
			if (array_key_exists($pk, $this->_cache)) return $this->_cache[$pk];
			$this->_cache[$pk] = $this->_fetchItem($pk, $params);
		} else {
			return $this->_fetchItem($pk, $params);
		}
		return $this->_cache[$pk];
	}

	public function _fetchItem($pk, $params = []) {
		if (!$pk) throw new Exception("Missing primary key '{$this->_namespace}'");
		$pkField = $this->getSqlPrimaryKeyField();
		if (!$pkField) throw new Exception("Missing primary key field defined in '{$this->_namespace}'");
		$sqlPk = DB::getPDO()->quote($pk, PDO::PARAM_STR);
		$item = DB::getPDO()->fetchFirst("
			select t.*
			from `{$this->_rootTableName}` t
			where t.`{$pkField}` = {$sqlPk}
		");
		if (!$item) throw new Exception("Item '{$pk}' not exists - type '{$this->_namespace}'");
		return $this->buildFeatureFromSqlRow($item, $params);
	}

	public function getItems($params = []) {
		$sqlWhere = $this->_parseWhere($params);

		$currSortCol = V::get('order_by', 'idZasob', $params);
		$currSortFlip = strtolower(V::get('order_dir', 'desc', $params));
		// TODO: validate $currSortCol is in field list
		// TODO: validate $currSortFlip ('asc' or 'desc')
		$xsdFields = $this->getXsdTypes();
		if (!array_key_exists($currSortCol, $xsdFields)) throw new Exception("Field '{$currSortCol}' not found in '{$this->_namespace}'");
		if (!in_array($currSortFlip, ['asc', 'desc'])) throw new Exception("Sort dir not allowed");
		$sqlOrderBy = "order by t.`{$currSortCol}` {$currSortFlip}";

		$limit = V::get('limit', 0, $params, 'int');
		$limit = ($limit < 0) ? 0 : $limit;
		$offset = V::get('limitstart', 0, $params, 'int');
		$offset = ($offset < 0) ? 0 : $offset;
		$sqlLimit = ($limit > 0)
		? "limit {$limit} offset {$offset}"
		: '';

		Lib::loadClass('AclQueryItems');
		$query = new AclQueryItems($this);
		$query->setParams($params);
		$query->setSource('default_db');
		$query->setRawSql("
			select t.*
			from `{$this->_rootTableName}` t
			{$sqlWhere}
			{$sqlOrderBy}
			{$sqlLimit}
		");
		return $query->fetchAll();
	}

	public function buildFeatureFromSqlRow($item, $params = []) {
		DBG::log($params, 'array', "buildFeatureFromSqlRow... '{$item['namespace']}'");
		$exNs = explode('/', $item['namespace']);
		$item['name'] = array_pop($exNs);
		$item['nsPrefix'] = implode('__x3A__', $exNs);
		$item['typeName'] = implode('__x3A__', $exNs) . ':' . $item['name'];
		$item['reinstallLink'] = Router::getRoute('Storage_AclReinstall')->getLink('', [ 'namespace' => $item['namespace'] ]);
		if (!empty($params['propertyName'])) {
			if (is_string($params['propertyName'])) $params['propertyName'] = explode(',', $params['propertyName']);
			if (!is_array($params['propertyName'])) throw new Exception("Wrong param propertyName - expected array or string");
			foreach ($params['propertyName'] as $fetchField) {
				if ('*' == $fetchField) continue;
				if ('field' == $fetchField) {
					$item['field'] = SchemaFactory::loadDefaultObject('SystemObjectField')->getItems([
						'__backRef' => [
							'namespace' => 'default_objects/SystemObject',
							'primaryKey' => $item['namespace']
						],
						'order_by' => 'sortPrio',
						'order_dir' => 'asc',
					]);
				}
			}
		}
		return $item;
	}

	public function updateItem($itemPatch) { // @required [ 'namespace' => ... ] (primaryKey)
		$pkField = $this->getPrimaryKeyField();
		$pk = V::get($pkField, null, $itemPatch);
		if (null === $pk) throw new Exception("BUG missing primary key field for '{$this->_namespace}' updateItem");
		$this->clearGetItemCache($pk);
		DBG::log(['updateItem $itemPatch', $itemPatch]);
		unset($itemPatch[$pkField]);
		if (empty($itemPatch)) return 0;
		foreach ($itemPatch as $fieldName => $value) {
			if ('isStructInstalled' == $fieldName) continue;
			if ('isObjectActive' == $fieldName) continue;
			if ('primaryKey' == $fieldName) continue;
			if ('appInfo' == $fieldName) continue;
			throw new Exception("Update field '{$fieldName}' not allowed for '{$this->_namespace}'");
		}
		return DB::getPDO()->update($this->_rootTableName, $pkField, $pk, $itemPatch);
	}

	static function deleteObjectFromCache($idZasob, $namespace) {
		if (!$idZasob) throw new Exception("Missing idZasob in deleteObjectFromCache");
		if (!$namespace) throw new Exception("Missing namespace in deleteObjectFromCache");
		DB::getPDO()->execSql("
			DELETE from `CRM_#CACHE_ACL_OBJECT` where idZasob = :id_zasob
		", [
			':id_zasob' => $idZasob,
		]);
		DB::getPDO()->execSql("
			DELETE from `CRM_#CACHE_ACL_OBJECT_FIELD` where objectNamespace = :namespace
		", [
			':namespace' => $namespace,
		]);
		DB::getPDO()->update('CRM_LISTA_ZASOBOW', 'ID', $idZasob, [
			'PARENT_ID' => -1,
			'A_STATUS' => "DELETED",
			'A_RECORD_UPDATE_AUTHOR' => "update-acl-cache",
			'A_RECORD_UPDATE_DATE' => "NOW()",
		]);
	}
}